精华内容
下载资源
问答
  • JDK8日期时间库 例子

    2018-09-25 18:12:00
    package com.example.java8demo; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.c...

    1. 基本使用例子

    package com.example.java8demo;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.time.*;
    import java.time.format.DateTimeFormatter;
    import java.time.temporal.TemporalAdjusters;
    import java.util.Set;
    
    /**
     * java 8 对于日期和时间的使用
     * API文档:https://blog.fondme.cn/apidoc/jdk-1.8-google/下的java.time包下
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest // 指定启动类
    public class LocalDateTimeTest {
        
        
        /**
         * localDate The operation of time
         */
        @Test
        public void  test1(){
            
            LocalDateTime localDateTime = LocalDateTime.now();
            System.out.println("++++【localDateTime】++++"+localDateTime);
            // -------iso 标准时间体系-------
            LocalDateTime localDateTime1 = LocalDateTime.of(2018, 9, 25, 16, 46);
            System.out.println("++++++【localDateTime1】+++++"+localDateTime1);
            LocalDateTime localDateTime2 = localDateTime1.minusDays(20);
            System.out.println("+++++++【localDateTime2】+++++++"+localDateTime2);
            System.out.println("+++++++【localDateTime2.plusMonths(2)】+++++++++"+localDateTime2.plusMonths(2));
            System.out.println("localDateTime2.getYear()"+localDateTime2.getYear());
            System.out.println("localDateTime2.getMonthValue()"+localDateTime2.getMonthValue());
            System.out.println("localDateTime2.getMonth()"+localDateTime2.getMonth());
            System.out.println("localDateTime2.getDayOfWeek()"+localDateTime2.getDayOfWeek());
            System.out.println("localDateTime2.getDayOfMonth()"+localDateTime2.getDayOfMonth());
            System.out.println("localDateTime2.getHour()"+localDateTime2.getHour());
            System.out.println("localDateTime2.getMinute()"+localDateTime2.getMinute());
            System.out.println("localDateTime2.getSecond()"+localDateTime2.getSecond());
        }
    
        /**
         * 2. Instant : 时间戳。 (使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值)
         */
        @Test
        public void test2(){
            //默认使用 UTC 时区
            Instant ins = Instant.now();
            System.out.println(ins);
            //偏移时区调整,时间偏移量8个小时
            OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));
            System.out.println(odt);
            System.out.println("++++ins.getNano()++++"+ins.getNano()); 
            Instant ins2 = Instant.ofEpochSecond(5); 
            System.out.println("++++ins2++++"+ins2);
        }
        
        /**
         * 计算时间间隔  Duration Period
         * @throws InterruptedException 
         *  toMillis()
         * 
         */
        @Test
        public void test3() throws InterruptedException{
            
            Instant instantBegin = Instant.now();
            Thread.sleep(2000);
            Instant instantEnd = Instant.now();
            System.out.println("输出当前时间间隔差"+ Duration.between(instantBegin, instantEnd).toMillis());
            // -----------------------------------------------------------------------
            LocalDate local1 = LocalDate.now();
            LocalDate local2 = LocalDate.of(2016, 7, 23);
            Period period = Period.between(local1, local2);
            System.out.println("++++year++++"+period.getYears());
            //月份单位不会按年份单位自动标准化。 这意味着“15个月”与“1年3个月”不同。查看api文档
            System.out.println("++++month++++"+period.getMonths());
            System.out.println("++++days++++"+period.getDays());
        }
        
        /**
         * 时间校正器
         * TemporalAdjuster
         */
        @Test
        public void test4(){
            
            LocalDateTime ldt = LocalDateTime.now();
            System.out.println("-----ldt-----"+ldt);
    
            //表示为本月中的第几天
            LocalDateTime ldt2 = ldt.withDayOfMonth(30);
            System.out.println("----ldt2----"+ldt2);
            
            //计算下周一的时间
            LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
            System.out.println("------ldt3-----"+ldt3);
            
            //自定义:下一个工作日
            LocalDateTime ldt4 = ldt.with((local) ->{
                
                LocalDateTime ldt5 = (LocalDateTime) local;
                DayOfWeek dow = ldt5.getDayOfWeek();
                
                if(dow.equals(DayOfWeek.FRIDAY)){
                    return ldt5.plusDays(3);
                }else if(dow.equals(DayOfWeek.SATURDAY)){
                    return ldt5.plusDays(2);
                }else{
                    return ldt5.plusDays(1);
                }
            });
            System.out.println("-------ldt4-----"+ldt4);
            
        }
        
        
        /**
         * 5. DateTimeFormatter : 解析和格式化日期或时间
         */
        @Test
        public void test5(){
            
            DateTimeFormatter dateTimeFormater = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
            LocalDateTime localDateTime = LocalDateTime.now();
            System.out.println("【----未格式化之前----】" + localDateTime);
            System.out.println("【----格式化之后----】"+dateTimeFormater.format(localDateTime));
        }
        
        @Test
        public void test6(){
            // 获取可用时区
            Set<String> set = ZoneId.getAvailableZoneIds();
            set.forEach(System.out::println);
        }
        
        /**
         * 7.ZonedDate、ZonedTime、ZonedDateTime : 带时区的时间或日期
         */
        @Test
        public void test7(){
            
            LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
            System.out.println("----【ldt】----"+ldt);
            
            ZonedDateTime zdt =  ZonedDateTime.now(ZoneId.of("America/New_York"));
            System.out.println("----【zdt】----"+zdt);
        }
        
        
        /**
         * <B>备注:<B>
         * 
         * zone    英[zəʊn]美[zoʊn]n.地带; 区域,范围; 地区,时区;  [物] 晶带;vt.    划分成带; 用带子围绕;vi.    分成区,分成地带;
         * 
         * available 英[əˈveɪləbl]美[əˈveləbəl]adj.    可获得的; 有空的; 可购得的; 能找到的;
         * 
         * offset 美[ˈɔ:fset]vt.  抵消; 补偿; (为了比较的目的而)把…并列(或并置) ; 
         * 为(管道等)装支管;vi.    形成分支,长出分枝; 装支管;n.    开端; 出发; 平版印刷; 抵消,补偿;
         * 
         * duration    美[duˈreɪʃn] n.    持续,持续的时间,期间; (时间的) 持续,持久,连续; [语音学] 音长,音延;
         * 
         * instant    英[ˈɪnstənt] 美[ˈɪnstənt] n.    瞬间,顷刻; 此刻; 当月; 速食食品,即溶饮料; adj.    立即的; 迫切的; 正在考虑的,目前的; 即食的;
         * 
         * temporal 英[ˈtempərəl] 美[ˈtɛmpərəl,ˈtɛmprəl] adj.时间的; 世俗的; 暂存的; <语>表示时间的; n.暂存的事物,世间的事物; 世俗的权力; 一时的事物,俗事;
         * 
         * adjuster    英[ə'dʒʌstə] 美[ə'dʒʌstə] n.调停者,调节器;
         * 
         */
    
    }
    

      2. 封装工具类

    package com.example.java8demo;
    
    import java.time.LocalDateTime;
    import java.time.ZoneId;
    import java.time.format.DateTimeFormatter;
    import java.util.Date;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    
    /**
     * @Title   日期时间工具类
     * @Author  lijingrun
     * @Version 1.0.0
     * @Date 2018/9/25 17:27
     * @Description 使用JDK8新特性封装的日期时间工具类
     */
    public class DateTimeUtils {
    
        private static final ConcurrentMap<String, DateTimeFormatter> FORMATTER_CACHE = new ConcurrentHashMap<>();
    
        private static final int PATTERN_CACHE_SIZE = 500;
        /**
         * Date转换为格式化时间
         * @param date date
         * @param pattern 格式
         * @return
         */
        public static String format(Date date, String pattern){
            return format(LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()), pattern);
        }
    
        /**
         * localDateTime转换为格式化时间
         * @param localDateTime localDateTime
         * @param pattern 格式
         * @return
         */
        public static String format(LocalDateTime localDateTime, String pattern){
            DateTimeFormatter formatter = createCacheFormatter(pattern);
            return localDateTime.format(formatter);
        }
    
        /**
         * 格式化字符串转为Date
         * @param time 格式化时间
         * @param pattern 格式
         * @return
         */
        public static Date parseDate(String time, String pattern){
            return Date.from(parseLocalDateTime(time, pattern).atZone(ZoneId.systemDefault()).toInstant());
    
        }
    
        /**
         * 格式化字符串转为LocalDateTime
         * @param time 格式化时间
         * @param pattern 格式
         * @return
         */
        public static LocalDateTime parseLocalDateTime(String time, String pattern){
            DateTimeFormatter formatter = createCacheFormatter(pattern);
            return LocalDateTime.parse(time, formatter);
        }
    
        /**
         * 在缓存中创建DateTimeFormatter
         * @param pattern 格式
         * @return
         */
        private static DateTimeFormatter createCacheFormatter(String pattern){
            if (pattern == null || pattern.length() == 0) {
                throw new IllegalArgumentException("Invalid pattern specification");
            }
            DateTimeFormatter formatter = FORMATTER_CACHE.get(pattern);
            if(formatter == null){
                if(FORMATTER_CACHE.size() < PATTERN_CACHE_SIZE){
                    formatter = DateTimeFormatter.ofPattern(pattern);
                    //putIfAbsent,如果指定的键尚未与值相关联,请将其与给定值相关联。
                    DateTimeFormatter oldFormatter = FORMATTER_CACHE.putIfAbsent(pattern, formatter);
                    if(oldFormatter != null){
                        formatter = oldFormatter;
                    }
                }
            }
    
            return formatter;
        }
    }
    

      3. 参看文档

    https://blog.fondme.cn/apidoc/jdk-1.8-google/下的java.time包下相关

    https://wizardforcel.gitbooks.io/java8-tutorials/content/Java%208%20%E6%96%B0%E7%89%B9%E6%80%A7%E7%BB%88%E6%9E%81%E6%8C%87%E5%8D%97.html#datetimeAPI

    [Java 8新的时间日期库的20个使用示例](https://wizardforcel.gitbooks.io/java8-tutorials/content/Java%208%20%E6%96%B0%E7%9A%84%E6%97%B6%E9%97%B4%E6%97%A5%E6%9C%9F%E5%BA%93%E7%9A%8420%E4%B8%AA%E4%BD%BF%E7%94%A8%E7%A4%BA%E4%BE%8B.html)

    转载于:https://www.cnblogs.com/move22/p/9701092.html

    展开全文
  • 1、获取当前的日期、时间、日期加时间 LocalDate todayDate = LocalDate.now(); //今天的日期 LocalTime now = LocalTime.now(); //此刻的时间--精确到毫秒 LocalDateTime now = LocalDateTime.now(); ...

    统一使用java.time.*包下的类

    1、获取当前的日期、时间、日期加时间

    LocalDate todayDate = LocalDate.now(); //今天的日期
    
    
    LocalTime now = LocalTime.now(); //此刻的时间--精确到毫秒
    
    
    LocalDateTime now = LocalDateTime.now(); //此刻时间--年-月-日-时-分-秒-毫秒
    

     2、获取单独年日月时分秒

    LocalDateTime now = LocalDateTime.now();
    System.out.println("年:"+now.getYear());
    System.out.println("月:"+now.getMonthValue());
    System.out.println("日:"+now.getDayOfMonth());
    System.out.println("时:"+now.getHour());
    System.out.println("分:"+now.getMinute());
    System.out.println("秒:"+now.getSecond());
    System.out.println("该日期是该年的第"+now.getDayOfYear()+"天");
    

    3、将特定的时间转成LocalDate、LocalTime、LocalDateTime  都有很多的重载的方法

    LocalDate of1 = LocalDate.of(2019, 1, 16);
    System.out.println(of1);
    LocalTime of2 = LocalTime.of(9, 25, 36);
    System.out.println(of2);
    LocalDateTime of3 = LocalDateTime.of(of1, of2);
    System.out.println(of3);
    LocalDateTime of4 = LocalDateTime.of(2019, 1, 14, 9, 26, 25);
    System.out.println(of4);
    

     4、判断时间是否相等(日期、时间、日期加时间)时间的比较精确到纳秒,可以先将时间进行格式化,然后比较,可以控制精度问题

    // 日期
    LocalDate date1 = LocalDate.of(2019, 1, 17);
    LocalDate date2 = LocalDate.now();
    if (date1.equals(date2)) {
        System.out.println("日期相等");
    } else {
        System.out.println("日期不相等");
    }
    // 时间
    LocalTime date1 = LocalTime.of(9, 46);
    LocalTime date2 = LocalTime.now();
    if (date1.equals(date2)) {
        System.out.println("时间相等");
    } else {
        System.out.println("时间不相等");
    }
    // 时间加日期
    LocalDateTime date1 = LocalDateTime.of(2019,1,17,9,47);
    LocalTime date2 = LocalTime.now();
    if (date1.equals(date2)) {
        System.out.println("时间加日期相等");
    } else {
        System.out.println("时间加日期不相等");
    }
    

     5、检查周几这种周期性的事件

    DayOfWeek of = DayOfWeek.THURSDAY;
    DayOfWeek from = DayOfWeek.from(LocalDate.now());
    if (from.equals(of)) {
        System.out.println("今天是周四");
    } else {
        System.out.println("今天不是周四");
    }
    DayOfWeek from1 = DayOfWeek.from(LocalDate.of(2019, 1, 10));
    if (from1.equals(of)) {
        System.out.println("该日期是周四");
    } else {
        System.out.println("该日期不是周四");
    }
    

     6、指定时间之后或之前XXX的时间

    LocalDateTime now = LocalDateTime.now();
    System.out.println("当前时间"+now);
    System.out.println("当前时间之前2天:"+now.minusDays(2));
    System.out.println("当前时间之后2天:"+now.plusDays(2));
    System.out.println("当前时间之前2周:"+now.minusWeeks(2));
    System.out.println("当前时间之后2周:"+now.plusWeeks(2));
    System.out.println("当前时间之前2月:"+now.minusMonths(2));
    System.out.println("当前时间之后2月:"+now.plusMonths(2));
    System.out.println("当前时间之前2年:"+now.minusYears(2));
    System.out.println("当前时间之后2年:"+now.plusYears(2));
    System.out.println("当前时间之前2小时:"+now.minusHours(2));
    System.out.println("当前时间之后2小时:"+now.plusHours(2));
    System.out.println("当前时间之前2分钟:"+now.minusMinutes(2));
    System.out.println("当前时间之后2分钟:"+now.plusMinutes(2));
    System.out.println("当前时间之前2秒:"+now.minusSeconds(2));
    System.out.println("当前时间之后2秒:"+now.plusSeconds(2));
    

     7、比较时间的先后

    LocalDateTime now = LocalDateTime.now();
    System.out.println("当前时间:"+now);
    LocalDateTime appointTime = LocalDateTime.of(2019, 1, 17, 9, 32, 12);
    System.out.println("指定时间:"+appointTime);
    System.out.println(now.isAfter(appointTime));
    System.out.println(now.isBefore(appointTime));
    

     8、格式化时间格式及按照一定格式解析

    LocalDateTime now = LocalDateTime.now();
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("HH:mm:ss");
    //格式化
    String format = now.format(formatter);
    String format2 = now.format(formatter2);
    String format3 = now.format(formatter3);
    System.out.println("格式化1:" + format);
    System.out.println("格式化2:" + format2);
    System.out.println("格式化3:" + format3);
    //解析
    LocalDateTime localDateTime = LocalDateTime.parse(format, formatter);
    LocalDate localDate = LocalDate.parse(format2, formatter2);
    LocalTime localTime = LocalTime.parse(format3, formatter3);
    System.out.println("解析1:" + localDateTime);
    System.out.println("解析2:" + localDate);
    System.out.println("解析3:" + localTime);
    

    9、根据指定的毫秒数获取LocalDateTime对象

    Long nowMilli = new Date().getTime();
    LocalDateTime localDateTime = Instant.ofEpochMilli(nowMilli).atZone(ZoneId.of("+8")).toLocalDateTime();
    System.out.println(localDateTime);
    

    注:+8 表示东八区,即常说的北京时间

    10、通过LocalDateTime对象获取毫秒数

    LocalDateTime now = LocalDateTime.now();
    long l = now.atZone(ZoneId.of("+8")).toInstant().toEpochMilli();
    System.out.println(l);
    

    注:+8 表示东八区,即常说的北京时间

    11、通过LocalDateTime对象获取秒数

    LocalDateTime now = LocalDateTime.now();
    long second = now.toEpochSecond(ZoneOffset.of("+8"));
    System.out.println(second);
    

     注:+8 表示东八区,即常说的北京时间

    12、判断指定日期是否是闰年(只LocalDate)

    LocalDate now = LocalDate.now();
    if (now.isLeapYear()) {
        System.out.println("now是闰年");
    } else {
        System.out.println("now不是闰年");
    }
    

    13、使用默认格式解析时间(LocalDateTime对象可解析的格式yyyy-MM-ddTHH:mm:ss)--不是空格了,是T

    LocalDateTime dateTime = LocalDateTime.parse("2019-01-14T12:04:12");
    int monthValue = dateTime.getMonthValue();
    int minute = dateTime.getMinute();
    System.out.println(monthValue+":"+minute);
    LocalTime time = LocalTime.parse("19:14:25");
    int hour = time.getHour();
    System.out.println(hour);
    LocalDate date = LocalDate.parse("2019-01-12");
    int year = date.getYear();
    System.out.println(year);
    

    14、总结

          jdk8中提供三个类(LocalDate,LocalTime,LocalDateTime),它们分别对年月日、时分秒和年月日时分秒进行单独的处理,使用时可以根据自己的实际情况进行选择,它们的API类似。

          Date与LocalDateTime、LocalDate、LocalTime互转参考  https://www.cnblogs.com/exmyth/p/6425878.html

    转载于:https://www.cnblogs.com/lu51211314/p/10280739.html

    展开全文
  • JDK8以前日期时间类型统一使用的是java.util.Date,JDK8以后在java.time包下定义了三种新的日期时间类型LocalDateTime、LocalDate、LocalTime。 最近项目中使用日期类型比较多,这里做下总结。 常用类 类型 ...

    JDK8推出了很多新特性,比如:


    这篇文章总结了一下stream()流式计算的使用例子。


    JDK8以前日期时间类型统一使用的是java.util.Date,JDK8以后在java.time包下定义了三种新的日期时间类型LocalDateTime、LocalDate、LocalTime。


    最近项目中使用日期类型比较多,这里做下总结。


    常用类

    类型 用途
    LocalDateTime 用于“年月日时分秒”的类型,比如:yyyy-MM-dd HH:mm:ss
    LocalDate 用于“年月日”的类型,比如yyyy-MM-dd
    LocalTime 用于“时分秒”的类型,比如:HH:mm:ss
    DateTimeFormatter 用于时间日期格式化
    ZoneOffset.of("+8") 表示东八区,即北京时间
    ChronoUnit 时间单位常量类,日期时间加减时使用

    常用示例

    获取当前日期时间、指定日期时间

    //获取当前日期时间
    LocalDateTime localDateTime = LocalDateTime.now();  // 2020-08-04 16:43:02
    
    //获取当前日期
    LocalDate localDate = LocalDate.now();    // 2020-08-04
    
    //获取当前时间
    LocalTime localTime = LocalTime.now();   // 16:43:02
    
    //获取指定日期时间
    LocalDateTime localDateTime2 = LocalDateTime.of(2020, 1, 1, 23, 59, 59);  // 2020-01-01 23:59:59
    
    //获取指定日期
    LocalDate localDate2 = LocalDate.of(2020, 1, 1); // 2020-01-01
    
    //获取指定时间
    LocalTime localTime2 = LocalTime.of(23, 59, 59);   // 23:59:59
    LocalTime localTime3 = LocalTime.of(23, 59);       // 23:59:00
    LocalTime localTime4 = LocalTime.parse("23:59:59"); // 23:59:00
    LocalTime localTime5 = LocalTime.parse("23:59:59", DateTimeFormatter.ofPattern("HH:mm:ss"));// 23:59:00
    

    LocalDateTime转Date、Date转LocalDateTime

    //获取当前日期时间
    LocalDateTime localDateTime = LocalDateTime.now();
    
    // LocalDateTime转Date
    Date date = Date.from(localDateTime.toInstant(ZoneOffset.of("+8")));
    
    // Date转LocalDateTime,方式一
    LocalDateTime localDateTime1 = LocalDateTime.ofInstant(date.toInstant(), ZoneOffset.of("+8"));
    
    // Date转LocalDateTime,方式二
    LocalDateTime localDateTime2 = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    

    运行结果:(相互转换后的日期时间是相等的)
    在这里插入图片描述


    Date转LocalDate

    Date date = new Date();
    // Date 转 LocalDate
    LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    

    LocalDateTime转String、String转LocalDateTime

    // 格式化
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    
    // LocalDateTime转String,方式一
    String dateTimeStr = LocalDateTime.now(ZoneOffset.of("+8")).format(dtf);
    System.out.println(dateTimeStr);  // 2020-08-03 20:42:55
    
    // LocalDateTime转String,方式二
    dateTimeStr = dtf.format(LocalDateTime.now());
    System.out.println(dateTimeStr);  // 2020-08-03 20:42:55
    
    // String转LocalDateTime
    LocalDateTime dateTime = LocalDateTime.parse(dateTimeStr, dtf);
    System.out.println(dateTimeStr);
    
    

    运行结果:

    2020-08-03 20:55:55
    2020-08-03 20:55:55
    2020-08-03 20:55:55


    LocalDate转String、String转LocalDate

    // 格式化
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    
    // String转LocalDate
    LocalDate localDate = LocalDate.parse("20200803", DateTimeFormatter.BASIC_ISO_DATE);
    LocalDate localDate2 = LocalDate.parse("2020-08-03", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    System.out.println(localDate);     // 2020-08-03
    System.out.println(localDate2);    // 2020-08-03
    
    // LocalDate转String
    String localDateStr = dtf.format(LocalDate.now())
    System.out.println(localDateStr);     // 2020-08-03
    
    // LocalDate转String
    LocalDate localDate = LocalDate.parse("2020-09-04");
    String yearMonth = DateTimeFormatter.ofPattern("yyyy-MM").format(localDate);
    String monthDay = DateTimeFormatter.ofPattern("MM-dd").format(localDate);
    System.out.println(yearMonth);  // 2020-09
    System.out.println(monthDay);   // 09-04
    

    运行结果:

    2020-08-03
    2020-08-03
    2020-08-03
    2020-09
    09-04


    LocalTime转String、String转LocalTime

    LocalTime localTime = LocalTime.of(8, 30, 0);
    // LocalTime转String
    String localTimeStr = DateTimeFormatter.ofPattern("HH:mm:ss").format(localTime);
    System.out.println(localTimeStr); //08:30:00
    
    // String转LocalTime
    LocalTime localTime2 = LocalTime.parse(localTimeStr, DateTimeFormatter.ofPattern("HH:mm:ss"));
    
    

    LocalDateTime转LocalDate、LocalTime

    LocalDateTime localDateTime = LocalDateTime.now();
    LocalDate localDate = localDateTime.toLocalDate();
    LocalTime localTime = localDateTime.toLocalTime();
    

    不规范的时间、日期格式的转换

    通常的时间格式是"yyyy-MM-dd HH:mm:ss",以上的转换方式LocalDateTime.parse()、LocalDate.parse()、LocalTime.parse()没问题。如2020-08-30 01:00:22,但如果是2020/08/30 00:00:01或者2020-8-30 1:00:22,这时用LocalDateTime.parse()、LocalDate.parse()、LocalTime.parse()就会报错。那怎么办呢?
    传统的SimpleDateFormat兼容性更强,解决方案:先SimpleDateFormat转Date,再Date转LocalDateTime。

    String dateStr = "2020/08/30 00:00:01";
    dateStr = dateStr.replaceAll("\\/", "-");
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = sdf.parse(dateStr);
    LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    

    总之,如果用jdk8新特性对不规范的时间、日期格式转换不好用时,就用传统的Date、SimpleDateFormat过渡一下。


    获取时间戳

    LocalDateTime获取时间戳,精确到毫秒数、精确到秒数。

    // 精确到毫秒数
     new Date().getTime();
     LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
    
     // 精确到秒数
     LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
     Instant.now().getEpochSecond();
    

    LocalDate获取时间戳,精确到毫秒数。

    LocalDate.now().atStartOfDay().toInstant(ZoneOffset.of("+8")).toEpochMilli();
    

    获取指定日期(LocalDate)当天的开始时间、结束时间

    比如LocalDate是2020-08-04,返回2020-08-04 00:00:00、2020-08-04 23:59:59

    LocalDate localDate = LocalDate.now();
    LocalDateTime startDateTime = LocalDateTime.of(localDate, LocalTime.MIN);
    LocalDateTime endDateTime = LocalDateTime.of(localDate, LocalTime.MAX);
    
    // 格式化
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    System.out.println(dtf.format(startDateTime));
    System.out.println(dtf.format(endDateTime));
    

    运行结果:

    2020-08-04 00:00:00
    2020-08-04 23:59:59


    最近7天的每一天的日期

    days是7,可以获取最近7天的每一天的日期;days是15,可以获取最近半个月的每一天的日期;days是30,可以获取最近一个月的每一天的日期。以此类推。

    public static void main(String[] args) {
       int days = 7;
       List<LocalDate> recentDates = getRecentDates(days);
       System.out.println(recentDates);
    }
    
    private static List<LocalDate> getRecentDates(int days) {
       List<LocalDate> recentDates = Lists.newArrayList();
       LocalDate localDate = LocalDate.now();
       recentDates.add(localDate);
       for (int i = 1; i < days; i++) {
           localDate = localDate.minus(1, ChronoUnit.DAYS);
           recentDates.add(localDate);
       }
       Collections.sort(recentDates); //倒序修改为顺序
       return recentDates;
    }
    

    今天是2020-09-04,输入结果是:

    [2020-08-29, 2020-08-30, 2020-08-31, 2020-09-01, 2020-09-02, 2020-09-03, 2020-09-04]


    两个日期相差天数

    // 两个日期相差天数,方式一
    LocalDate day1 = LocalDate.of(2020, 1, 1);   // 2020-01-01
    LocalDate day2 = LocalDate.of(2020, 2, 1);   // 2020-02-01
    long l = day2.toEpochDay() - day1.toEpochDay();   // 31
    
    // 两个日期相差天数,方式二
    LocalDate day1 = LocalDate.of(2020, 1, 1);        // 2020-01-01
    LocalDate day2 = day1.plus(10, ChronoUnit.DAYS);  // 加10天,2020-01-10
    Period period = Period.between(day1, day2);
    System.out.println("相差多少天:" + period.getDays() + ",相差几个月=" + period.getMonths() + ",相差几年=" + period.getYears());
    
    // 日期equals比较
    LocalDate day1 = LocalDate.of(2020, 1, 1);   // 2020-01-01
    LocalDate day2 = LocalDate.of(2020, 1, 1);   // 2020-02-01
    boolean flag = day1.equals(day2);  // true
    

    根据生日日期获取年龄

    根据生日当天为分界线来计算年龄。

    private static int getAgeByBirthday(LocalDate birthday) {
      int age = 0;
      try {
          Calendar now = Calendar.getInstance();
          now.setTime(new Date());// 当前时间
          now.setTimeInMillis(LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());
    
          Calendar birth = Calendar.getInstance();
          birth.setTimeInMillis(birthday.atStartOfDay().toInstant(ZoneOffset.of("+8")).toEpochMilli());
          if (birth.after(now)) {// 如果传入的时间,在当前时间的后面,返回0岁
              age = 0;
          } else {
              age = now.get(Calendar.YEAR) - birth.get(Calendar.YEAR) - 1;
              if (now.get(Calendar.MONTH) >= birth.get(Calendar.MONTH)) {
                  if (now.get(Calendar.DAY_OF_MONTH) >= birth.get(Calendar.DAY_OF_MONTH)) {
                      age += 1;
                  }
              }
          }
          return age;
      } catch (Exception e) {
          return 0;
      }
    }
    

    时间加减、相差秒数、时间比较

    LocalTime time1 = LocalTime.of(9, 0, 0);   // 09:00:00
    LocalTime time2 = LocalTime.of(18, 0, 0);   // 18:00:00
    
    LocalTime startTime = time1.plusMinutes(30);  // 加30分钟,09:30:00
    LocalTime endTime = time2.minusMinutes(30);   // 减30分钟,17:30:00
    Duration flag1 = Duration.between(startTime, endTime);
    Duration flag2 = Duration.between(endTime, startTime);
    System.out.println(flag1.getSeconds());    //获取相差秒数,28800
    System.out.println(flag2.getSeconds());    //获取相差秒数,-28800
    

    日期加减操作

    LocalDate today = LocalDate.now();
    System.out.println("today=" + today);
    
    // 一个星期后
    LocalDate nextweek = today.plus(1, ChronoUnit.WEEKS);
    // LocalDate nextweek = today.plus(7,ChronoUnit.DAYS);
    System.out.println("nextweek=" + nextweek);
    
    // 1月后日期
    LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);
    System.out.println("nextMonth=" + nextMonth);
    
    // 一年后日期
    LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
    System.out.println("nextYear=" + nextYear);
    
    // 10年后日期
    LocalDate nextTenyear = today.plus(1, ChronoUnit.DECADES);
    System.out.println("Date after ten year:" + nextTenyear);
    

    运行结果:

    today=2020-08-04
    nextweek=2020-08-11
    nextMonth=2020-09-04
    nextYear=2021-08-04
    Date after ten year:2030-08-04


    平年、闰年

    LocalDate today = LocalDate.now();
    System.out.print(today + "\t");
    if (today.isLeapYear()) {
        System.out.println("闰年");
    } else {
        System.out.println("平年");
    }
    

    运行结果:

    2020-08-04 闰年


    @RequestBody+@JsonFormat接收日期时间格式

    在Controller类里,方法使用“@RequestParam LocalDate date,@RequestParam LocalDateTime dateTime” 接收日期时间参数可以使用配置类自动转换,但配置类对@RequestBody 对象包含的日期时间参数不起作用。我的解决办法是:

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime attendanceTime;
    

    在属性上面加@JsonFormat注解,指定日期时间格式化。


    我的 配置类:

    /**
     * 日期时间类型转换器配置
     *
     * @Author wanglingqiang
     * @Date 2020/7/9 下午12:28
     **/
    @Configuration
    public class DateConfig {
    
        /**
         * LocalDate转换器,用于转换RequestParam和PathVariable参数
         */
        @Bean
        public Converter<String, LocalDate> localDateConverter() {
            return new Converter<String, LocalDate>() {
                @Override
                public LocalDate convert(@NotNull String source) {
                    return LocalDate.parse(source, DateTimeFormatter.ofPattern(Constants.DEFAULT_DATE_FORMAT));
                }
            };
        }
    
        /**
         * LocalDateTime转换器,用于转换RequestParam和PathVariable参数
         */
        @Bean
        public Converter<String, LocalDateTime> localDateTimeConverter() {
            return new Converter<String, LocalDateTime>() {
                @Override
                public LocalDateTime convert(@NotNull String source) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(Constants.DEFAULT_DATE_TIME_FORMAT));
                }
            };
        }
    
        /**
         * LocalTime转换器,用于转换RequestParam和PathVariable参数
         */
        @Bean
        public Converter<String, LocalTime> localTimeConverter() {
            return new Converter<String, LocalTime>() {
                @Override
                public LocalTime convert(@NotNull String source) {
                    return LocalTime.parse(source, DateTimeFormatter.ofPattern(Constants.DEFAULT_TIME_FORMAT));
                }
            };
        }
    
        /**
         * Date转换器,用于转换RequestParam和PathVariable参数
         */
        @Bean
        public Converter<String, Date> dateConverter() {
            return new Converter<String, Date>() {
                @Override
                public Date convert(@NotNull String source) {
                    SimpleDateFormat format = new SimpleDateFormat(Constants.DEFAULT_DATE_TIME_FORMAT);
                    try {
                        return format.parse(source);
                    } catch (ParseException e) {
                        throw new RuntimeException(e);
                    }
                }
            };
        }
    
        /**
         * Json序列化和反序列化转换器,用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
         */
        @Bean
        public ObjectMapper objectMapper() {
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
            objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
    
            //LocalDateTime系列序列化和反序列化模块,继承自jsr310,我们在这里修改了日期格式
            JavaTimeModule javaTimeModule = new JavaTimeModule();
            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(Constants.DEFAULT_DATE_TIME_FORMAT)));
            javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(Constants.DEFAULT_DATE_FORMAT)));
            javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(Constants.DEFAULT_TIME_FORMAT)));
            javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(Constants.DEFAULT_DATE_TIME_FORMAT)));
            javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(Constants.DEFAULT_DATE_FORMAT)));
            javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(Constants.DEFAULT_TIME_FORMAT)));
    
    
            //Date序列化和反序列化
            javaTimeModule.addSerializer(Date.class, new JsonSerializer<Date>() {
                @Override
                public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
                    SimpleDateFormat formatter = new SimpleDateFormat(Constants.DEFAULT_DATE_TIME_FORMAT);
                    String formattedDate = formatter.format(date);
                    jsonGenerator.writeString(formattedDate);
                }
            });
            javaTimeModule.addDeserializer(Date.class, new JsonDeserializer<Date>() {
                @Override
                public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
                    SimpleDateFormat format = new SimpleDateFormat(Constants.DEFAULT_DATE_TIME_FORMAT);
                    String date = jsonParser.getText();
                    try {
                        return format.parse(date);
                    } catch (ParseException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
    
            objectMapper.registerModule(javaTimeModule);
            return objectMapper;
        }
    }
    

    实际使用时,发现对@RequestBody 对象包含的日期时间参数不起作用,有知道的请留言指教。


    获取指定日期(LocalDate)当月的第一天

    方法一:

     /**
      * 获取当月的第一天
      *
      * @param
      * @return String
      **/
     private String getFirstDayOfMonth() {
         LocalDate today = LocalDate.now();  // 也可以指定不同的日期,获取指定月的第一天
         return localDate.with(TemporalAdjusters.firstDayOfMonth());
     }
    

    方法二:

     /**
      * 获取当月的第一天
      *
      * @param
      * @return String
      **/
     private String getFirstDayOfMonth() {
         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
         Calendar cale = Calendar.getInstance();
         cale.add(Calendar.MONTH, 0);
         cale.set(Calendar.DAY_OF_MONTH, 1);
         return format.format(cale.getTime());
     }
    

    运行输出:

    2020-08-01


    获取指定日期(LocalDate)当月的最后一天

    方法一:

     /**
      * 获取当月的最后一天
      *
      * @param
      * @return String
      **/
     private String getLastDayOfMonth() {
         LocalDate today = LocalDate.now();// 也可以指定不同的日期,获取指定月的最后一天
         return localDate.with(TemporalAdjusters.lastDayOfMonth());
     }
    

    方法二:

     /**
      * 获取当月的最后一天
      *
      * @param
      * @return String
      **/
     private String getLastDayOfMonth() {
         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
         Calendar cale = Calendar.getInstance();
         cale.add(Calendar.MONTH, 1);
         cale.set(Calendar.DAY_OF_MONTH, 0);
         return format.format(cale.getTime());
     }
    

    运行输出:

    2020-08-31


    获取指定月份的总天数

    比如:2月有29天、6月有30天、7月有31天。
    方式一:

    int days1 = LocalDate.of(2020, 2, 27).lengthOfMonth();
    int days2 = LocalDate.of(2020, 6, 27).lengthOfMonth();
    int days3 = LocalDate.of(2020, 7, 27).lengthOfMonth();
    System.out.println(days1);  //2020年2月,输出29天
    System.out.println(days2);  //2020年6月,输出30天
    System.out.println(days3);  //2020年7月,输出31天
    

    运行结果:

    29
    30
    31

    方式二:

    /**
     * 获取指定月份的总天数
     *
     * @param dateStr 格式:yyyy-MM
     * @return Integer
     **/
    private Integer getDaysOfMonth(String dateStr) {
        try {
            Date date = new SimpleDateFormat("yyyy-MM").parse(dateStr);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        } catch (ParseException e) {
            log.error("", e);
            return null;
        }
    }
    

    传参:2020-08,运行结果:

    31


    获取指定月份的每一天

    输入:2020-07
    输出:2020-07-01、2020-07-02、2020-07-03……2020-07-31;

    public static void main(String[] args) throws ParseException {
    
            //输入:2020-07,输出:2020-07-01、2020-07-02、2020-07-03……2020-07-31;
            String dateStr = "2020-07";
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
            Date date = sdf.parse(dateStr);
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            int month = cal.get(Calendar.MONTH);
    
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
            while (month == cal.get(Calendar.MONTH)) {
                System.out.println(sdf1.format(cal.getTime()));
                cal.add(Calendar.DAY_OF_MONTH, 1);
            }
    
        }
    

    运行输出:

    2020-07-01
    2020-07-02
    2020-07-03
    2020-07-04

    // …中间省略

    2020-07-29
    2020-07-30
    2020-07-31


    展开全文
  • package com.mybatis.springbootmybatis.jdk8.localdate; import java.time.*; import java.time.format.DateTimeFormatter; import java.time.temporal.TemporalAdjusters; public class Test { public stat...
    package com.mybatis.springbootmybatis.jdk8.localdate;
    
    import java.time.*;
    import java.time.format.DateTimeFormatter;
    import java.time.temporal.TemporalAdjusters;
    
    public class Test {
        public static void main(String[] args) {
            // LocalDate 获取日期、LocalTime获取时间、LocalDateTime获取日期+时间
            //订制日期格式
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            //如果需要使用官方制定的时期格式直接DateTimeFormatter点就可以拿到
            //DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_DATE_TIME;
    
            LocalDateTime localDateTime = LocalDateTime.now();
            String format = localDateTime.format(dateTimeFormatter);
            System.out.println(format);
    
            System.out.println("========================");
    
            // 获取一天的最大最小时间
            LocalDateTime of = localDateTime.of(LocalDate.now(), LocalTime.MIN);
            of = localDateTime.of(LocalDate.now(), LocalTime.MAX);
            System.out.println(of.format(dateTimeFormatter));
    
            System.out.println("========================");
    
            LocalDateTime localDateTime1 = localDateTime.withHour(0).withMinute(0).withSecond(0);
            localDateTime1 = localDateTime.withHour(23).withMinute(59).withSecond(59);
            System.out.println(localDateTime1.format(dateTimeFormatter));
    
            System.out.println("========================");
    
            // 当前时间减去2h
            System.out.println(localDateTime1.minusHours(2).format(dateTimeFormatter));
    
            System.out.println("========================");
    
    
            // TemporalAdjuster : 时间校正器。有时我们可能需要获,取例如:将日期调整到“下个周日”等操作。
            // TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
            // 获取周日时间
            System.out.println(LocalDateTime.now().with(TemporalAdjusters.next(DayOfWeek.SUNDAY)).format(dateTimeFormatter));
    
            System.out.println("========================");
    
            // 判断当前时间是哪一天后,进行加减操作
            // DayOfWeek获取周中天
            LocalDateTime localDateTime2 = LocalDateTime.now();
            System.out.println(
                    localDateTime2.with((x) -> {
                        LocalDateTime time = (LocalDateTime) x;
                        if (time.getDayOfWeek().equals(DayOfWeek.SUNDAY)) {
                            return time.plusDays(1);
                        }
                        if (time.getDayOfWeek().equals(DayOfWeek.SATURDAY)) {
                            return time.plusDays(2);
                        }
                        return time;
                    }).format(dateTimeFormatter)
            );
    
            System.out.println("========================");
    
            // Duration : 用于计算两个“时间”间隔
            // Period : 用于计算两个“日期”间隔
            // Instant : 时间戳。 (使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值)
            // ZonedDate、ZonedTime、ZonedDateTime : 带时区的时间或日期
            Instant now = Instant.now();
            LocalTime localTime1 = LocalTime.now();
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            Instant now2 = Instant.now();
            System.out.println(Duration.between(now,now2).getSeconds());
            LocalTime localTime2 = LocalTime.now();
            System.out.println(Duration.between(localTime1,localTime2).getSeconds());
        }
    }
    

     

    展开全文
  • JDK8提供的java.time.LocalDateTime或者java.time.LocalDate,那么随着变化的还有前端JSP页面怎么格式化日期时间?使用java.util.Date时,前端JSP页面格式化时间是由官方JSTL提供的L格式化标签,只要在JSP页面引入...

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

jdk8日期时间