精华内容
下载资源
问答
  • Java日期时间处理

    万次阅读 2016-01-08 18:34:56
    我的Java日期时间处理 最近在公司做统计分析项目,经常碰见需要按天统计,按周统计,按月统计的需要,跟日期时间的处理就必不可少了。鉴于博主自己的水平有限,也对Joda-Time等之类的日期时间处理组件知之甚少,...
    我的Java日期时间处理

    最近在公司做统计分析项目,经常碰见需要按天统计,按周统计,按月统计的需要,跟日期时间的处理就必不可少了。鉴于博主自己的水平有限,也对Joda-Time等之类的日期时间处理组件知之甚少,所幸Java自带API中Date和Calendar两个类还比较强大,基本能满足我现在的需求。

    贴代码之前,我先讲解一下我的命名规则,以方便各位看官理解,基于方便处理的目的,基本九成以上的方法都是直接返回java.util.Date的结果。再次我也特别提供了dateToString、formatStringDT的转换方法去format Date结果

    规则:

    1、我的方法都基于见名知意的原则,如果不理解,每个方法,或者每组重载方法都提供了相应的注释
    2、用于判断的都用 isXXX 格式,用于取值的都以 getXXX开头
    a:getXXXs 之类,为取数量
    b:getStartXXX 之类,为按需取开始时间,格式如此例:2015-01-01 00:00:00
    c:getEndXXX 之类,为按需取结束时间,格式如此例:2015-12-31 23:59:59
    d:getStrXXX 之类,为取字符串格式的时间,默认格式为 yyyy-MM-dd HH:mm:ss
    e:getOffSetXXX 之类,为按需取偏移时间
    f:rollXXX 之类,为向前或者向后滚动时间
    g:CN 和 EN 分别为 符合中文习惯 和 英文习惯的标记
    h:DT 是 DateTime 的简写,SE 是 StartEnd 的简写
    3、有一个很明显的缺点:如果不是默认格式,拿到结果之后还需要重新format,或者调用传参之前需要预处理 参数的格式以符合默认格式。后期改进。

    本人在此贴出代码,一来也是希望对新手有所帮助,二来也希望高手指正,相互学习。在此感谢。下面是代码:
    /**
     * 类名称:DateTime
     * 类描述: 日期处理相关
     */
    public class DateTime {
    
    	// 年月格式
    	public static final String YEAR_MONTH_PATTERN = "yyyy-MM";
    	// 日期格式
    	public static final String DATE_PATTERN = "yyyy-MM-dd";
    	// 时间格式
    	public static final String TIME_PATTERN = "HH:mm:ss";
    	// 日期时间格式
    	public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    	// 精确日期时间格式
    	public static final String EXACT_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss.SSS";
    	
    	public static SimpleDateFormat defaultDF = new SimpleDateFormat(DATE_TIME_PATTERN);
    	
    	public static final String[] CN_WEEK = new String[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
    	public static final String[] EN_WEEK = new String[] { "Sunday", "Monday", "Tuesday", "Wednesday","Thursday", "Friday", "Saturday" };
    	
    	/**
    	 * 描述: 获取当前日期
    	 */
    	public static Date getDate(){
    		return new Date();
    	}
    	public static Date getNow(){
    		return getDate();
    	}
    	public static Date getYesterday(){
    		return rollDay(getDate(), -1);
    	}
    	public static Date getTomorrow(){
    		return rollDay(getDate(), 1);
    	}
    	
    	/**
    	 * 这种用法规定参数只能是DATE_TIME_PATTERN格式,不然转换报错!
    	 */
    	public static Date getDate(String dateTime){
    		return stringToDate(dateTime);
    	}
    	
    	/**
    	 * 描述: 根据 Calendar 的属性获取相应值
    	 */
    	public static int getField(int typeValue){
    		return getField(new Date(), typeValue);
    	}
    	public static int getYear(){
    		return getField(Calendar.YEAR);
    	}
    	public static int getMonth(){
    		return getField(Calendar.MONTH);
    	}
    	public static int getDay(){
    		return getField(Calendar.DAY_OF_MONTH);
    	}
    	public static int getHour(){
    		return getField(Calendar.HOUR);
    	}
    	public static int getMinute(){
    		return getField(Calendar.MINUTE);
    	}
    	public static int getSecond(){
    		return getField(Calendar.SECOND);
    	}
    	public static int getField(Date date, int typeValue){
    		if(null == date){
    			date = new Date();
    		}
    		Calendar cd = Calendar.getInstance();
        	cd.setTime(date);
        	if(typeValue == Calendar.MONTH){
        		return cd.get(typeValue)+1;
        	}else{
        		return cd.get(typeValue);
        	}
    	}
    	
    	/**
    	 * 获得指定字符串格式的当前时间
    	 */
    	public static String getStrCurrentDT(String pattern) {
    		if(isNotNull(pattern)){
    			return dateToString(new Date(), pattern);
    		}else{
    			return getStrCurrentDT();
    		}
    	}
    	public static String getStrCurrentDT() {
    		return dateToString(new Date(), DATE_TIME_PATTERN);
    	}
    	
    	/**
    	 * 判断一个字符串是否是空
    	 */
    	public static boolean isNotNull(String str) {
    		return (null != str && !"".equals(str.trim()) && !"null".equals(str));
    	}
    	
    	/**
    	 * 描述: 判断是否是闰年
    	 */
    	public static boolean isLeapYear(int year) {
    		return (((year % 4 == 0 && year % 100 != 0)) || (year % 400 == 0));
    	}
    	public static boolean isLeapYear(Date date) {
    		Calendar cld = Calendar.getInstance();
    		if(null == date){
    			date = new Date();
    		}
    		cld.setTime(date);
    		int year = cld.get(Calendar.YEAR);
    		return (((year % 4 == 0 && year % 100 != 0)) || (year % 400 == 0));
    	}
    	
    	/**
    	 * String时间转换成 Date
    	 */
    	public static Date stringToDate(String time, String pattern){
    		SimpleDateFormat sdf = null;
    		if(pattern.equals(DATE_TIME_PATTERN)){
    			sdf = defaultDF;
    		}else{
    			sdf = new SimpleDateFormat(pattern);
    		}
    		Date date = null;
    		try {
    			date = sdf.parse(time);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return date;
    	}
    	public static Date stringToDate(String time){
    		return stringToDate(time, DATE_TIME_PATTERN);
    	}
    
    	/**
    	 * Date类型时间转换成 String形式
    	 */
    	public static String dateToString(Date date, String pattern) {
    		return new SimpleDateFormat(pattern).format(date);
    	}
    	public static String dateToString(Date date) {
    		return defaultDF.format(date);
    	}
    	
    	/**
    	 * 描述: 将字符串格式的时间做格式转换
    	 */
    	public static String formatStringDT(String strTime, String oldPattern, String newPattern) {
            SimpleDateFormat getsdf = new SimpleDateFormat(oldPattern);
            SimpleDateFormat resdf = new SimpleDateFormat(newPattern);
            String dateTime = null;
            try {
    			 dateTime = resdf.format(getsdf.parse(strTime));
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
            return dateTime;
        }
    	
    	/**
    	 * 获取当前月份, 字符串形式
    	 * @return 返回字符串 格式:两位数
    	 */
    	public static String getStrCurrentMonth() {
    		Calendar cld = Calendar.getInstance();
    		int intMon = cld.get(Calendar.MONTH) + 1;
    		if (intMon < 10){
    			return ("0" + String.valueOf(intMon));
    		}else{
    			return String.valueOf(intMon);
    		}
    	}
    	
    	/**
    	 * 描述: 得到某年某月的天数
    	 */
    	public static int getDaysOfMonth(int year, int month){   
            if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8  
                      || month == 10 || month == 12) {   
                  return 31;   
            }   
            if (month == 4 || month == 6 || month == 9 || month == 11) {   
                  return 30;   
            }   
            if (month == 2) {   
                  if (isLeapYear(year)) {   
                      return 29;   
                  } else {   
                      return 28;   
                  }   
            }   
            return 0;   
    	}
    	public static int getDaysOfMonth() {
            Calendar cal = Calendar.getInstance();
            return cal.getActualMaximum(Calendar.DATE);
        }
        public static int getDaysOfMonth(Date date) {
            Calendar cal = Calendar.getInstance();
            if (date != null) {
                cal.setTime(date);
            }
            int dayOfMonth = cal.getActualMaximum(Calendar.DATE);
            return dayOfMonth;
        }
        /**
         * 描述: 得到date该日期所在月有多少天
         */
        public static int getMonthDaysOfDate() {
        	return getMonthDaysOfDate(null);
        }
        public static int getMonthDaysOfDate(Date date) {
        	Calendar cal = Calendar.getInstance();
        	if(null != date){
        		cal.setTime(date);
        	}
    		int year = cal.get(Calendar.YEAR);
    		int month = cal.get(Calendar.MONTH)+1;
    		int days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    		if(isLeapYear(year)){
    			days[1] = 29;
    		}
    		return days[month - 1];
    	}
        
        /**
         * 计算指定日期所在年份的总天数
         */
        public static int getDaysOfYear() {
        	Calendar cd = Calendar.getInstance();
            cd.set(Calendar.DAY_OF_YEAR,1);//把日期设为当年第一天   
            cd.roll(Calendar.DAY_OF_YEAR,-1);//把日期回滚一天。   
            return cd.get(Calendar.DAY_OF_YEAR);
        }
        public static int getDaysOfYear(int year) {
        	Calendar cd = Calendar.getInstance();
        	cd.set(Calendar.YEAR, year);
            cd.set(Calendar.DAY_OF_YEAR,1);//把日期设为当年第一天   
            cd.roll(Calendar.DAY_OF_YEAR,-1);//把日期回滚一天。  
            return cd.get(Calendar.DAY_OF_YEAR);
        }
        public static int getDaysOfYear(Date date) {
        	if(null == date){
        		date = new Date();
        	}
        	Calendar cd = Calendar.getInstance();
        	cd.setTime(date);
            cd.set(Calendar.DAY_OF_YEAR,1);//把日期设为当年第一天   
            cd.roll(Calendar.DAY_OF_YEAR,-1);//把日期回滚一天。   
            int MaxYear = cd.get(Calendar.DAY_OF_YEAR);    
            return MaxYear;  
        }
    	
    	/**
    	 * 获取日期
    	 * @param timeType 时间类型,譬如:Calendar.DAY_OF_YEAR
    	 * @param timenum  时间数字,譬如:-1 昨天,0 今天,1 明天
    	 * @return 日期
    	 */
    	public static Date getOffsetFromNow(int timeType, int timeNum){
    		Calendar cld = Calendar.getInstance();
    		cld.add(timeType, timeNum);
    		return cld.getTime();
    	}
    	public static Date getOffsetFromDate(Date date, int timeType, int timeNum){
    		Calendar cld = Calendar.getInstance();
    		cld.setTime(date);
    		cld.add(timeType, timeNum);
    		return cld.getTime();
    	}
    	
    	/**
    	 * 计算从现在开始几天后的时间
    	 * @param afterDay
    	 * @param dateFormatter 字符串时间格式
    	 * @return
    	 */
    	public static Date getOffsetDaysFromNow(int afterDay) {
    		return getOffsetFromNow(Calendar.DATE, afterDay);
    	}
    	public static Date getOffsetDaysFromDate(Date date, int afterDay) {
    		return getOffsetFromDate(date, Calendar.DATE, afterDay);
    	}
    	
    	/**
    	 * 描述: 求两个时间之间的秒差(不精确)
    	 */
    	public static long getSecondsBetween(Date startDate, Date endDate) {
    		long startDT = startDate.getTime();
    		long endDT = endDate.getTime();
    		long seconds = 0;
    		if(startDT >= endDT){
    			seconds = (int) ((startDT - endDT) / 1000);
    		}else{
    			seconds = (int) ((endDT - startDT) / 1000);
    		}
            return seconds;
        }
    	
    	/**
    	 * 描述: 重置日期
    	 */
    	public static Date getResetDate(Date date, int year, int month, int dayOfMonth) {
            Calendar cal = Calendar.getInstance();
            if (date != null) {
                cal.setTime(date);
            }
            cal.set(Calendar.YEAR, year);
            cal.set(Calendar.MONTH, month-1);
            cal.set(Calendar.DAY_OF_MONTH, dayOfMonth);
            return cal.getTime();
        }
    	
    	/**
    	 * 描述: 重置时间
    	 */
    	public static Date getResetTime(Date date, int hour, int minute, int second) {
            Calendar cal = Calendar.getInstance();
            if (date != null) {
                cal.setTime(date);
            }
            cal.set(Calendar.HOUR_OF_DAY, hour);
            cal.set(Calendar.MINUTE, minute);
            cal.set(Calendar.SECOND, second);
            return cal.getTime();
        }
    	
    	/**
    	 * 描述: 重置日期时间
    	 */
    	public static Date getResetDT(Date date, int year, int month, int dayOfMonth, int hour, int minute, int second) {
            Calendar cal = Calendar.getInstance();
            if (date != null) {
                cal.setTime(date);
            }
            cal.set(Calendar.YEAR, year);
            cal.set(Calendar.MONTH, month-1);
            cal.set(Calendar.DAY_OF_MONTH, dayOfMonth);
            cal.set(Calendar.HOUR_OF_DAY, hour);
            cal.set(Calendar.MINUTE, minute);
            cal.set(Calendar.SECOND, second);
            return cal.getTime();
        }
    	
    	/**
    	 * 描述: 按照给定参数获取偏移日期
    	 */
    	public static Date rollDate(Date date, int years, int months, int days) {
            Calendar cal = Calendar.getInstance();
            if (date != null) {
                cal.setTime(date);
            }
            cal.add(Calendar.YEAR, years);
            cal.add(Calendar.MONTH, months);
            cal.add(Calendar.DAY_OF_MONTH, days);
            return cal.getTime();
        }
    	public static Date rollTime(Date date, int hours, int minutes, int seconds) {
            Calendar cal = Calendar.getInstance();
            if (date != null) {
                cal.setTime(date);
            }
            cal.add(Calendar.HOUR_OF_DAY, hours);
            cal.add(Calendar.MINUTE, minutes);
            cal.add(Calendar.SECOND, seconds);
            return cal.getTime();
        }
    	public static Date rollDateTime(Date date, int years, int months, int days, int hours, int minutes, int seconds) {
            Calendar cal = Calendar.getInstance();
            if (date != null) {
                cal.setTime(date);
            }
            cal.add(Calendar.YEAR, years);
            cal.add(Calendar.MONTH, months);
            cal.add(Calendar.DAY_OF_MONTH, days);
            cal.add(Calendar.HOUR_OF_DAY, hours);
            cal.add(Calendar.MINUTE, minutes);
            cal.add(Calendar.SECOND, seconds);
            return cal.getTime();
        }
    	public static Date rollYear(Date date, int years) {
            return rollDate(date, years, 0, 0);
        }
    	public static Date rollMonth(Date date, int months) {
            return rollDate(date, 0, months, 0);
        }
    	public static Date rollWeek(Date date, int weeks) {
    		return rollDateTime(date, 0, 0, weeks*7, 0, 0, 0);
        }
    	public static Date rollDay(Date date, int days) {
            return rollDate(date, 0, 0, days);
        }
    	public static Date rollHour(Date date, int hours) {
    		return rollTime(date, hours, 0, 0);
        }
    	public static Date rollMinute(Date date, int minutes) {
    		return rollTime(date, 0, minutes, 0);
        }
    	public static Date rollSecond(Date date, int seconds) {
    		return rollTime(date, 0, 0, seconds);
        }
    	
    	/**
    	 * 描述: 得到 date 的一天开始时间戳
    	 */
    	public static String getStrStartDTOfDay(){
    		return dateToString(getResetTime(new Date(), 0, 0, 0), DATE_TIME_PATTERN);
    	}
    	public static String getStrStartDTOfDay(Date date){
    		return dateToString(getResetTime(date, 0, 0, 0), DATE_TIME_PATTERN);
    	}
    	public static Date getStartDTOfDay(){
    		return getResetTime(new Date(), 0, 0, 0);
    	}
    	public static Date getStartDTOfDay(Date date){
    		return getResetTime(date, 0, 0, 0);
    	}
    	
    	/**
    	 * 描述: 得到 date 的一天结束时间戳
    	 */
    	public static String getStrEndDTOfDay(Date date) {
    		return dateToString(getResetTime(date, 23, 59, 59), DATE_TIME_PATTERN);
    	}
    	public static String getStrEndDTOfDay() {
    		return dateToString(getResetTime(new Date(), 23, 59, 59), DATE_TIME_PATTERN);
    	}
    	public static Date getEndDTOfDay() {
    		return getResetTime(new Date(), 23, 59, 59);
    	}
    	public static Date getEndDTOfDay(Date date) {
    		return getResetTime(date, 23, 59, 59);
    	}
    	
        /**
         * 获取当周第一天的起始时间,例如2014-08-01 00:00:00
         */
        public static Date getStartDTOfWeek() {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_WEEK, 1);
            return getStartDTOfDay(cal.getTime());
        }
        public static Date getStartDTOfWeek(Date date) {
            Calendar cal = Calendar.getInstance();
            if(null == date){
            	return getStartDTOfWeek();
            }
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, 1);
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 描述:获取帝国特色的自然周(周一 -> 周日)开始日期时间,即本周的周一
         */
        public static Date getCNStartDTOfWeek() {
        	return getCNStartDTOfWeek(null);
        }
        public static Date getCNStartDTOfWeek(Date date) {
        	Calendar cal = Calendar.getInstance();
        	if(null != date){
        		cal.setTime(date);
        	}
        	if(cal.get(Calendar.DAY_OF_WEEK) == 1){
        		 return rollDay(cal.getTime(), -6);
        	}else{
        		return rollDay(getStartDTOfWeek(cal.getTime()), 1);
        	}
        }
        
        
        /**
         * 获取当周最后一天的起始时间,例如2014-08-07 23:59:59
         */
        public static Date getEndDTOfWeek() {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_WEEK, 7);
            return getEndDTOfDay(cal.getTime());
        }
        public static Date getEndDTOfWeek(Date date) {
            Calendar cal = Calendar.getInstance();
            if(null == date){
            	return getEndDTOfWeek();
            }
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, 7);
            return getEndDTOfDay(cal.getTime());
        }
        
        /**
         * 描述:获取帝国特色的自然周(周一 -> 周日)结束日期时间,即本周的周日
         */
        public static Date getCNEndDTOfWeek() {
        	return getCNEndDTOfWeek(null);
        }
        public static Date getCNEndDTOfWeek(Date date) {
        	Calendar cal = Calendar.getInstance();
        	if(null != date){
        		cal.setTime(date);
        	}
        	if(cal.get(Calendar.DAY_OF_WEEK) == 1){
        		 return getEndDTOfDay(cal.getTime());
        	}else{
        		return rollDay(getEndDTOfWeek(cal.getTime()), 1);
        	}
        }
        
        /**
         * 获取当月第一天的起始时间,例如2014-08-01 00:00:00
         */
        public static Date getStartDTOfMonth() {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return getStartDTOfDay(cal.getTime());
        }
        public static Date getStartDTOfMonth(Date date) {
            Calendar cal = Calendar.getInstance();
            if(null == date){
            	return getStartDTOfMonth();
            }
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当月最后一天的结束时间,例如2014-08-31 23:59:59
         */
        public static Date getEndDTOfMonth() {
        	Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_MONTH, getDaysOfMonth(cal.getTime()));
            return getEndDTOfDay(cal.getTime());
        }
        public static Date getEndDTOfMonth(Date date) {
        	if(null == date){
            	return getEndDTOfMonth();
            }
        	Calendar cal = Calendar.getInstance();
        	cal.setTime(date);
            cal.set(Calendar.DAY_OF_MONTH, getDaysOfMonth(cal.getTime()));
            return getEndDTOfDay(cal.getTime());
        }
        
        /**
         * 获取上个月第一天的起始时间,例如2014-07-01 00:00:00
         */
        public static Date getStartDTOfLastMonth() {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.MONTH, -1);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return getStartDTOfDay(cal.getTime());
        }
        public static Date getStartDTOfNextMonth() {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.MONTH, 1);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return getStartDTOfDay(cal.getTime());
        }
        public static Date getStartDTOffsetMonth(int month) {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.MONTH, month);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取上个月最后一天的结束时间,例如2014-07-31 23:59:59
         */
        public static Date getEndDTOfLastMonth() {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.MONTH, -1);
            cal.set(Calendar.DAY_OF_MONTH, getDaysOfMonth(cal.getTime()));
            return getEndDTOfDay(cal.getTime());
        }
        public static Date getEndDTOfNextMonth() {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.MONTH, 1);
            cal.set(Calendar.DAY_OF_MONTH, getDaysOfMonth(cal.getTime()));
            return getEndDTOfDay(cal.getTime());
        }
        public static Date getEndDTOffsetMonth(int month) {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.MONTH, month);
            cal.set(Calendar.DAY_OF_MONTH, getDaysOfMonth(cal.getTime()));
            return getEndDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当前季度第一天的起始时间
         */
        public static Date getStartDTOfQuarter() {
        	return getStartDTOfQuarter(null);
        }
        public static Date getStartDTOfQuarter(Date date) {
            Calendar cal = Calendar.getInstance();
            if(null != date){
            	cal.setTime(date);
            }
            int month = cal.get(Calendar.MONTH);
            if (month < 3) {
                cal.set(Calendar.MONTH, 0);
            } else if (month < 6) {
                cal.set(Calendar.MONTH, 3);
            } else if (month < 9) {
                cal.set(Calendar.MONTH, 6);
            } else {
                cal.set(Calendar.MONTH, 9);
            }
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当前季度最后一天的结束时间
         */
        public static Date getEndDTOfQuarter() {
        	return getEndDTOfQuarter(null);
        }
        public static Date getEndDTOfQuarter(Date date) {
            Calendar cal = Calendar.getInstance();
            if(null != date){
            	cal.setTime(date);
            }
            int month = cal.get(Calendar.MONTH);
            if (month < 3) {
                cal.set(Calendar.MONTH, 2);
            } else if (month < 6) {
                cal.set(Calendar.MONTH, 5);
            } else if (month < 9) {
                cal.set(Calendar.MONTH, 8);
            } else {
                cal.set(Calendar.MONTH, 11);
            }
            cal.set(Calendar.DAY_OF_MONTH, getDaysOfMonth(cal.getTime()));
            return getEndDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当年第一天的开始时间,例如2014-01-01 00:00:00
         */
        public static Date getStartDTOfYear() {
        	Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_YEAR, 1);
            return getStartDTOfDay(cal.getTime());
        }
        public static Date getStartDTOfYear(Date date) {
        	if(null == date){
            	return getStartDTOfYear();
            }
        	Calendar cal = Calendar.getInstance();
        	cal.setTime(date);
            cal.set(Calendar.DAY_OF_YEAR, 1);
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当年最后一天的结束时间,例如2014-12-31 23:59:59
         */
        public static Date getEndDTOfYear() {
        	Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_YEAR, getDaysOfYear(getDate()));
            return getEndDTOfDay(cal.getTime());
        }
        public static Date getEndDTOfYear(Date date) {
        	if(null == date){
            	return getEndDTOfYear();
            }
        	Calendar cal = Calendar.getInstance();
        	cal.setTime(date);
            cal.set(Calendar.DAY_OF_YEAR, getDaysOfYear(date));
            return getEndDTOfDay(cal.getTime());
        }
        
        /**
         * 获取前一个工作日(只指周一 到 周五)
         */
        public static Date getPrevWorkday() {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.DAY_OF_MONTH, -1);
            if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
                cal.add(Calendar.DAY_OF_MONTH, -2);
            }
            if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
                cal.add(Calendar.DAY_OF_MONTH, -1);
            }
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取下一个工作日(只指周一 到 周五)
         */
        public static Date getNextWorkday() {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.DAY_OF_MONTH, 1);
            if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
                cal.add(Calendar.DAY_OF_MONTH, 2);
            }
            if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
                cal.add(Calendar.DAY_OF_MONTH, 1);
            }
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当前月的工作日列表
         */
        public static List<Date> getWorkDateListOfMonth(){
        	int days = getDaysOfMonth();
        	Date startDateOfMonth = getStartDTOfMonth();
        	List<Date> dateList = new ArrayList<Date>();
        	for(int i=0; i<days; i++){
        		if(isWorkday(startDateOfMonth)){
        			dateList.add(startDateOfMonth);
        		}
        		startDateOfMonth = rollDay(startDateOfMonth, 1);
        	}
        	return dateList;
        }
        public static List<Date> getWorkDateListOfMonth(Date date){
        	return getDaysList(date);
        }
        public static List<Date> getWorkDateListOfMonth(int year, int month){
        	Date date = getResetDate(getDate(), year, month, 1);
        	return getDaysList(date);
        }
        private static List<Date> getDaysList(Date date){
        	int days = getDaysOfMonth(date);
        	Date startDateOfMonth = getStartDTOfMonth(date);
        	List<Date> dateList = new ArrayList<Date>();
        	for(int i=0; i<days; i++){
        		if(isWorkday(startDateOfMonth)){
        			dateList.add(startDateOfMonth);
        		}
        		startDateOfMonth = rollDay(startDateOfMonth, 1);
        	}
        	return dateList;
        }
        
        /**
         * 描述:获取两个日期之间的所有工作日(周一到周五都算)
         */
        public static List<Date> getWorkDateListBetween(Date startDate, Date endDate){
        	startDate = getStartDTOfDay(startDate);
        	List<Date> dateList = new ArrayList<Date>();
        	while(startDate.getTime() <= endDate.getTime()){
        		if(isWorkday(startDate)){
        			dateList.add(startDate);
        		}
        		startDate = rollDay(startDate, 1);
        	}
        	return dateList;
        }
        
        /**
         * 获取当周的第一个工作日
         */
        public static Date getFirstWorkdateOfWeek() {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
            return getStartDTOfDay(cal.getTime());
        }
        public static Date getFirstWorkdateOfWeek(Date date) {
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当周的最后一个工作日
         */
        public static Date getLastWorkdateOfWeek() {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
            return getStartDTOfDay(cal.getTime());
        }
        public static Date getLastWorkdateOfWeek(Date date) {
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
            return getStartDTOfDay(cal.getTime());
        }
        
        /**
         * 获取当月的第一个工作日
         */
        public static Date getFirstWorkdateOfMonth() {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_MONTH, 1);
            if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), 1));
            }else if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), 2));
            }else{
            	return getStartDTOfDay(cal.getTime());
            }
        }
        public static Date getFirstWorkdateOfMonth(Date date) {
            Calendar cal = Calendar.getInstance();
            if(null == date){
            	return getFirstWorkdateOfMonth();
            }else{
            	cal.setTime(date);
            }
            cal.set(Calendar.DAY_OF_MONTH, 1);
            if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), 1));
            }else if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), 2));
            }else{
            	return getStartDTOfDay(cal.getTime());
            }
        }
        
        /**
         * 获取当月的最后一个工作日
         */
        public static Date getLastWorkdateOfMonth() {
        	Date lastDate = getEndDTOfMonth();
            Calendar cal = Calendar.getInstance();
            cal.setTime(lastDate);
            if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), -2));
            }else if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), -1));
            }else{
            	return getStartDTOfDay(cal.getTime());
            }
        }
        public static Date getLastWorkdateOfMonth(Date date) {
        	Date lastDate = getEndDTOfMonth(date);
            Calendar cal = Calendar.getInstance();
            if(null == date){
            	return getLastWorkdateOfMonth();
            }else{
            	cal.setTime(date);
            }
            cal.setTime(lastDate);
            if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), -2));
            }else if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY){
            	return getStartDTOfDay(rollDay(cal.getTime(), -1));
            }else{
            	return getStartDTOfDay(cal.getTime());
            }
        }
        
        /**
         * 判断指定日期是否是工作日
         */
        public static boolean isWorkday(Date date) {
            Calendar cal = Calendar.getInstance();
            if (null != date) {
                cal.setTime(date);
            }
            int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
            return !(dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY);
        }
        
        /**
         * 获取指定日期是星期几(中文形式)
         */
        public static String getChineseDayName(Date date) {
            Calendar cal = Calendar.getInstance();
            if (null != date) {
                cal.setTime(date);
            }
            return CN_WEEK[cal.get(Calendar.DAY_OF_WEEK) - 1];
        }
        
        /**
         * 获取指定日期是星期几(英文形式)
         */
        public static String getEnglishDayName(Date date) {
            Calendar cal = Calendar.getInstance();
            if (null != date) {
                cal.setTime(date);
            }
            return EN_WEEK[cal.get(Calendar.DAY_OF_WEEK) - 1];
        }
        
        /**
         * 获取指定日期距离当前时间的时间差描述(如3小时前、1天前)
         */
        public static String getOffsetDescription(Date date) {
            long seconds = getSecondsBetween(date, new Date());
            if (Math.abs(seconds) < 60) {
                return Math.abs(seconds) + "秒" + (seconds > 0 ? "前" : "后");
            }
            long minutes = seconds / 60;
            if (Math.abs(minutes) < 60) {
                return Math.abs(minutes) + "分钟" + (minutes > 0 ? "前" : "后");
            }
            long hours = minutes / 60;
            if (Math.abs(hours) < 60) {
                return Math.abs(hours) + "小时" + (hours > 0 ? "前" : "后");
            }
            long days = hours / 24;
            if (Math.abs(days) < 7) {
                return Math.abs(days) + "天" + (days > 0 ? "前" : "后");
            }
            long weeks = days / 7;
            if (Math.abs(weeks) < 5) {
                return Math.abs(weeks) + "周" + (weeks > 0 ? "前" : "后");
            }
            long monthes = days / 30;
            if (Math.abs(monthes) < 12) {
                return Math.abs(monthes) + "个月" + (monthes > 0 ? "前" : "后");
            }
            long years = monthes / 12;
            return Math.abs(years) + "年" + (years > 0 ? "前" : "后");
        }
        
        /**
    	 * 时间比较  1:date1靠前 		-1:date1靠后
    	 */
    	public static int compareDate(Date date1, Date date2) {
    		if (date2.getTime() > date1.getTime()) {
    			return 1;
    		} else if (date2.getTime() < date1.getTime()) {
    			return -1;
    		} else {
    			return 0;
    		}
    	}
    	
    	/**
    	 * 计算该日期的周开始时间和月开始时间是否都在同一个年份内, 在就 返回 true
    	 */
    	public static boolean isPerfectWeek(Date date){
    		Date startDate = getStartDTOfWeek(date);
    		Date endDate = getEndDTOfWeek(date);
    		int startDateYear = getField(startDate, Calendar.YEAR);
    		int endDateYear = getField(endDate, Calendar.YEAR);
    		if(startDateYear == endDateYear){
    			return true;
    		}else{
    			return false;
    		}
    	}
    	
    	/**
    	 * 描述:得到两个日期之间的日期列表
    	 */
    	public static List<Date> getDateBetween(String startDate, String endDate) {
    		Date dateStart = stringToDate(startDate, DATE_TIME_PATTERN);
    		Date dateEnd = stringToDate(endDate, DATE_TIME_PATTERN);
    		return getDateBetween(dateStart, dateEnd);
    	}
    	public static List<Date> getDateBetween(String startDate) {
    		Date dateStart = stringToDate(startDate, DATE_TIME_PATTERN);
    		Date dateEnd = new Date();
    		if(dateStart.getTime() <= dateEnd.getTime()){
    			return getDateBetween(dateStart, dateEnd);
    		}else{
    			return getDateBetween(dateEnd, dateStart);
    		}
    	}
    	public static List<Date> getDateBetween(Date startDate, Date endDate) {
    		if(startDate.getTime() <= endDate.getTime()){
    			List<Date> dateList = new ArrayList<Date>();
    			while(startDate.getTime() <= endDate.getTime()){
    				dateList.add(getStartDTOfDay(startDate));
    				startDate = rollDay(startDate, 1);
    			}
    			return dateList;
    		}else{
    			return getDateBetween(endDate, startDate);
    		}
    	}
    	public static List<Date> getDateBetween(Date startDate) {
    		return getDateBetween(startDate, getDate());
    	}
    	
    	/**
    	 * 描述:得到两个日期之间的周列表
    	 * 每一周只存一个时间,第一周存开始时间,中间的数都是每一周的开始时间, 最后一周存的是结束日期
    	 * 如果返回结果只有两个时间,如何判断,他们是同一周的开始结束时间,还是不同周的开始结束时间呢。
    	 * 暂时还没想好,替换的处理办法是调用 getWeekBetweenWithSE(Date startDate, Date endDate) 方法
    	 */
    	public static List<Date> getWeekBetween(Date startDate,Date endDate){
    		if(startDate.getTime() > endDate.getTime()){
    			return getWeekBetween(endDate, startDate);
    		}else{
    			List<Date> list = new ArrayList<Date>();
    			list.add(startDate);
    			Date startTime = getStartDTOfWeek(startDate);
    			for(Date d = startTime; compareDate(d, endDate) >= 0; d = rollDay(d, 7)){
    				if(d != startTime){
    					list.add(d);
    				}
    			}
    			if(list.size() == 1){
    				list.add(endDate);
    			}else{
    				list.set(list.size()-1, endDate);
    			}
    			return list;
    		}
    	}
    	public static List<Date> getCNWeekBetween(Date startDate,Date endDate){
    		if(startDate.getTime() > endDate.getTime()){
    			return getCNWeekBetween(endDate, startDate);
    		}else{
    			List<Date> list = new ArrayList<Date>();
    			list.add(startDate);
    			Date startTime = getCNStartDTOfWeek(startDate);
    			for(Date d = startTime; compareDate(d, endDate) >= 0; d = rollDay(d, 7)){
    				if(d != startTime){
    					list.add(d);
    				}
    			}
    			if(list.size() == 1){
    				list.add(endDate);
    			}else{
    				list.set(list.size()-1, endDate);
    			}
    			return list;
    		}
    	}
    	
    	/**
    	 * 描述:getWeekBetween的进化版本
    	 * 每周存两个时间,开始时间和结束时间都存
    	 */
    	public static List<Date> getWeekBetweenWithSE(Date startDate,Date endDate){
    		List<Date> dateList = null;
    		if(startDate.getTime() > endDate.getTime()){
    			dateList = getWeekBetween(endDate, startDate);
    		}else{
    			dateList = getWeekBetween(startDate, endDate);
    		}
    		List<Date> resultList = new ArrayList<Date>();
    		int size = dateList.size();
    		Date firstDate = dateList.get(0);
    		Date lastDate = dateList.get(size - 1);
    		if(size == 2){
    			resultList.add(firstDate);
    			Date firstWeekEndDate = getEndDTOfWeek(firstDate);
    			if(firstWeekEndDate.getTime() >= lastDate.getTime()){
    				resultList.add(lastDate);
    			}else{
    				resultList.add(firstWeekEndDate);
    				resultList.add(getStartDTOfWeek(lastDate));
    				resultList.add(lastDate);
    			}
    		}else{
    			for(int i=0; i<size; i++ ){
    				if(i == size - 1){	// 最后一个是结束日期
    					resultList.add(getStartDTOfWeek(lastDate));
    					resultList.add(lastDate);
    				}else if(i == 0){
    					resultList.add(firstDate);
    					resultList.add(getEndDTOfWeek(firstDate));
    				}else{
    					resultList.add(dateList.get(i));
    					resultList.add(getEndDTOfWeek(dateList.get(i)));
    				}
    			}
    		}
    		return resultList;
    	}
    	public static List<Date> getCNWeekBetweenWithSE(Date startDate,Date endDate){
    		List<Date> dateList = null;
    		if(startDate.getTime() > endDate.getTime()){
    			dateList = getCNWeekBetween(endDate, startDate);
    		}else{
    			dateList = getCNWeekBetween(startDate, endDate);
    		}
    		List<Date> resultList = new ArrayList<Date>();
    		int size = dateList.size();
    		Date firstDate = dateList.get(0);
    		Date lastDate = dateList.get(size - 1);
    		if(size == 2){
    			resultList.add(firstDate);
    			Date firstWeekEndDate = getCNEndDTOfWeek(firstDate);
    			if(firstWeekEndDate.getTime() >= lastDate.getTime()){
    				resultList.add(lastDate);
    			}else{
    				resultList.add(firstWeekEndDate);
    				resultList.add(getCNStartDTOfWeek(lastDate));
    				resultList.add(lastDate);
    			}
    		}else{
    			for(int i=0; i<size; i++ ){
    				if(i == size - 1){	// 最后一个是结束日期
    					resultList.add(getCNStartDTOfWeek(lastDate));
    					resultList.add(lastDate);
    				}else if(i == 0){
    					resultList.add(firstDate);
    					resultList.add(getCNEndDTOfWeek(firstDate));
    				}else{
    					resultList.add(dateList.get(i));
    					resultList.add(getCNEndDTOfWeek(dateList.get(i)));
    				}
    			}
    		}
    		return resultList;
    	}
    	
    	/**
    	 * 描述:得到两个日期之间的月份列表
    	 */
    	public static List<Date> getMonthBetween(Date startDate,Date endDate){
    		if(endDate.getTime() < startDate.getTime()){
    			return getMonthBetween(endDate, startDate);
    		}else{
    			Calendar sc = Calendar.getInstance();
    			sc.setTime(startDate);
    			Calendar ec = Calendar.getInstance();
    			ec.setTime(endDate);
    			int startYear = sc.get(Calendar.YEAR);
    			int startMonth = sc.get(Calendar.MONTH)+1;
    			int endYear = ec.get(Calendar.YEAR);
    			int endMonth = ec.get(Calendar.MONTH)+1;
    			int length = (endYear - startYear)*12 + (endMonth - startMonth) + 1;
    			List<Date> list = new ArrayList<Date>();
    			for(int i=0; i<length; i++){
    				Date date = getStartDTOfMonth(rollMonth(startDate, i));
    				list.add(date);
    			}
    			list.set(0, startDate);
    			list.set(list.size() - 1, endDate);
    			return list;
    		}
    	}
    	
    	/**
    	 * 描述:获取带开始和结束时间的月份列表
    	 */
    	public static List<Date> getMonthBetweenWithSE(Date startDate,Date endDate){
    		List<Date> dateList = null;
    		if(endDate.getTime() < startDate.getTime()){
    			dateList = getMonthBetween(endDate, startDate);
    		}else{
    			dateList = getMonthBetween(startDate, endDate);
    		}
    		List<Date> resultList = new ArrayList<Date>();
    		int size = dateList.size();
    		Date firstDate = dateList.get(0);
    		Date lastDate = dateList.get(size - 1);
    		if(size == 2){
    			resultList.add(firstDate);
    			Date firstMonthEndDate = getEndDTOfMonth(firstDate);
    			if(firstMonthEndDate.getTime() >= lastDate.getTime()){
    				resultList.add(lastDate);
    			}else{
    				resultList.add(firstMonthEndDate);
    				resultList.add(getStartDTOfMonth(lastDate));
    				resultList.add(lastDate);
    			}
    		}else{
    			for(int i=0; i<size; i++ ){
    				if(i == size - 1){	// 最后一个是结束日期
    					resultList.add(getStartDTOfMonth(lastDate));
    					resultList.add(lastDate);
    				}else if(i == 0){
    					resultList.add(firstDate);
    					resultList.add(getEndDTOfMonth(firstDate));
    				}else{
    					resultList.add(dateList.get(i));
    					resultList.add(getEndDTOfMonth(dateList.get(i)));
    				}
    			}
    		}
    		return resultList;
    	}
    	
    	/**
    	 * 描述: 得到过去完整(不包含今月)的12个月
    	 */
    	public static List<Date> getLastTwelveMonth(){
    		Date endDate = getStartDTOfMonth(rollMonth(getDate(), -1));
    		Date startDate = getStartDTOfMonth(rollMonth(endDate, -11));
    		return getMonthBetween(startDate, endDate);
    	}
    	public static List<Date> getLastTwelveMonth(Date date){
    		Date endDate = getStartDTOfMonth(rollMonth(date, -1));
    		Date startDate = getStartDTOfMonth(rollMonth(endDate, -11));
    		return getMonthBetween(startDate, endDate);
    	}
        
    	/**
         * 得到一年中的总周数
         */
        public static int getWeeksOfYear(int year){
        	Calendar cal = Calendar.getInstance();
        	cal.set(Calendar.YEAR, year);
        	Date startDate = getStartDTOfYear(cal.getTime());
        	Date endDate = getEndDTOfYear(cal.getTime());
        	List<Date> dateList = getWeekBetween(startDate, endDate);
        	return dateList.size();
        }
        public static int getWeeksOfYear(Date date){
        	Calendar cal = Calendar.getInstance();
        	cal.setTime(date);
        	Date startDate = getStartDTOfYear(cal.getTime());
        	Date endDate = getEndDTOfYear(cal.getTime());
        	List<Date> dateList = getWeekBetween(startDate, endDate);
        	return dateList.size();
        }
    }

    欢迎各位大侠拍砖

    展开全文
  • date4j是一个用于简化日期时间操作的Java工具。可以替换java.util.Date。
  • 主要介绍了JAVA时间日期处理类,可实现遍历两个日期之间的每一天的功能,涉及针对日期的常见操作技巧,需要的朋友可以参考下
  • Java时间日期处理相关文档收藏 Java时间日期处理 Java日期处理
  • JAVA处理日期时间常用方法.JAVA处理日期时间常用方法: java.util.Calendar
  • Java8 日期时间处理

    千次阅读 2020-05-29 17:50:59
    Java 8以前Java处理日期、日历和时间的方式一直为社区所诟病,将 java.util.Date设定为可变类型,以及SimpleDateFormat的非线程安全使其应用非常受限。 Date如果不格式化,打印出的日期可读性差 Fri May 29 15:38:...


    【前言】

    Java 8以前Java处理日期、日历和时间的方式一直为社区所诟病,将 java.util.Date设定为可变类型,以及SimpleDateFormat的非线程安全使其应用非常受限。

    Date如果不格式化,打印出的日期可读性差

    Fri May 29 15:38:01 CST 2020

    阿里巴巴开发手册中禁用static修饰SimpleDateFormat
    在这里插入图片描述
    SimpleDateFormat的format方法最终调用代码

    private StringBuffer format(Date date, StringBuffer toAppendTo, FieldDelegate delegate) {
            
        calendar.setTime(date);
    
        boolean useDateFormatSymbols = useDateFormatSymbols();
    
        for (int i = 0; i < compiledPattern.length; ) {
            int tag = compiledPattern[i] >>> 8;
            int count = compiledPattern[i++] & 0xff;
            if (count == 255) {
                count = compiledPattern[i++] << 16;
                count |= compiledPattern[i++];
            }
    
            switch (tag) {
            case TAG_QUOTE_ASCII_CHAR:
                toAppendTo.append((char)count);
                break;
    
            case TAG_QUOTE_CHARS:
                toAppendTo.append(compiledPattern, i, count);
                i += count;
                break;
    
            default:
                subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
                break;
            }
        }
        return toAppendTo;
    }
    

    calendar是共享变量,并且这个共享变量没有做线程安全控制。当多个线程同时使用相同的SimpleDateFormat对象【如用static修饰的SimpleDateFormat】调用format方法时,多个线程会同时调用calendar.setTime方法,可能一个线程刚设置好time值另外的一个线程马上把设置的time值给修改了导致返回的格式化时间可能是错误的。在多并发情况下使用SimpleDateFormat需格外注意 SimpleDateFormat除了format是线程不安全以外,parse方法也是线程不安全的。parse方法实际调用alb.establish(calendar).getTime()方法来解析,alb.establish(calendar)方法里主要完成了

    a、重置日期对象cal的属性值
    b、使用calb中中属性设置cal
    c、返回设置好的cal对象

    但是这三步不是原子操作

    多线程并发如何保证线程安全:

    • 避免线程之间共享一个SimpleDateFormat对象,每个线程使用时都创建一次SimpleDateFormat对象 => 创建和销毁对象的开销大
    • 对使用format和parse方法的地方进行加锁 => 线程阻塞性能差
    • 使用ThreadLocal保证每个线程最多只创建一次SimpleDateFormat对象 => 较好的方法

    Date对时间处理比较麻烦,比如想获取某年、某月、某星期,以及n天以后的时间,如果用Date来处理的话真是太难了,你可能会说Date类不是有getYear、getMonth这些方法吗,获取年月日很Easy,但都被弃用了啊


    【Java8 提供的时间处理类】

    java8借鉴了第三方日期库joda很多的优点

    java.time

    类名描述
    Instant时间戳
    Duration持续时间,时间差
    LocalDate只包含日期,比如:2020-05-20
    LocalTime只包含时间,比如:13:14:00
    LocalDateTime包含日期和时间,比如:2020-05-20 13:14:00
    Period时间段
    ZoneOffset时区偏移量,比如:+8:00
    ZonedDateTime带时区的时间
    Clock时钟,比如获取目前美国纽约的时间

    java.time.format

    类名描述
    DateTimeFormatter时间格式化

    【常用API】

    【LocalDate】

    获取今天的日期(年月日)

    // 2020-05-20
    LocalDate localDate = LocalDate.now();
    

    指定日期

    // 2020-05-20
    LocalDate localDate = LocalDate.of(2020, 5, 20);
    

    获取年、月、日、星期几

    // 获取年
    int year = localDate.getYear();
    int year1 = localDate.get(ChronoField.YEAR);
    
    // 获取月
    Month month = localDate.getMonth();
    int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);
    
    // 获取日
    int day = localDate.getDayOfMonth();
    int day1 = localDate.get(ChronoField.DAY_OF_MONTH);
    
    // 获取星期几
    DayOfWeek dayOfWeek = localDate.getDayOfWeek();
    int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);
    

    日期计算

    日期做减法处理(以1为例)

    // 去年
    localDate.minusYears(1);
    // 上个月
    localDate.minusMonths(1);
    // 上个星期
    localDate.minusWeeks(1);
    // 昨天
    localDate.minusDays(1);
    

    日期做加法处理(以1为例)

    // 明年
    localDate.plusYears(1);
    // 下个月
    localDate.plusMonths(1);
    // 下个星期
    localDate.plusWeeks(1);
    // 明天
    localDate.plusDays(1);
    

    日期判断

    // 是否相等
    localDate.isEqual(localDate1);
    // 是否早于
    localDate.isBefore(localDate1);
    // 是否晚于
    localDate.isAfter(localDate1);
    // 是否是闰年
    localDate.isLeapYear();
    

    日期设置

    // 设置年
    localDate.withYear(2020);
    // 设置月份
    localDate.withMonth(5);
    // 设置日期
    localDate.withDayOfMonth(20);
    localDate.withDayOfYear(100);
    

    检查像生日这种周期性事件

    // 假设今天是 2020-05-20
    LocalDate date1 = LocalDate.now();
    MonthDay currentMonthDay = MonthDay.from(date1);
    
    LocalDate date2 = LocalDate.of(1996,5,20);
    MonthDay birthday = MonthDay.from(date2);
    
    if(currentMonthDay.equals(birthday)){
        System.out.println("今天是你的生日");
    }
    

    只要当天的日期和生日匹配,无论是哪一年都会打印出祝贺信息。你可以把程序整合进系统时钟,看看生日时是否会受到提醒,或者写一个单元测试来检测代码是否运行正确。


    【LocalTime】

    获取当前时间(不包含日期)

    // 13:14:00.111
    LocalTime localTime = LocalTime.now();
    

    指定时间

    LocalTime localTime = LocalTime.of(13, 14, 0);
    

    获取时分秒

    //获取小时
    int hour = localTime.getHour();
    int hour1 = localTime.get(ChronoField.HOUR_OF_DAY);
    
    //获取分
    int minute = localTime.getMinute();
    int minute1 = localTime.get(ChronoField.MINUTE_OF_HOUR);
    
    //获取秒
    int second = localTime.getSecond();
    int second1 = localTime.get(ChronoField.SECOND_OF_MINUTE);
    

    时间计算

    时间做减法处理(以1为例)

     // 上一小时
     localTime.minusHours(1);
     // 上一分钟
     localTime.minusMinutes(1);
     // 上一秒
     localTime.minusSeconds(1);
    

    时间做加法处理(以1为例)

    // 下一小时
    localTime.plusHours(1);
    // 下一分钟
    localTime.plusMinutes(1);
    // 下一秒
    localTime.plusSeconds(1);
    

    时间判断

    // 是否相等
    localTime.equals(localTime1);
    // 是否早于
    localTime.isBefore(localTime1);
    // 是否晚于
    localTime.isAfter(localTime1);
    

    时间设置

    // 设置小时
    localTime.withHour(13);
    // 设置分钟
    localTime.withMinute(14);
    // 设置秒
    localTime.withSecond(0);
    // 设置毫秒
    localTime.withNano(0);
    

    【LocalDateTime】

    获取年月日 时分秒,等于LocalDate + LocalTime

    获取年月日时分秒

    LocalDateTime localDateTime = LocalDateTime.now();
    

    获取LocalDate

    LocalDate localDate = localDateTime.toLocalDate();
    

    获取LocalTime

    LocalTime localTime = localDateTime.toLocalTime();
    

    指定日期

    LocalDateTime.of(localDate, localTime);
    
    LocalDateTime.of(2020, 5, 20, 13, 14, 0);
    

    判断

    // 是否相等
    localdatetime.isEqual(localdatetime1);
    // 是否早于
    localdatetime.isBefore(localdatetime1);
    // 是否晚于
    localdatetime.isAfter(localdatetime1);
    

    【Instant】时间戳

    创建Instant对象

    Instant instant = Instant.now();
    

    获取秒数

    long currentSecond = instant.getEpochSecond();
    

    获取毫秒数

    long currentMilli = instant.toEpochMilli();
    

    如果只是为了获取毫秒数,使用System.currentTimeMillis()来得更为方便


    【Clock】时钟

    Java 8增加了一个Clock时钟类用于获取当时的时间戳,或当前时区下的日期时间信息。以前用到System.currentTimeInMillis()和TimeZone.getDefault()的地方都可用Clock替换。

    // UTC
    Clock clock = Clock.systemUTC();
    
    // system clock zone
    Clock defaultClock = Clock.systemDefaultZone();
    

    【DateTimeFormatter】

    格式化时间

    LocalDate localDate = LocalDate.of(2020, 5, 20);
    String s1 = localDate.format(DateTimeFormatter.BASIC_ISO_DATE);
    String s2 = localDate.format(DateTimeFormatter.ISO_LOCAL_DATE);
    
    //自定义格式化
    DateTimeFormatter dateTimeFormatter =   DateTimeFormatter.ofPattern("dd/MM/yyyy");
    String s3 = localDate.format(dateTimeFormatter);
    

    DateTimeFormatter默认提供了多种格式化方式,如果默认提供的不能满足要求,可以通过DateTimeFormatter的ofPattern方法创建自定义格式化方式

    解析时间

    LocalDate localDate1 = LocalDate.parse("20190910", DateTimeFormatter.BASIC_ISO_DATE);
    LocalDate localDate2 = LocalDate.parse("2019-09-10", DateTimeFormatter.ISO_LOCAL_DATE);
    

    和SimpleDateFormat相比,DateTimeFormatter是线程安全的


    【java8 时间类与Date类的相互转化】

    在转换中,我们需要注意,因为java8之前Date是包含日期和时间的,而LocalDate只包含日期,LocalTime只包含时间,所以与Date在互转中,势必会丢失日期或者时间,或者会使用起始时间。如果转LocalDateTime,那么就不存在信息误差。

    //Date与Instant的相互转化
    Instant instant  = Instant.now();
    Date date = Date.from(instant);
    Instant instant2 = date.toInstant();
    
    //Date -> LocalDateTime
    Date date2 = new Date();
    LocalDateTime localDateTime2 = LocalDateTime.ofInstant(date2.toInstant(), ZoneId.systemDefault());
    
    //LocalDateTime -> Date
    LocalDateTime localDateTime3 = LocalDateTime.now();
    Instant instant3 = localDateTime3.atZone(ZoneId.systemDefault()).toInstant();
    Date date3 = Date.from(instant);
    
    //LocalDate -> Date
    //因为LocalDate不包含时间,所以转Date时,会默认转为当天的起始时间,00:00:00
    LocalDate localDate4 = LocalDate.now();
    Instant instant4 = localDate4.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant();
    Date date4 = Date.from(instant);
    

    SpringBoot中应用LocalDateTime

    将LocalDateTime字段以时间戳的方式返回给前端 添加日期转化类

    public class LocalDateTimeConverter extends JsonSerializer<LocalDateTime> {
    
        @Override
        public void serialize(LocalDateTime localDateTime, JsonGenerator jsonGenerator, SerializerProvider serializers) throws IOException {
        	jsonGenerator.writeNumber(localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli());
        }
    }
    

    并在LocalDateTime字段上添加@JsonSerialize(using = LocalDateTimeConverter.class)注解,如下:

    @JsonSerialize(using = LocalDateTimeConverter.class)
    protected LocalDateTime createTime;
    

    将LocalDateTime字段以指定格式化日期的方式返回给前端 在LocalDateTime字段上添加@JsonFormat(shape=JsonFormat.Shape.STRING, pattern=“yyyy-MM-dd HH:mm:ss”)注解即可,如下:

    @JsonFormat(shape=JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss")
    protected LocalDateTime createTime;
    

    对前端传入的日期进行格式化 在LocalDateTime字段上添加@DateTimeFormat(pattern = “yyyy-MM-dd HH:mm:ss”)注解即可,如下:

    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    protected LocalDateTime createTime;
    

    【参考文章】

    老大,你为什么在代码中要求我们使用LocalDateTime而不是Date?

    Java 8 中处理日期和时间示例

    18个Java8日期处理的实践,太有用了!

    Java8 LocalDateTime和Date相互转换

    【推荐文章】

    日期时间【墙裂推荐】

    展开全文
  • 主要给大家介绍了利用Java中的Calendar 类处理日期时间的方法汇总,其中包括取日期的每部分、取当月的第一天或最后一天、求两个日期之间相隔的天数以及一年前的日期等等的示例代码,有需要的朋友们可以直接参考借鉴...
  • java8 日期时间处理

    千次阅读 2017-11-06 23:35:27
    最近了解了一下java8的新日期时间类库,简直方便到感人。重构了一下代码,行数少了多一半,有些方法直接删掉了,因为已经自带了。适用多种业务场景:展示、统计、设置有效期、增加/减少日期、日期比较等。 package ...

    之前有个项目频繁用到年、月、周的数据库统计。为此专门写了一个蛮复杂的工具类。最近了解了一下java8的新日期时间类库,简直方便到感人。重构了一下代码,行数少了多一半,有些方法直接删掉了,因为已经自带了。适用多种业务场景:展示、统计、设置有效期、增加/减少日期、日期比较等。

    package com.utils.zjc;
    
    import java.time.DayOfWeek;
    import java.time.Instant;
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.time.LocalTime;
    import java.time.ZoneId;
    import java.time.format.DateTimeFormatter;
    import java.time.temporal.TemporalAdjusters;
    
    public class DateMethod8{
    
    	//把毫秒数转换为标准日期时间字符串
    	public String formatMilliSecond(long milliSeconds) {
    		ZoneId z=ZoneId.systemDefault();
    		Instant instant = Instant.now();
    		LocalDateTime datetime = LocalDateTime.ofEpochSecond(milliSeconds/1000, 0,z.getRules().getOffset(instant));
    		DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    		return datetime.format(formatter);
    	}
    
    	//获取当前日期时间字符串
    	public String getNowDateAndTimeString() {
    		LocalDateTime now = LocalDateTime.now();
    		DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    		return now.format(formatter);
    	}
    
    	//获取当前日期字符串
    	public String getNowDateString() {
    		LocalDate today=LocalDate.now();
    		return today.toString();
    	}
    
    	//获取当前时间字符串
    	public String getNowTimeString() {
    		LocalTime now = LocalTime.now();
    		DateTimeFormatter formatter=DateTimeFormatter.ofPattern("HH:mm:ss");
    		return now.format(formatter);
    	}
    
    	//获取某年某月第一天
    	public String getYearMonthFirstDayString(int year, int month) throws Exception {
    		if(month<1||month>12){
    			throw new Exception("invalid parameters");
    		}
    		Integer iyear = Integer.valueOf(year);
    		Integer imonth = Integer.valueOf(month);
    		if(month<10){
    			return iyear.toString()+"-0"+imonth.toString()+"-01 00:00:00";
    		}else{
    			return iyear.toString()+"-"+imonth.toString()+"-01 00:00:00";
    		}
    	}
    	
    	//获取某年某月最后一天
    	public String getYearMonthLastDayString(int year, int month) throws Exception {
    		if(month<1||month>12){
    			throw new Exception("invalid parameters");
    		}
    		LocalDate date = LocalDate.of(year,month,1);
    		Integer lastday=date.getMonth().length(date.isLeapYear());
    		Integer iyear = Integer.valueOf(year);
    		Integer imonth = Integer.valueOf(month);
    		if(month<10){
    			return iyear.toString()+"-0"+imonth.toString()+"-"+lastday.toString()+" 23:59:59";
    		}else{
    			return iyear.toString()+"-"+imonth.toString()+"-"+lastday.toString()+" 23:59:59";
    		}
    	}
    
    	//获取某年某月某日所在周的某一天
    	public String getWeekDayString(int year, int month, int day, DayOfWeek dow) throws Exception{
    		try{
    			LocalDate date = LocalDate.of(year,month,day);
    			LocalDate newDate = date.with(TemporalAdjusters.nextOrSame(dow));
    			return newDate.toString();
    		}catch(Exception e){
    			throw new Exception("invalid parameters");
    		}
    	}
    	public static void main(String[] args){
    		LocalDateTime now = LocalDateTime.now();
    		LocalDateTime nextMonth = now.plusMonths(1);  //向后延续一个月
    		DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    		System.out.println(nextMonth.format(formatter));
    		int compareResult = nextMonth.compareTo(now); //比较日期和时间
    		if(compareResult>0){
    			System.out.println("晚于当前");
    		}else if(compareResult==0){
    			System.out.println("相同");
    		}else{
    			System.out.println("早于当前");
    		};
    		LocalDate temp = LocalDate.now();
    		System.out.println(temp.with(TemporalAdjusters.lastDayOfMonth()));//月末一天的另一种方法
    		Duration dtime = Duration.between(now, nextMonth);  //计算时间间隔
    		long seconds = dtime.getSeconds();//秒表示 
    		long millis = dtime.toMillis();//毫秒表示
    		System.out.println(seconds);
    		System.out.println(millis);
    		try{
    			LocalDate newDate = LocalDate.of(2005,2,28);  //验证日期有效性
    			LocalDateTime newTime = LocalDateTime.of(newDate, LocalTime.now());
    			System.out.println("日期有效");
    			System.out.println(newTime.format(formatter));
    		}catch(Exception e){
    			System.out.println("日期无效");
    		}
    	}
    }


    展开全文
  • java日期处理大全

    2012-12-05 12:45:25
    java日期处理大全,用与时间的各种处理。。
  • Java 时间日期处理

    千次阅读 2017-07-24 10:46:11
    Java 时间日期处理 王下邀月熊 18 小时前 Java 时间日期处理 从属于笔者的现代 Java 开发系列文章,涉及到的引用资料声明在 Java 学习与实践资料索引中。 Java 时间日期处理Java 8 之前,我们...

    Java 时间与日期处理

    王下邀月熊 王下邀月熊
    18 小时前
    Java 时间与日期处理 从属于笔者的 现代 Java 开发系列文章,涉及到的引用资料声明在 Java 学习与实践资料索引中。

    Java 时间与日期处理

    在 Java 8 之前,我们最常见的时间与日期处理相关的类就是 Date、Calendar 以及 SimpleDateFormatter 等等。不过 java.util.Date 也是被诟病已久,它包含了日期、时间、毫秒数等众多繁杂的信息,其内部利用午夜 12 点来区分日期,利用 1970-01-01 来计算时间;并且其月份从 0 开始计数,而且用于获得年、月、日等信息的接口也是太不直观。除此之外,java.util.Date与 SimpleDateFormatter 都不是类型安全的,而 JSR-310 中的 LocalDate 与 LocalTime 等则是不变类型,更加适合于并发编程。JSR 310 实际上有两个日期概念。第一个是 Instant,它大致对应于 java.util.Date 类,因为它代表了一个确定的时间点,即相对于标准 Java 纪元(1970年1月1日)的偏移量;但与 java.util.Date 类不同的是其精确到了纳秒级别。另一个则是 LocalDate、LocalTime 以及 LocalDateTime 这样代表了一般时区概念、易于理解的对象。

    Class / TypeDescriptionYearRepresents a year.YearMonthA month within a specific year.LocalDateA date without an explicitly specified time zone.LocalTimeA time without an explicitly specified time zone.LocalDateTimeA combination date and time without an explicitly specified time zone.

    最新 JDBC 映射将把数据库的日期类型和 Java 8 的新类型关联起来:

    SQLJavadateLocalDatetimeLocalTimetimestampLocalDateTimedatetimeLocalDateTime

    时间与日期基础概念

    标准时间

    GMT 即「格林威治标准时间」( Greenwich Mean Time,简称 G.M.T. ),指位于英国伦敦郊区的皇家格林威治天文台的标准时间,因为本初子午线被定义为通过那里的经线。然而由于地球的不规则自转,导致 GMT 时间有误差,因此目前已不被当作标准时间使用。UTC 是最主要的世界时间标准,是经过平均太阳时(以格林威治时间 GMT 为准)、地轴运动修正后的新时标以及以「秒」为单位的国际原子时所综合精算而成的时间。UTC 比 GMT 来得更加精准。其误差值必须保持在 0.9 秒以内,若大于 0.9 秒则由位于巴黎的国际地球自转事务中央局发布闰秒,使 UTC 与地球自转周期一致。不过日常使用中,GMT 与 UTC 的功能与精确度是没有差别的。协调世界时区会使用 “Z” 来表示。而在航空上,所有使用的时间划一规定是协调世界时。而且 Z 在无线电中应读作 “Zulu”(可参见北约音标字母),协调世界时也会被称为 “Zulu time”。

    TimeZone&UTC Offsets: 时区与偏移

    人们经常会把时区与 UTC 偏移量搞混,UTC 偏移量代表了某个具体的时间值与 UTC 时间之间的差异,通常用 HH:mm 形式表述。而 TimeZone 则表示某个地理区域,某个 TimeZone 中往往会包含多个偏移量,而多个时区可能在一年的某些时间有相同的偏移量。譬如 America/Chicago, America/Denver, 以及 America/Belize 在一年中不同的时间都会包含 -06:00 这个偏移。

    时间戳

    Unix 时间戳表示当前时间到 1970 年 1 月 1 日 00:00:00 UTC 对应的秒数。注意,JavaScript 内的时间戳指的是当前时间到 1970 年 1 月 1 日 00:00:00 UTC 对应的毫秒数,和 Unix 时间戳不是一个概念,后者表示秒数,差了 1000 倍。

    时间数字字符串格式

    RFC2822

    YYYY/MM/DD HH:MM:SS ± timezone(时区用4位数字表示)
    // eg 1992/02/12 12:23:22+0800
    

    ISO 8601

    国际标准化组织的国际标准 ISO 8601 是日期和时间的表示方法,全称为《数据存储和交换形式·信息交换·日期和时间的表示方法》。目前最新为第三版 ISO8601:2004,第一版为 ISO8601:1988,第二版为 ISO8601:2000。年由 4 位数组成,以公历公元 1 年为 0001 年,以公元前 1 年为 0000 年,公元前 2 年为 -0001 年,其他以此类推。应用其他纪年法要换算成公历,但如果发送和接受信息的双方有共同一致同意的其他纪年法,可以自行应用。

    YYYY-MM-DDThh:mm:ss ± timezone(时区用HH:MM表示)
    1997-07-16T08:20:30Z
    // “Z”表示UTC标准时区,即"00:00",所以这里表示零时区的`1997年7月16日08时20分30秒`
    //转换成位于东八区的北京时间则为`1997年7月17日16时20分30秒`
    1997-07-16T19:20:30+01:00
    // 表示东一区的1997年7月16日19时20秒30分,转换成UTC标准时间的话是1997-07-16T18:20:30Z
    

    时间戳

    在 Java 8 之前,我们使用 java.sql.Timestamp 来表示时间戳对象,可以通过以下方式创建与获取对象:

    // 利用系统标准时间创建
    Timestamp timestamp = new Timestamp(System.currentTimeMillis());
    
    // 从 Date 对象中创建
    new Timestamp((new Date()).getTime());
    
    // 获取自 1970-01-01 00:00:00 GMT 以来的毫秒数
    timestamp.getTime();
    

    在 Java 8 中,即可以使用 java.time.Instant 来表示自从 1970-01-01T00:00:00Z 之后经过的标准时间:

    // 基于静态函数创建
    Instant instant = Instant.now();
    
    // 基于 Date 或者毫秒数转换
    Instant someInstant = someDate.toInstant();
    Instant someInstant = Instant.ofEpochMilli(someDate.getTime());
    
    // 基于 TimeStamp 转换
    Instant instant = timestamp.toInstant();
    
    // 从 LocalDate 转化而来
    LocalDate.now().atStartOfDay().toInstant(ZoneOffset.UTC)
    
    // 从 LocalDateTime 转化而来
    ldt.atZone(ZoneId.systemDefault()).toInstant();
    
    // 获取毫秒
    long timeStampMillis = instant.toEpochMilli();
    
    // 获取秒
    long timeStampSeconds = instant.getEpochSecond();
    

    Clock 方便我们去读取当前的日期与时间。Clock 可以根据不同的时区来进行创建,并且可以作为System.currentTimeMillis()的替代。这种指向时间轴的对象即是Instant类。Instants 可以被用于创建java.util.Date对象。

    Clock clock = Clock.systemDefaultZone();
    long millis = clock.millis();
    
    Instant instant = clock.instant();
    Date legacyDate = Date.from(instant);   // legacy java.util.Date
    

    Date

    // 默认创建
    Date date0 = new Date();
    
    // 从 TimeStamp 中创建
    Date date1 = new Date(time);
    
    // 基于 Instant 创建
    Date date = Date.from(instant);
    
    // 从格式化字符串中获取
    SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    java.util.Date dt=sdf.parse("2005-2-19");
    
    // 从 LocalDateTime 中转化而来
    Date out = Date.from(ldt.atZone(ZoneId.systemDefault()).toInstant());
    

    基于 Date 的日期比较常常使用以下方式:

    • 使用 getTime() 方法获取两个日期(自1970年1月1日经历的毫秒数值),然后比较这两个值。
    • 使用方法 before(),after() 和 equals()。例如,一个月的12号比18号早,则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
    • 使用 compareTo() 方法,它是由 Comparable 接口定义的,Date 类实现了这个接口。

    Calendar

    Date 用于记录某一个含日期的、精确到毫秒的时间。重点在代表一刹那的时间本身。 Calendar 用于将某一日期放到历法中的互动——时间和年、月、日、星期、上午、下午、夏令时等这些历法规定互相作用关系和互动。我们可以通过 Calendar 内置的构造器来创建实例:

    Calendar.Builder builder =new Calendar.Builder();
    Calendar calendar1 = builder.build();
    Date date = calendar.getTime();
    

    在 Calendar 中我们则能够获得较为直观的年月日信息:

    // 2017,不再是 2017 - 1900 = 117
    int year =calendar.get(Calendar.YEAR);
    
    int month=calendar.get(Calendar.MONTH)+1;
    
    int day =calendar.get(Calendar.DAY_OF_MONTH);
    
    int hour =calendar.get(Calendar.HOUR_OF_DAY);
    
    int minute =calendar.get(Calendar.MINUTE);
    
    int seconds =calendar.get(Calendar.SECOND);    
    

    除此之外,Calendar 还提供了一系列 set 方法来允许我们动态设置时间,还可以使用 add 等方法进行日期的加减。

    SimpleDateFormat

    SimpleDateFormat 用来进行简单的数据格式化转化操作:

    Date dNow = new Date( );
    SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
    

    LocalDateTime

    LocalDate

    // 取当前日期:
    LocalDate today = LocalDate.now();
    
    // 根据年月日取日期,12月就是12:
    LocalDate crischristmas = LocalDate.of(2017, 5, 15); 
    
    // 根据指定格式字符串取
    LocalDate endOfFeb = LocalDate.parse("2017-05-15"); // 严格按照ISO yyyy-MM-dd验证,02写成2都不行,当然也有一个重载方法允许自己定义格式
    LocalDate.parse("2014-02-29"); // 无效日期无法通过:DateTimeParseException: Invalid date
    
    // 通过自定义时间字符串格式获取
    DateTimeFormatter germanFormatter =
        DateTimeFormatter
            .ofLocalizedDate(FormatStyle.MEDIUM)
            .withLocale(Locale.GERMAN);
    
    LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
    System.out.println(xmas);   // 2014-12-24
    
    // 获取其他时区下日期
    LocalDate localDate = LocalDate.now(ZoneId.of("GMT+02:30"));
    
    // 从 LocalDateTime 中获取实例
    LocalDateTime localDateTime = LocalDateTime.now();
    LocalDate localDate = localDateTime.toLocalDate();
    

    日期操作

    // 取本月第1天
    LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth()); // 2014-12-01
    
    // 取本月第2天
    LocalDate secondDayOfThisMonth = today.withDayOfMonth(2); // 2014-12-02
    
    // 取本月最后一天,再也不用计算是28,29,30还是31
    LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth()); // 2014-12-31
    
    // 取下一天
    LocalDate firstDayOf2015 = lastDayOfThisMonth.plusDays(1); // 变成了2015-01-01
    
    // 取2015年1月第一个周一
    LocalDate firstMondayOf2015 = LocalDate.parse("2015-01-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY)); // 2015-01-05
    

    LocalTime

    // 获取其他时区下时间
    LocalTime localTime = LocalTime.now(ZoneId.of("GMT+02:30"));
    
    // 从 LocalDateTime 中获取实例
    LocalDateTime localDateTime = LocalDateTime.now();
    LocalTime localTime = localDateTime.toLocalTime();
    
    
    - 12:00
    - 12:01:02
    - 12:01:02.345
    

    LocalDateTime

    // 通过时间戳创建
    LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochSecond(1450073569l), TimeZone.getDefault().toZoneId());
    
    // 通过 Date 对象创建
    Date in = new Date();
    LocalDateTime ldt = LocalDateTime.ofInstant(in.toInstant(), ZoneId.systemDefault());
    
    // 通过解析时间字符串创建
    DateTimeFormatter formatter =
        DateTimeFormatter
            .ofPattern("MMM dd, yyyy - HH:mm");
    
    LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
    String string = formatter.format(parsed);
    System.out.println(string);     // Nov 03, 2014 - 07:13
    
    • 获取年、月、日等信息
    LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
    
    DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
    System.out.println(dayOfWeek);      // WEDNESDAY
    
    Month month = sylvester.getMonth();
    System.out.println(month);          // DECEMBER
    
    long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
    System.out.println(minuteOfDay);    // 1439
    
    • 时间格式化展示
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
    LocalDateTime dateTime = LocalDateTime.of(1986, Month.APRIL, 8, 12, 30);
    String formattedDateTime = dateTime.format(formatter); // "1986-04-08 12:30"
    

    时间操作

    localDateTime.plusDays(1);
    localDateTime.minusHours(2);
    

    时区转换

    Timezones 以 ZoneId 来区分。可以通过静态构造方法很容易的创建,Timezones 定义了 Instants 与 Local Dates 之间的转化关系:

    System.out.println(ZoneId.getAvailableZoneIds());
    // prints all available timezone ids
    
    ZoneId zone1 = ZoneId.of("Europe/Berlin");
    ZoneId zone2 = ZoneId.of("Brazil/East");
    System.out.println(zone1.getRules());
    System.out.println(zone2.getRules());
    
    // ZoneRules[currentStandardOffset=+01:00]
    // ZoneRules[currentStandardOffset=-03:00]
    LocalDateTime ldt = ...
    ZonedDateTime zdt = ldt.atZone(ZoneId.systemDefault());
    Date output = Date.from(zdt.toInstant());
    ZoneId losAngeles = ZoneId.of("America/Los_Angeles");
    ZoneId berlin = ZoneId.of("Europe/Berlin");
    
    // 2014-02-20 12:00
    LocalDateTime dateTime = LocalDateTime.of(2014, 02, 20, 12, 0);
    
    // 2014-02-20 12:00, Europe/Berlin (+01:00)
    ZonedDateTime berlinDateTime = ZonedDateTime.of(dateTime, berlin);
    
    // 2014-02-20 03:00, America/Los_Angeles (-08:00)
    ZonedDateTime losAngelesDateTime = berlinDateTime.withZoneSameInstant(losAngeles);
    
    int offsetInSeconds = losAngelesDateTime.getOffset().getTotalSeconds(); // -28800
    
    // a collection of all available zones
    Set<String> allZoneIds = ZoneId.getAvailableZoneIds();
    
    // using offsets
    LocalDateTime date = LocalDateTime.of(2013, Month.JULY, 20, 3, 30);
    ZoneOffset offset = ZoneOffset.of("+05:00");
    
    // 2013-07-20 03:30 +05:00
    OffsetDateTime plusFive = OffsetDateTime.of(date, offset);
    
    // 2013-07-19 20:30 -02:00
    OffsetDateTime minusTwo = plusFive.withOffsetSameInstant(ZoneOffset.ofHours(-2));
    

    时差

    Period 类以年月日来表示日期差,而 Duration 以秒与毫秒来表示时间差;Duration 适用于处理 Instant 与机器时间。


    // periods
    
    LocalDate firstDate = LocalDate.of(2010, 5, 17); // 2010-05-17
    LocalDate secondDate = LocalDate.of(2015, 3, 7); // 2015-03-07
    Period period = Period.between(firstDate, secondDate);
    
    int days = period.getDays(); // 18
    int months = period.getMonths(); // 9
    int years = period.getYears(); // 4
    boolean isNegative = period.isNegative(); // false
    
    Period twoMonthsAndFiveDays = Period.ofMonths(2).plusDays(5);
    LocalDate sixthOfJanuary = LocalDate.of(2014, 1, 6);
    
    // add two months and five days to 2014-01-06, result is 2014-03-11
    LocalDate eleventhOfMarch = sixthOfJanuary.plus(twoMonthsAndFiveDays);
    
    
    // durations
    
    Instant firstInstant= Instant.ofEpochSecond( 1294881180 ); // 2011-01-13 01:13
    Instant secondInstant = Instant.ofEpochSecond(1294708260); // 2011-01-11 01:11
    
    Duration between = Duration.between(firstInstant, secondInstant);
    
    // negative because firstInstant is after secondInstant (-172920)
    long seconds = between.getSeconds();
    
    // get absolute result in minutes (2882)
    long absoluteResult = between.abs().toMinutes();
    
    // two hours in seconds (7200)
    long twoHoursInSeconds = Duration.ofHours(2).getSeconds();
    
    展开全文
  • Java 8新增了LocalDate和LocalTime接口,接下来通过本文给大家介绍Java 8中日期时间处理方法,非常不错,感兴趣的朋友一起看下吧
  • 高级时间日期处理Java
  • 日期和时间格式由 日期和时间模式字符串 指定。...只是在格式化时将它们简单复制到输出字符串白话文的讲:这些A——Z,a——z这些字母(不被单引号包围的)会被特殊处理替换为对应的日期时间,其他的字...
  • Java处理时间日期

    千次阅读 2019-02-27 23:13:40
    从 JDK 1.1 开始,应该使用 Calendar 类实现日期时间字段之间转换,使用 DateFormat 类来格式化和分析日期字符串。Date 中的把日期解释为年、月、日、小时、分钟和秒值的方法已废弃。 1.2 java.text.DateFormat...
  • Java DateTime 日期时间处理

    千次阅读 2014-12-04 22:28:53
    java.util.Datejava.sql.Datejava.sql.Timejava.sql.Timestamp-------------------------------------java.util.Calendarjava.util.GregorianCalendarjava.util.TimeZonejava.util.SimpleTimeZone------------
  • java日期处理小结

    2012-12-07 09:56:42
    java日期处理 和格式解析 包含java.util.Calender java.util. GregorianCalendar java.util.Date
  • java读取Excel中的日期时间处理

    万次阅读 2017-12-14 14:07:46
    java读取Excel中的日期时间处理
  • Java日期时间

    千次阅读 2014-11-28 10:56:26
    Java日期时间类 Date类 Java提供的Date类和Calendar类用于处理日期和时间的类,包括创建日期,时间对象,获取系统当前日期,时间 等操作。但Date类无法实现国际化,注意,月份与小时都是以0开始,而月份中的天数...
  • Java日期处理

    千次阅读 2012-08-17 18:55:30
    学习Java日期处理,看见这一篇比较详细,转载之。 转自:http://www.cnblogs.com/hqr9313/archive/2012/04/19/2458221.html 时间日期 1)java中的时间类有:Date和Calendar 2)java中时间类的本质 long(毫秒...
  • 自己整理的Java日期处理类 。包含获取两个之间段之间的天数、月初日期,月末日期、一个时间段之间的所有的日期,月份 一周的第一天,最后一天、 当前是周几等。仅供参考
  • java处理日期合并

    2014-03-25 10:09:13
    java处理日期合并
  • Java中的时间日期处理

    万次阅读 2016-05-13 00:18:12
    日常开发中对时间或者日期处理肯定层出不穷,简单总结一下Java时间相关的使用方法。 相关类Date: Date表示特定的瞬间,精确到毫秒,Date中的相应方法已废弃,从JDK 1.1开始,应该使用Calendar类实现日期时间...
  • java日期处理代码

    千次阅读 2018-01-25 09:48:18
    下面的代码封装了一系列日期处理的方法,大家看看有没有用得上的,有需要的话就拿去用吧! import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util...
  • Java中的时间日期处理

    千次阅读 2018-07-22 22:06:11
    日期处理 旧版本 Date Calendar Java 8 日期和时间:LocalDate和LocalTime 创建LocalDate和LocalTime的两种方式 ...机器时间处理 旧版本:Timestamp Java 8:Instant 时间区间:Duration和Per...
  • java处理日期时间 相加减

    千次阅读 2016-12-14 09:30:37
    JAVA处理日期时间常用方法:  1.java.util.Calendar  Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得...
  • 2014" 专门用于处理springboard定时任务修改cron参数的日期处理方法 12.获取本月第一天(月初时间) 13.获取本月最后一天(月底时间) 以上这些方法都在该Java工具类,当然不仅仅包含这些,还有其他的很多。
  • java日期格式处理

    千次阅读 2013-01-17 13:24:19
    日期字符串:Wed, 16 Jan 2013 19:01:18 EST 日期格式:EEE, dd MMM yyyy HH:mm:ss ZZZ 参考:...为了防止遗忘,先将页面copy一下 ...时间日期中常用到的几个类:java.util
  • Java日期格式处理

    千次阅读 2016-01-22 09:32:15
    日期字符串:Wed, 16 Jan 2013 19:01:18 EST 日期格式:EEE, dd MMM yyyy HH:mm:ss ZZZ 参考:http://blog.163.com/zhaowenchao_vip/blog/static/1715151442011524114322505/ 为了防止遗忘,先将...
  • 想通过Java来获取某文件夹(或多个文件夹)下的视频的总时长经过查询资料,发现可以通过JAVE实现:The JAVE (Java Audio Video Encoder) library is Java wrapper on the ffmpeg project。 JAVE下载地址

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,520
精华内容 58,608
关键字:

java日期时间处理

java 订阅