Java日期工具类

日期工具类

主要将平时用的最多的日期转换类收集起来，做一下整理，每个方法都有注释进行说明，直接可以复制，通过类名进行调用，有需要的可以看一下。

/**
 * 日期工具类, 继承org.apache.commons.lang.time.DateUtils类
 */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
	/**
	 * 日期精度，秒
	 */
	public static final int ACCURACY_SECOND = 1;
	/**
	 * 日期精度，分
	 */
	public static final int ACCURACY_MINUTE = 2;
	/**
	 * 日期精度，小时
	 */
	public static final int ACCURACY_HOUR = 3;
	/**
	 * 日期精度，天
	 */
	public static final int ACCURACY_DAY = 4;

	/**
	 * 日期精度，月
	 */
	public static final int ACCURACY_MONTH = 5;

	/**
	 * 日期精度，年
	 */
	public static final int ACCURACY_YEAR = 6;
	
	/**
	 * 默认的时间格式
	 */
	public static final String DEFAULT_TIME_PATTERN = "HH:mm:ss";
	public static final String  DEFAULT_TIME_HM = "HH:mm";

	/**
	 * 默认的日期格式
	 */
	private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";
	
	public static final String DEFAULT_DATE_MONTH = "yyyy年MM月";
	
	public static final String EN_GB_DATE_PATTERN = "dd/MM/yyyy";
	
	public static final String EN_GBA_DATE_PATTERN = "yyyy/MM/dd";

    public static String ZH_CN_DATE_PATTERN = "yyyy-MM-dd";

    public static String ZH_CN_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    
    public static String ZH_CN_DATETIME_PATTERN_NO_SS = "yyyy-MM-dd HH:mm";
    
    public static String ZH_CN_DTP_NO_HOR = "yyyyMMdd HH:mm:ss";
    
    public static String ZH_CN_DP_NO_HOR = "yyyyMMdd";
    
    public static String ZH_CN_DP_NO_TRIM = "yyyyMMddHHmmss";
	
    /**
	 * 比较用日期格式，精度为年
	 */
	private static final String ACCURACY_PATTERN_YEAR = "yyyy";

	/**
	 * 比较用日期格式，精度为月
	 */
	private static final String ACCURACY_PATTERN_MONTH = "yyyyMM";

	/**
	 * 比较用日期格式，精度为日
	 */
	private static final String ACCURACY_PATTERN_DAY = "yyyyMMdd";

	/**
	 * 比较用日期格式，精度为时
	 */
	private static final String ACCURACY_PATTERN_HOUR = "yyyyMMddHH";

	/**
	 * 比较用日期格式，精度为分
	 */
	private static final String ACCURACY_PATTERN_MINUTE = "yyyyMMddHHmm";

	/**
	 * 比较用日期格式，精度为秒
	 */
	private static final String ACCURACY_PATTERN_SECOND = "yyyyMMddHHmmss";
    
	private static String[] parsePatterns = {
		"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM", 
		"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
		"yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};

	/**
	 * 得到当前日期字符串 格式（yyyy-MM-dd）
	 */
	public static String getDate() {
		return getDate("yyyy-MM-dd");
	}
	
	/**
	 * 得到当前日期字符串 格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
	 */
	public static String getDate(String pattern) {
		return DateFormatUtils.format(new Date(), pattern);
	}
	
	/**
	 * 得到日期字符串 默认格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
	 */
	public static String formatDate(Date date, Object... pattern) {
		String formatDate = null;
		if (pattern != null && pattern.length > 0) {
			formatDate = DateFormatUtils.format(date, pattern[0].toString());
		} else {
			formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
		}
		return formatDate;
	}
	
	/**
	 * 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
	 */
	public static String formatDateTime(Date date) {
		return formatDate(date, "yyyy-MM-dd HH:mm:ss");
	}
	
	
	/**
	 * 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
	 */
	public static String formatDateT(Date date) {
		return formatDate(date, "yyyy-MM-dd");
	}

	/**
	 * 得到当前时间字符串 格式（HH:mm:ss）
	 */
	public static String getTime() {
		return formatDate(new Date(), "HH:mm:ss");
	}

	/**
	 * 得到当前日期和时间字符串 格式（yyyy-MM-dd HH:mm:ss）
	 */
	public static String getDateTime() {
		return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 得到当前年份字符串 格式（yyyy）
	 */
	public static String getYear() {
		return formatDate(new Date(), "yyyy");
	}

	/**
	 * 得到当前月份字符串 格式（MM）
	 */
	public static String getMonth() {
		return formatDate(new Date(), "MM");
	}

	/**
	 * 得到当天字符串 格式（dd）
	 */
	public static String getDay() {
		return formatDate(new Date(), "dd");
	}

	/**
	 * 得到当前星期字符串 格式（E）星期几
	 */
	public static String getWeek() {
		return formatDate(new Date(), "E");
	}
	
	/**
	 * 日期型字符串转化为日期 格式
	 * { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", 
	 *   "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm",
	 *   "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm" }
	 */
	public static Date parseDate(Object str) {
		if (str == null){
			return null;
		}
		try {
			return parseDate(str.toString(), parsePatterns);
		} catch (ParseException e) {
			return null;
		}
	}

	/**
	 * 获取过去的天数
	 * @param date
	 * @return
	 */
	public static long pastDays(Date date) {
		long t = new Date().getTime()-date.getTime();
		return t/(24*60*60*1000);
	}

	/**
	 * 获取过去的小时
	 * @param date
	 * @return
	 */
	public static long pastHour(Date date) {
		long t = new Date().getTime()-date.getTime();
		return t/(60*60*1000);
	}
	
	/**
	 * 获取过去的分钟
	 * @param date
	 * @return
	 */
	public static long pastMinutes(Date date) {
		long t = new Date().getTime()-date.getTime();
		return t/(60*1000);
	}
	
	/**
	 * 转换为时间（天,时:分:秒.毫秒）
	 * @param timeMillis
	 * @return
	 */
    public static String formatDateTime(long timeMillis){
		long day = timeMillis/(24*60*60*1000);
		long hour = (timeMillis/(60*60*1000)-day*24);
		long min = ((timeMillis/(60*1000))-day*24*60-hour*60);
		long s = (timeMillis/1000-day*24*60*60-hour*60*60-min*60);
		long sss = (timeMillis-day*24*60*60*1000-hour*60*60*1000-min*60*1000-s*1000);
		return (day>0?day+",":"")+hour+":"+min+":"+s+"."+sss;
    }
	
	/**
	 * 获取两个日期之间的天数
	 * 
	 * @param before
	 * @param after
	 * @return
	 */
	public static double getDistanceOfTwoDate(Date before, Date after) {
		long beforeTime = before.getTime();
		long afterTime = after.getTime();
		return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
	}
	
	/**
	 * 返回前后两个日期之间的小时差
	 * 
	 * @param before 前日期
	 * @param after 后日期
	 * @param decimalPlace 返回结果所保留的小数点位数，取值范围{0, 1, 2, 3, 4}，
	 *                     表示保留小数点后{0位（即整数），1位， 2位， 3位}
	 *                     取 4 时是特殊情况，是保留小数点后一位的小数，并且小数点后的数只会是 0 或 5 。
	 *                     即只会是整数或几点五的小数。例：1.0，2.5, 4.0
	 * @return String
	 */
	public static String getHourDifferentOfTwoDate(Date before, Date after, int decimalPlace) {
		String[] decimalArr = {"0", "0.0", "0.00", "0.000"};
		DecimalFormat decimalFormat;
		if (decimalPlace == 4) {
			decimalFormat = new DecimalFormat("0.00");
		} else {
			decimalFormat = new DecimalFormat(decimalArr[decimalPlace]);
		}
		
		long beforeTime = before.getTime();
		long afterTime = after.getTime();
		double differentValue = (double)(afterTime - beforeTime) / (1000 * 60 * 60);
		String differentStr = decimalFormat.format(differentValue);
		if (decimalPlace == 4) {
			String beforePoint = differentStr.substring(0, differentStr.indexOf("."));
			String afterPoint = differentStr.substring(differentStr.indexOf(".") + 1,differentStr.indexOf(".") + 2);
			int afterValue = Integer.valueOf(afterPoint);
			if (afterValue >= 5) {
				afterValue = 5;
			} else {
				afterValue = 0;
			}
			afterPoint = String.valueOf(afterValue);
			differentStr = beforePoint + "." + afterPoint;
		}
		return differentStr;
	}
	
	/**
	 * 获取两个日期区间的所有日期的集合（不包含这两个日期）
	 * 
	 * @return List<String>
	 */
	public static List<String> listDatesBetweenTwoDate(Date startDate, Date endDate, String dateFormat) {
		List<String> result = new ArrayList<>();
		SimpleDateFormat sDateFormat = new SimpleDateFormat(dateFormat);
		
	    Calendar tempStart = Calendar.getInstance();
	    tempStart.setTime(startDate);
	    tempStart.add(Calendar.DAY_OF_YEAR, 1);
	    
	    Calendar tempEnd = Calendar.getInstance();
	    tempEnd.setTime(endDate);
	    while (tempStart.before(tempEnd)) {
	    	if (tempStart.get(Calendar.DAY_OF_YEAR) < tempEnd.get(Calendar.DAY_OF_YEAR)) {
	    		result.add(sDateFormat.format(tempStart.getTime()));
			}
	        tempStart.add(Calendar.DAY_OF_YEAR, 1);
	    }
	    return result;
	}
	
	/**
	 * 获取两个日期区间的所有日期的集合（不包含这两个日期）
	 * 
	 * @return List<Date>
	 */
	public static List<Date> listDatesBetweenTwoDate(Date startDate, Date endDate) {
		List<Date> result = new ArrayList<Date>();
		
	    Calendar tempStart = Calendar.getInstance();
	    tempStart.setTime(startDate);
	    tempStart.add(Calendar.DAY_OF_YEAR, 1);
	    
	    Calendar tempEnd = Calendar.getInstance();
	    tempEnd.setTime(endDate);
	    while (tempStart.before(tempEnd)) {
	    	if (tempStart.get(Calendar.DAY_OF_YEAR) < tempEnd.get(Calendar.DAY_OF_YEAR)) {
	    		result.add(tempStart.getTime());
	    	}
	        tempStart.add(Calendar.DAY_OF_YEAR, 1);
	    }
	    return result;
	}
	
	/***
	 * 
	 * 功能描述：对于终身的日期：设置它的终止日期为2099
	 */
	public static Date getMaxDate() {
		Calendar c = Calendar.getInstance();
		c.add(Calendar.YEAR, 1000);
		return c.getTime();
	}
	/**
	 * 根据当前日期得到某一个日期
	 * @param value 值
	 * @param unit 单位 Y M D
	 * @return
	 */
	public static String calDate(int value,String unit) {
		Calendar c = Calendar.getInstance();
		if("Y".equals(unit)){
			c.add(Calendar.YEAR, value);
		}else if ("M".equals(unit)){
			c.add(Calendar.MONTH, value);
		}else if ("D".equals(unit)){
			c.add(Calendar.DATE, value);
		}
		return formatDate(c.getTime(), "yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	 * 根据某个日期计算差值
	 * @param value 值
	 * @param unit 单位 Y M D
	 * @return
	 * @throws ParseException 
	 */
	public static String calDate(String dateStr,int value,String unit) throws ParseException {
		SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
		Date date =sdf.parse(dateStr);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		if("Y".equals(unit)){
			calendar.add(Calendar.YEAR, value);
		}else if ("M".equals(unit)){
			calendar.add(Calendar.MONTH, value);
		}else if ("D".equals(unit)){
			calendar.add(Calendar.DATE, value);
		}
		return formatDate(calendar.getTime(), "yyyy-MM-dd");
	}
	
	/**
	 * 日期比较（精确到天），date1晚于date2
	 * 
	 * @param date1
	 *            日期1
	 * @param date2
	 *            日期2
	 * @return date1晚于date2，返回true，否则返回false
	 */
	public static boolean later(Date date1, Date date2) {
		boolean result = false;
		if (1 == compare(date1, date2, ACCURACY_DAY)) {
			result = true;
		}
		return result;
	}

	/**
	 * 日期比较（精确到天），date1早于date2
	 * 
	 * @param date1
	 *            日期1
	 * @param date2
	 *            日期2
	 * @return date1早于或 date2，返回true，否则返回false
	 */
	public static boolean earlier(Date date1, Date date2) {
		boolean result = false;
		if (-1 == compare(date1, date2, ACCURACY_DAY)) {
			result = true;
		}
		return result;
	}

	/**
	 * 日期比较（精确到天），date1等于date2
	 * 
	 * @param date1
	 *            日期1
	 * @param date2
	 *            日期2
	 * @return date1等于date2，返回true，否则返回false
	 */
	public static boolean equal(Date date1, Date date2) {
		boolean result = false;
		if (0 == compare(date1, date2, ACCURACY_DAY)) {
			result = true;
		}
		return result;
	}
	
	/**
	 * 根据指定规则，比较日期
	 * 
	 * @param date1
	 *            日期1
	 * @param date2
	 *            日期2
	 * @param accuracy
	 *            日期精度
	 * @return int型，date1晚，返回1；date1早，返回-1；相等，返回0
	 */
	private static int compare(Date date1, Date date2, int accuracy) {
		String pattern = DEFAULT_DATE_PATTERN;
		switch (accuracy) {
		case ACCURACY_YEAR:
			pattern = ACCURACY_PATTERN_YEAR;
			break;
		case ACCURACY_MONTH:
			pattern = ACCURACY_PATTERN_MONTH;
			break;
		case ACCURACY_DAY:
			pattern = ACCURACY_PATTERN_DAY;
			break;
		case ACCURACY_HOUR:
			pattern = ACCURACY_PATTERN_HOUR;
			break;
		case ACCURACY_MINUTE:
			pattern = ACCURACY_PATTERN_MINUTE;
			break;
		case ACCURACY_SECOND:
			pattern = ACCURACY_PATTERN_SECOND;
			break;
		default:
			break;
		}
		Date formatedDate1 = transDateFormat(date1, pattern);
		Date formatedDate2 = transDateFormat(date2, pattern);
		return formatedDate1.compareTo(formatedDate2);
	}
	
	/**
	 * 根据指定规则，转化日期，如只取年、取年月等
	 * 
	 * @param date
	 *            待转化日期
	 * @param pattern
	 *            日期格式
	 * @return 转化后的日期
	 */
	public static Date transDateFormat(Date date, String pattern) {
		String dateStr = null;
		Date dateResult = null;
		if(date != null){
			dateStr = getDateStr(date, pattern);
			try {
				dateResult = org.apache.commons.lang.time.DateUtils.parseDate(dateStr,
						new String[] { pattern.toString() });
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
		
		return dateResult;
	}
	
	/**
	 * 根据指定格式，返回日期时间字符串
	 * 
	 * @param date
	 *            日期变量
	 * @param pattern
	 *            日期格式
	 * @return 日期时间字符串
	 */
	public static String getDateStr(Date date, String pattern) {
		DateFormat df = new SimpleDateFormat(pattern);
		return df.format(date);
	}
	
	/**
	 *   指定日期格式为拼接日期和时间字符串，转化为Date类型；
	 *   如String类型的"2018/05/24 13:30"转化为Date类型；
	 */
	public static Date stringTurnDate(String date, String time, String datePattern, String timePattern){
		SimpleDateFormat dateformat = new SimpleDateFormat(datePattern + " " + timePattern );
		String beforeDate = date + " " + time;
		Date afertDate = null;
		try {
			afertDate = dateformat.parse(beforeDate);
		} catch (ParseException e) {
			return afertDate;
		}
		return afertDate;
	}
	
	/**
	 * @description: 验证日期字符串格式
	 *               设置lenient为false.
	 *               否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
	 *               如果throw java.text.ParseException或者NullPointerException，就说明格式不对
	 * @param date 
	 *                日期变量
	 * @param pattern 
	 *                日期格式
	 */
	public static boolean isValidDate(String date, String pattern) {
		Boolean convertSuccess = true;
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        if(!"".equals(date) && date != null){
        	format.setLenient(false);
        	try {
        		format.parse(date);
        	} catch (ParseException e) {
             	convertSuccess = false;
            }
        }
        return convertSuccess;
    }
	
	/**
	 * @description:
	 *       验证时间字符串格式
	 *       设置lenient为false.
	 *       如果throw java.text.ParseException就说明格式不对
	 */
	public static boolean isValidTime(String time, String pattern) {
		Boolean convertSuccess = true;
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        format.setLenient(false);
        if(!"".equals(time) && time != null){
        	try {
        		format.parse(time);
        		} catch (ParseException e) {
        			convertSuccess = false;
        		}
        	}
        return convertSuccess;
    }

	/**
	 * 判断两个时间是不是同一个月的 ，如果是同一个月 返回一个List 元素是数组
	 * 数组第一个是元素是开始时间 第二个是结束时间 例如 startDate = 2020-01-01，endDate = 2020-01-25，
	 * 返回 String{2020-01-01,2020-01-25 }
	 *
	 * 不是同一个月 返回一个 两个多个元素的List
	 * startDate = 2020-01-01，endDate = 2020-02-25
	 * 返回  {startDate = 2020-01-01}
	 *
	 * 默认 startDate < endDate
	 *
	 * @param startDate
	 * @param endDate
	 * @return
	 */
	public static List<Date[]> CompareDate(Date startDate, Date endDate){
		List<Date[]> list  =new ArrayList<>();
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
		String startDateStr =format.format(startDate);
		String endDateStr = format.format(endDate);
		//判断两个时间 是不是在一个月
		if(startDateStr.equals(endDateStr)){
			Date[] date =new Date[]{startDate,endDate};
			list.add(date);
			return list;
		}
		Calendar cDay1 = Calendar.getInstance();
		cDay1.setTime(startDate);
		Calendar c = Calendar.getInstance();
		c.setTime(endDate);
		//获取 startDate所在月的 最后一天
		cDay1.set(Calendar.DAY_OF_MONTH, cDay1.getActualMaximum(Calendar.DAY_OF_MONTH));
		Date lastDate = cDay1.getTime();
		Date[] date1 =new Date[]{startDate,lastDate};
		list.add(date1);

		int result = c.get(Calendar.MONTH) - cDay1.get(Calendar.MONTH);
		System.out.println(result);
		Date temp = startDate;
		//两个时间相差两个月 或以上  例如 2018-01-01  2018-03-05
		while(result - 1> 0){
			Calendar mid1 = Calendar.getInstance();
			mid1.setTime(temp);
			mid1.add(Calendar.MONTH, 1);
			mid1.set(Calendar.DAY_OF_MONTH, mid1.getActualMinimum(Calendar.DAY_OF_MONTH));
			temp = mid1.getTime();
			Calendar mid2 = Calendar.getInstance();
			mid2.setTime(mid1.getTime());
			mid2.set(Calendar.DAY_OF_MONTH, mid1.getActualMaximum(Calendar.DAY_OF_MONTH));
			Date[] midDate =new Date[]{mid1.getTime(),mid2.getTime()};
			list.add(midDate);
			result --;
		}
		//获取endDate 所在月的第一天
		c.add(Calendar.MONTH, 0);
		c.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
		Date firstDate =  c.getTime();
		Date[] date2 =new Date[]{firstDate,endDate};
		list.add(date2);
		return list;
	}
	/**
	 * @param args
	 * @throws ParseException
	 */
	public static void main(String[] args) throws ParseException {
 	//System.out.println(formatDate(parseDate("2010/3/6")));
//		System.out.println(getDate("yyyy年MM月dd日 E"));
//		long time = new Date().getTime()-parseDate("2012-11-19").getTime();
//		System.out.println(time/(24*60*60*1000));
//		String date=DateUtils.calDate("2016-12-12", -2, "D");
//		System.out.println(date);
		Date startDate = parseDate("2018-03-06 11:25:00");
		Date endDate = parseDate("2018-03-06 16:47:00");
		getHourDifferentOfTwoDate(startDate,endDate,4);
		/*long a =startDate.getTime();
		long b = endDate.getTime();
		double c= (double)(b-a)/(1000 * 60 * 60) ;
		DecimalFormat decimalFormat = new DecimalFormat("0.0");
		decimalFormat.format(c);*/
	/*	List<Date[]> list =CompareDate(startDate,endDate);
		for (Date[] d :list){
			System.out.println(formatDate(d[0]));
			System.out.println(formatDate(d[1]));
		}*/
	}
}