Date函数处理

最新推荐文章于 2024-01-31 10:32:31 发布
原创最新推荐文章于 2024-01-31 10:32:31 发布 · 298 阅读
0 ·
CC 4.0 BY-SA版权
文章标签：
#java #date
本文介绍了一个实用的Java日期时间操作工具类，提供了多种日期时间格式化、转换及计算的功能，如获取当前时间、日期加减、计算时间差等，并支持不同格式的日期字符串转换。
package com.common.util.core;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import com.hlq.common.util.constant.CommonConstant;
import com.hlq.hessian.service.SystemResourceUtil;

/**
 * @类说明：
 */
public class DateUtil {
	/**
	 * @函数名称：getCurrentDateSimpleStr
	 * @功能描述：获取yyyyMMdd格式时间
	 * @return String -返回转换后的字符串
	 */
	public static String getCurrentDateSimpleStr() {
		SimpleDateFormat dataFormat = new SimpleDateFormat(CommonConstant.DATE_SHORT_SIMPLE_FORMAT);
		Date date = new Date();
		return dataFormat.format(date);
	}

	/**
	 * @函数名称：getCurrentTimeSimpleStr
	 * @功能描述：获取yyyyMMdd格式时间
	 * @return String -返回转换后的字符串
	 */
	public static String getCurrentTimeSimpleStr() {
		SimpleDateFormat dataFormat = new SimpleDateFormat(CommonConstant.TIME_SHORT_SIMPLE_FORMAT);
		Date date = new Date();
		return dataFormat.format(date);
	}

	/**
	 * @函数名称：getCurrentDateMonthStr
	 * @功能描述：获取MM.dd格式时间
	 * @return String -返回转换后的字符串
	 */
	public static String getCurrentDateMonthStr() {
		SimpleDateFormat dataFormat = new SimpleDateFormat(CommonConstant.DATE_MONTH_FORMAT);
		Date date = new Date();
		return dataFormat.format(date);
	}

	/**
	 * @函数名称：getCurrentTimeCHNStr
	 * @功能描述：获取yyyy年MM月dd日 HH:mm:ss格式时间
	 * @return String -返回转换后的字符串
	 */
	public static String getCurrentTimeCHNStr() {
		SimpleDateFormat dataFormat = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_CHN_FORMAT);
		Date date = new Date();
		return dataFormat.format(date);
	}

	/**
	 * @函数名称：getCurrentDateCHNStr
	 * @功能描述：获取yyyy年MM月dd日 格式时间
	 * @return String -返回转换后的字符串
	 */
	public static String getCurrentDateCHNStr() {
		SimpleDateFormat dataFormat = new SimpleDateFormat(CommonConstant.DATE_SHORT_CHN_FORMAT);
		Date date = new Date();
		return dataFormat.format(date);
	}

	/**
	 * 
	 * @Title: getCurrentTimeStr
	 * @Description: 获取当前时间yyyy-MM-dd HH:mm:ss
	 * @param @return 参数
	 * @return String 返回类型
	 * @throws
	 */
	public static String getCurrentTimeStr() {
		SimpleDateFormat dataFormat = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		Date date = new Date();
		return dataFormat.format(date);
	}

	/**
	 * 
	 * @Title: getCurrentDateStr
	 * @Description: 获取当前时间yyyy-MM-dd
	 * @param @return 参数
	 * @return String 返回类型
	 * @throws
	 */
	public static String getCurrentDateStr() {
		SimpleDateFormat dataFormat = new SimpleDateFormat(CommonConstant.DATE_SHORT_FORMAT);
		Date date = new Date();
		return dataFormat.format(date);
	}

	/**
	 * 将给定应用服务器日期按照给定格式化类型转换成字符串
	 * 
	 * @param date
	 *            -java日期对象
	 * @param format
	 *            -日期格式化类型
	 * @return String -返回转换后的字符串
	 */
	public static String dateToString(Date date, String format) {
		if (MethodUtil.isEmpty(date))
			date = new Date();
		if (MethodUtil.isEmpty(format))
			format = CommonConstant.DATE_WITHMILLISECOND_FORMAT;
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(date);
	}

	/**
	 * 将给定应用服务器日期按照默认格式化类型转换成字符串
	 * 
	 * @param date
	 *            -java日期对象
	 * @return String -返回转换后的字符串
	 */
	public static String dateToString(Date date) {
		return dateToString(date, CommonConstant.DATE_WITHMILLISECOND_FORMAT);
	}

	/**
	 * 将应用服务器当前日期按照给定格式化类型转换成字符串
	 * 
	 * @param format
	 *            -日期格式化类型
	 * @return String -返回转换后的字符串
	 */
	public static String dateToString(String format) {
		return dateToString(new Date(), format);
	}

	/**
	 * 将应用服务器日期按照默认格式化类型转换成字符串
	 * 
	 * @return String -返回转换后的字符串
	 */

	public static String dateToString() {
		return dateToString(new Date(), CommonConstant.DATE_WITHMILLISECOND_FORMAT);
	}

	/**
	 * 将字符串转换成日期 注意：一定要选用匹配的格式，否则不能解析，将返回null
	 * 
	 * @param strDate
	 *            - 日期
	 * @param format
	 *            - 格式
	 * @return Date -转换后的日期
	 */
	public static Date stringToDate(String strDate, String format) {
		if (MethodUtil.isEmpty(strDate))
			return null;
		if (MethodUtil.isEmpty(format))
			format = CommonConstant.DATE_SHORT_FORMAT;
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		try {
			return sdf.parse(strDate);
		} catch (ParseException e) {
			return null;
		}
	}

	/**
	 * 将字符串转换成日期，默认格式：yyyy-MM-dd
	 * 
	 * @param strDate
	 *            - 日期
	 * @return Date -转换后的日期
	 */
	public static Date stringToDate(String strDate) {
		if (MethodUtil.isEmpty(strDate))
			return null;
		return stringToDate(strDate, CommonConstant.DATE_SHORT_FORMAT);
	}

	/**
	 * 获取指定日期偏移delayDays后的日期
	 * 
	 * @param startDate
	 *            -开始日期
	 * @param delayDays
	 *            -延迟的天数
	 * @return Date -转换后的日期
	 */
	public static Date getDateAfterDays(Date startDate, int delayDays) {
		if (MethodUtil.isEmpty(startDate))
			return null;
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		c.add(Calendar.DAY_OF_MONTH, delayDays);
		return c.getTime();
	}

	/**
	 * 获取当前日期（没转化格式）
	 * 
	 * @return Date -转换后的日期
	 */
	public static Date getCurrentDate() {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.HOUR_OF_DAY, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		return c.getTime();
	}

	/**
	 * 获取当前时间，精确到秒（没转化格式）
	 * 
	 * @return Date -转换后的日期
	 */
	public static Date getCurrentTime() {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.MILLISECOND, 0);
		return c.getTime();
	}

	/**
	 * 设置开始日期时分秒格式 00:00:00
	 * 
	 * @param date
	 *            -日期
	 * @return Date -转换后的日期
	 */
	public static Date setSatrtDate(Date date) {
		if (MethodUtil.isEmpty(date))
			return null;
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.HOUR_OF_DAY, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		return c.getTime();
	}

	/**
	 * 设置结束日期时分秒格式 23:59:59
	 * 
	 * @param date
	 *            -日期
	 * @return Date -转换后的日期
	 */
	public static Date setEndDate(Date date) {
		if (MethodUtil.isEmpty(date))
			return null;
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		return c.getTime();
	}

	/**
	 * 获取当前年份-短
	 * 
	 * @return String -当前年份
	 */
	public static String getCurrentYear() {
		Calendar c = Calendar.getInstance();
		String year = Integer.toString(c.get(Calendar.YEAR));
		year = year.substring(2);
		return year;
	}

	/**
	 * 获取当前月份
	 * 
	 * @return String -当天月份
	 */
	public static String getCurrentMonth() {
		Calendar c = Calendar.getInstance();
		String month = Integer.toString(c.get(Calendar.MONTH) + 1);
		if (month.length() < 2)
			month = "0" + month;
		return month;
	}

	/**
	 * 获取当天日期
	 * 
	 * @return String -日期
	 */
	public static String getCurrentDay() {
		Calendar c = Calendar.getInstance();
		String date = Integer.toString(c.get(Calendar.DATE));
		if (date.length() < 2)
			date = "0" + date;
		return date;
	}

	/**
	 * 获取指定时间的前一天的指定类型日期
	 * 
	 * @param date
	 * @param format
	 * @return String
	 */
	public static String getBeforeDay(String date, String format) {
		if (MethodUtil.isEmpty(date))
			return null;
		if (MethodUtil.isEmpty(format))
			format = CommonConstant.DATE_SHORT_FORMAT;
		Calendar c = Calendar.getInstance();
		c.clear();
		c.setTime(stringToDate(date));
		c.add(Calendar.DATE, -1);
		SimpleDateFormat myFormatter = new SimpleDateFormat(format);
		return myFormatter.format(c.getTime());
	}

	/**
	 * 获取指定时间的前一天的默认类型日期
	 * 
	 * @param date
	 * @param format
	 * @return String
	 */
	public static String getBeforeDay(String date) {
		return getBeforeDay(date, CommonConstant.DATE_WITHMILLISECOND_FORMAT);
	}

	/**
	 * 获取指定时间的后一天的指定类型日期
	 * 
	 * @param date
	 * @param format
	 * @return String
	 */
	public static String getAfterDay(String date, String format) {
		if (MethodUtil.isEmpty(date))
			return null;
		if (MethodUtil.isEmpty(format))
			format = CommonConstant.DATE_SHORT_FORMAT;
		Calendar c = Calendar.getInstance();
		c.clear();
		c.setTime(stringToDate(date));
		c.add(Calendar.DATE, 1);
		SimpleDateFormat myFormatter = new SimpleDateFormat(format);
		return myFormatter.format(c.getTime());
	}

	/**
	 * 获取指定时间的后一天的默认类型日期
	 * 
	 * @param date
	 * @param format
	 * @return String
	 */
	public static String getAfterDay(String date) {
		return getAfterDay(date, CommonConstant.DATE_WITHMILLISECOND_FORMAT);
	}

	/**
	 * 获取指定时间前一天的最后时间的固定类型日期 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param String
	 * @return String
	 */
	public static String getBeforeDayLastTime(String date) {
		if (MethodUtil.isEmpty(date))
			return null;
		return dateToString(setEndDate(stringToDate(getBeforeDay(date))), CommonConstant.DATE_WITHSECOND_FORMAT);
	}

	/**
	 * 获取指定时间前一天的最后时间的固定类型日期 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param String
	 * @return Date
	 */
	public static Date getBeforeDayLastTime(Date date) {
		if (MethodUtil.isEmpty(date))
			return null;
		return setEndDate(stringToDate(getBeforeDay(dateToString(date, CommonConstant.DATE_WITHSECOND_FORMAT))));
	}

	/**
	 * 获取指定时间后一天的开始时间的固定类型日期 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param String
	 * @return String
	 */
	public static String getAfterDayFirstTime(String date) {
		if (MethodUtil.isEmpty(date))
			return null;
		return dateToString(setSatrtDate(stringToDate(getAfterDay(date))), CommonConstant.DATE_WITHSECOND_FORMAT);
	}

	/**
	 * 获取指定时间后一天的开始时间的固定类型日期 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param String
	 * @return Date
	 */
	public static Date getAfterDayFirstTime(Date date) {
		if (MethodUtil.isEmpty(date))
			return null;
		return setSatrtDate(stringToDate(getAfterDay(dateToString(date, CommonConstant.DATE_WITHSECOND_FORMAT))));
	}

	/**
	 * 根据一个日期，返回是星期几的字符串
	 * 
	 * @param sdate
	 * @return String
	 */
	public static String getWeek(String date) {
		if (MethodUtil.isEmpty(date))
			return null;
		Date sdate = stringToDate(date, CommonConstant.DATE_SHORT_FORMAT);
		Calendar c = Calendar.getInstance();
		c.setTime(sdate);

		return new SimpleDateFormat("EEEE").format(c.getTime());
	}

	/**
	 * 两个时间之间的天数
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 * @throws ParseException
	 */
	public static long getDays(String date1, String date2) throws ParseException {
		if (MethodUtil.isEmpty(date1))
			return 0;
		if (MethodUtil.isEmpty(date2))
			return 0;
		// 转换为标准时间
		SimpleDateFormat myFormatter = new SimpleDateFormat(CommonConstant.DATE_SHORT_FORMAT);
		Date date = null;
		Date mydate = null;

		date = myFormatter.parse(date1);
		mydate = myFormatter.parse(date2);
		long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
		return (new BigDecimal(day).abs()).longValue();
	}

	/**
	 * 两个时间之间的天数
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 * @throws ParseException
	 */
	public static int getDays(Date date1, Date date2) {
		Calendar aCalendar = Calendar.getInstance();
		aCalendar.setTime(date1);
		int day1 = aCalendar.get(Calendar.DAY_OF_YEAR);

		Calendar bCalendar = Calendar.getInstance();
		bCalendar.setTime(date2);
		int day2 = bCalendar.get(Calendar.DAY_OF_YEAR);

		return day2 - day1;
	}

	public static long getHours(String date1, String date2) throws ParseException {
		if (MethodUtil.isEmpty(date1))
			return 0;
		if (MethodUtil.isEmpty(date2))
			return 0;
		// 转换为标准时间
		SimpleDateFormat myFormatter = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		Date date = null;
		Date mydate = null;

		date = myFormatter.parse(date1);
		mydate = myFormatter.parse(date2);
		long hours = (date.getTime() - mydate.getTime()) % (24 * 60 * 60 * 1000) / (60 * 60 * 1000);
		return (new BigDecimal(hours).abs()).longValue();
	}

	public static long getMinutes(String date1, String date2) throws ParseException {
		if (MethodUtil.isEmpty(date1))
			return 0;
		if (MethodUtil.isEmpty(date2))
			return 0;
		// 转换为标准时间
		SimpleDateFormat myFormatter = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		Date date = null;
		Date mydate = null;

		date = myFormatter.parse(date1);
		mydate = myFormatter.parse(date2);
		long minutes = (date.getTime() - mydate.getTime()) % (60 * 60 * 1000) / (60 * 1000);
		return (new BigDecimal(minutes).abs()).longValue();
	}

	public static long getSeconds(String date1, String date2) throws ParseException {
		if (MethodUtil.isEmpty(date1))
			return 0;
		if (MethodUtil.isEmpty(date2))
			return 0;
		// 转换为标准时间
		SimpleDateFormat myFormatter = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		Date date = null;
		Date mydate = null;

		date = myFormatter.parse(date1);
		mydate = myFormatter.parse(date2);
		long seconds = (date.getTime() - mydate.getTime()) % (60 * 1000) / 1000;
		return (new BigDecimal(seconds).abs()).longValue();
	}

	/**
	 * 两个时间之间相差的分钟数
	 * 
	 * @param date1
	 * @param date2
	 * @return 正数：date1 在 date2 之前<br>
	 *         负数：date1 在 date2 之后<br>
	 *         注：date1 或 date2 为空时返回0<br>
	 */
	public static long getMinutes(Date date1, Date date2) {
		// 转换为标准时间
		if (date1 == null || date2 == null) {
			return 0;
		}
		return (date2.getTime() - date1.getTime()) / (60 * 1000);
	}

	/**
	 * 两个时间之间相差的秒数
	 * 
	 * @param date1
	 * @param date2
	 * @return 正数：date1 在 date2 之前<br>
	 *         负数：date1 在 date2 之后<br>
	 *         注：date1 或 date2 为空时返回0<br>
	 */
	public static long getSeconds(Date date1, Date date2) {
		// 转换为标准时间
		if (date1 == null || date2 == null) {
			return 0;
		}
		return (date2.getTime() - date1.getTime()) / 1000;
	}

	/**
	 * 给定一个年份判断该年份是否为闰年
	 * 
	 * @param year
	 * @return false:不是闰年 true:闰年
	 */
	public static boolean isLeapYear(int year) {
		GregorianCalendar calendar = new GregorianCalendar();
		return calendar.isLeapYear(year);
	}

	/**
	 * 获取数据库时间
	 * 
	 * @return String
	 * @throws Exception
	 * @throws AGPException
	 */
	public static Date getDBTime() throws Exception {
		return SystemResourceUtil.getInstance().getDBTime();
	}

	/**
	 * 获得当前时间, 格式yyyy-MM-dd HH:mm:ss
	 * 
	 * @return
	 */
	public static String getNowTime() {
		Date date = new Date();
		SimpleDateFormat format = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		return format.format(date);
	}

	/**
	 * 方法描述: 获取当前时间，返回Timestamp对象
	 * 
	 * @return
	 * @throws Exception
	 * @return Timestamp
	 */
	public static Timestamp getCurrentTimestamp() {
		return new Timestamp(System.currentTimeMillis());
	}

	/**
	 * 方法描述: 获取当前后几秒时间，返回Timestamp对象
	 * 
	 * @return
	 * @throws Exception
	 * @return Timestamp
	 */
	public static Timestamp getCurrentTimestampAddSecond(int second) {
		return new Timestamp(System.currentTimeMillis() + second * 1000);
	}

	/**
	 * 获取日期方法
	 * 
	 * @param type
	 *            0:yyyy-MM-dd HH:mm:ss 1:yyyyMMddHHmmss 2:yyyyMMdd
	 * @param formatStr
	 *            日期格式
	 * @return String
	 */
	public static String getDate(int type, String formatStr) {
		Date date = new Date();
		SimpleDateFormat sdf = null;
		if (null != formatStr) {
			sdf = new SimpleDateFormat(formatStr);
		} else if (type == 0) {
			sdf = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		} else if (type == 1) {
			sdf = new SimpleDateFormat(CommonConstant.DATE_WITH_FORMAT);
		} else if (type == 2) {
			sdf = new SimpleDateFormat(CommonConstant.DATE_SHORT_SIMPLE_FORMAT);
		}
		String str = sdf.format(date);
		return str;
	}

	/**
	 * 时间差
	 * 
	 * @param current_time
	 *            当前时间
	 * @param compare_time
	 *            比较时间
	 * @return long
	 */
	public static long getDateCompare(String current_time, String compare_time) {
		SimpleDateFormat sf = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		long time = 0;
		try {
			Date c_tiem = sf.parse(current_time);
			Date com_time = sf.parse(compare_time);
			long l = c_tiem.getTime() - com_time.getTime() > 0 ? c_tiem.getTime() - com_time.getTime() : com_time.getTime() - c_tiem.getTime();
			time = l / 1000; // 算出超时秒数
		} catch (Exception e) {
			e.printStackTrace();
		}
		return time;
	}

	/**
	 * 处理时间的加减运算 60*60 为一个小时 60*60*24 为一天
	 * 
	 * @param startTime
	 * @param endTime
	 * @param type
	 *            0为加 1为减
	 * @return Date long
	 */
	public static long getDateAdd(String startTime, String endTime, int type) {
		long time = 0l;
		try {
			Date date = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT).parse(startTime);
			Date addLong = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT).parse(endTime);
			switch (type) {
			case 0:
				time = (date.getTime() / 1000) + (addLong.getTime() / 1000);
				break;
			case 1:
				time = (date.getTime() / 1000) - (addLong.getTime() / 1000);
				break;
			default:
				time = (date.getTime() / 1000) + (addLong.getTime() / 1000);
				break;
			}
			date.setTime(time * 1000);
			time = date.getTime();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return time;
	}

	/**
	 * 一个月最大day
	 * 
	 * @param time
	 *            时间
	 * @return obj[0]=maxMonth; obj[1]=time
	 */
	public static Object[] getMaxMonth(String time) {
		Object[] obj = new Object[2];
		Date date = null;
		try {
			date = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT).parse(time);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		Calendar a = Calendar.getInstance();
		a.setTime(date);
		a.set(Calendar.DATE, 1); // 把日期设置为当月第一天
		a.roll(Calendar.DATE, -1);// 日期回滚一天，也就是最后一天
		int maxMonth = a.get(Calendar.DATE);
		a.roll(Calendar.DATE, 1);
		time = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT).format(a.getTime());
		obj[0] = maxMonth;
		obj[1] = time;
		return obj;
	}

	/**
	 * 将long转成string 类型
	 * 
	 * @param lo
	 * @return
	 */
	public static String longToDateStr(long lo) {
		Date date = new Date(lo);
		SimpleDateFormat sd = new SimpleDateFormat(CommonConstant.DATE_WITHSECOND_FORMAT);
		return sd.format(date);
	}

	/**
	 * 将微信Unix时间戳long转成date类型
	 * 
	 * @param str
	 * @return
	 */
	public static Date longToDate(long lo) {
		return new Date(lo);
	}

	/**
	 * 获取去年的今天日期格式 默认格式 yyyy-MM-dd
	 * 
	 * @return
	 */
	public static String getTodayOfLastYear(String format) {
		if (MethodUtil.isEmpty(format)) {
			format = CommonConstant.DATE_SHORT_FORMAT;
		}

		SimpleDateFormat aSimpleDateFormat = new SimpleDateFormat(format);
		GregorianCalendar aGregorianCalendar = new GregorianCalendar();
		aGregorianCalendar.set(Calendar.YEAR, aGregorianCalendar.get(Calendar.YEAR) - 1);

		return aSimpleDateFormat.format(aGregorianCalendar.getTime());
	}

	/**
	 * 
	 * @Title: timestampToStr
	 * @Description: timestamp类型转换成string类型格式日期
	 * @param @param timestamp
	 * @param @param format
	 * @param @return 参数
	 * @return String 返回类型
	 * @throws
	 */
	public static String timestampToStr(Timestamp timestamp, String format) {
		if (StringUtil.isBlank(format)) {
			format = CommonConstant.DATE_SHORT_SIMPLE_FORMAT;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		String tsStr = sdf.format(timestamp);
		return tsStr;

	}
}