jdk8常用时间api汇总

卖柴火的小伙子

已于 2022-10-24 22:45:03 修改

阅读量371

点赞数

文章标签： java time date 1024程序员节

于 2021-10-16 10:10:15 首次发布

本文链接：https://blog.csdn.net/weixin_43401380/article/details/120791436

版权

    主要记录一下日期类业务处理,能替代calender、simpleDateFormat等进行日期转化的api.apil来源包:java.time.常用的时间类对象主要有四个,区别是表示的时间格式不同:
    YearMonth: 年月时间
    MonthDay : 月日时间
    LocalDate: 年月日时间
    LocalDateTime: 年月日时分秒毫秒
常用方法：
    时间类相互转化以及指定类型时间截取
     LocalDate与字符串时间相互转化
     时间比较大小(大于小于大于等于): isAfter与isBefore与compare与equals
    获取指定年月日时间
     增加指定时间:min与plus
    计算两个日期之间的时间间隔:between(最好使用until,对于间隔超过一年的获取天数会不正确
     根据指定时间单位计算两个日期之间的时间差:until
    根据给定时间以及指定时间间隔获取指定时间信息:with与TemporalAdjusters
         TemporalAdjusters.java中next与nextOrSame源码对比
         TemporalAdjusters.java中previous与previousOrSame源码对比
     根据周几转化为对应日期
     根据日期获取对应的周几
     计算两个日期之间的时间差并转化为时分秒
以上时间对象中方法通用,均以LocalDate为例进行常用方法说明!后期有新的时间应用场景会持续补充。

时间类相互转化以及指定类型时间截取

private static void method() {
    // 获取指定格式的时间类型(LocalDateTime类型只保留年月日时分)
    LocalDateTime localDateTime = LocalDateTime.parse("2021-10-21 17:27", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
    System.out.println(localDateTime);   // 2021-10-21T17:27
    
    // LocalTime不保留秒与纳秒(只保留时分):withSecond(0).withNano(0)
    LocalTime now = LocalTime.now();
    System.out.println(now.withSecond(0).withNano(0));  // 19:43
    
    // LocalDateTime转化为LocalTime
    LocalTime localTime = localDateTime.toLocalTime();
    System.out.println(localTime);  // 17:27
    // LocalDateTime转化为LocalDate
    LocalDate localDate = localDateTime.toLocalDate();
    System.out.println(localDate);  // 2021-10-21

LocalDate与字符串时间相互转化

private static void method1() {
    // 当前日期:年月日--LocalDate
    LocalDate nowLocalDate = LocalDate.now();
    System.out.println(nowLocalDate);  // 2021-10-16

    // 获取指定日期的LocalDate
    LocalDate localDate = LocalDate.of(2021, 9, 19);
    System.out.println("自定义LocalDate"+localDate);  // 2021-09-19

    // LocalDate转化为字符串形式
    String dateStr = nowLocalDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    System.out.println(dateStr);  // 2021-10-16

    // 字符串转化为LocalDate
    LocalDate parseLocalDate = LocalDate.parse("2021-10-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    System.out.println(parseLocalDate);  // 2021-10-15
}

时间比较大小(大于小于大于等于): isAfter与isBefore与compareTo

private static void method2() {
 LocalDate localDate1 = LocalDate.parse("2021-11-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        LocalDate localDate2 = LocalDate.parse("2021-12-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        // 时间比较大小,最常见的字符串时间比较大小,可以转化为LocalDate,
        // A.isBefore(B) A小于B返回true;A.isAfter(B) A大于B返回true
        // 比较时间是否相等 equals
        boolean before = localDate1.isBefore(localDate2);
        System.out.println(before);  // true

        boolean after = localDate2.isAfter(localDate1);
        System.out.println(after);   // true
	

        LocalDate localDate3 = LocalDate.parse("2021-12-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        LocalDate localDate4 = LocalDate.parse("2021-12-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        boolean equals = localDate3.equals(localDate4);
        System.out.println(equals);  // true
		
		//补充:判断大于等于,两种思路,暂不提供案例说明
		// 时间类型A.compare(B时间类型),如果相等返回0;如果A小于B则返回1,反之为-1;另一种就是利用(A.isAfter(B) || A.equals(B))

		// 时间对象中不获取最后的纳秒withNano
		 LocalDateTime now = LocalDateTime.now();
        System.out.println(now);   //2021-10-20T22:49:42.039
        System.out.println(now.withNano(0)// 2021-10-20T22:49:42
    }

获取指定年月日时间

private static void method3() {
 LocalDate localDate1 = LocalDate.parse("2021-11-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    // 获取指定哪一天
    int dayOfMonth = localDate1.getDayOfMonth();
    System.out.println("按月计算的日期:"+dayOfMonth);
    DayOfWeek dayOfWeek = localDate1.getDayOfWeek();
    int weekDay = dayOfWeek.getValue();
    System.out.println("按周计算的日期:"+weekDay);
    int dayOfYear = localDate1.getDayOfYear();
    System.out.println("按年计算的日期:"+dayOfYear);
    // 获取月份
    int monthValue = localDate1.getMonthValue();
    System.out.println("获取月份:"+monthValue);
    // 获取年份
    int year = localDate1.getYear();
    System.out.println("获取年份:"+year);
}

增加指定时间:min与plus

private static void method4() {
 LocalDate localDate1 = LocalDate.parse("2021-11-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    // 指定时间加1天
    LocalDate plusDayLocalDate = localDate1.plus(1, ChronoUnit.DAYS);
    System.out.println("指定时间加1天:"+plusDayLocalDate);  // 2021-11-16

    // 指定时间减1天
    LocalDate minusDayLocalDate = localDate1.minus(1, ChronoUnit.DAYS);
    System.out.println("指定时间减1天:"+minusDayLocalDate);  // 2021-11-14

    // 指定时间加一周
    LocalDate plusWeekLocalDate = localDate1.plus(1, ChronoUnit.WEEKS);
    System.out.println("指定时间加一周:"+plusWeekLocalDate);  // 2021-11-22

    // 指定时间减一周
    LocalDate minusWeekLocalDate = localDate1.minus(1, ChronoUnit.WEEKS);
    System.out.println("指定时间减一周:"+minusWeekLocalDate);  // 2021-11-08

    // 指定时间加1个月
    LocalDate plusMonthLocalDate = localDate1.plus(1, ChronoUnit.MONTHS);
    System.out.println("指定时间加1个月:"+plusMonthLocalDate);  // 2021-12-15

    // 指定时间减1个月
    LocalDate minusMonthLocalDate = localDate1.minus(1, ChronoUnit.MONTHS);
    System.out.println("指定时间减1个月:"+minusMonthLocalDate);  // 2021-10-15


    // 指定时间加1年
    LocalDate plusYearLocalDate = localDate1.plus(1, ChronoUnit.YEARS);
    System.out.println("指定时间加1年:"+plusYearLocalDate);  // 2022-11-15

    // 指定时间减1年
    LocalDate minusYearLocalDate = localDate1.minus(1, ChronoUnit.YEARS);
    System.out.println("指定时间减1年:"+minusYearLocalDate);  // 2020-11-15
}

计算两个日期之间的时间间隔:between(最好使用until,对于间隔超过一年的获取天数可能为0)

private static void method5() {
 LocalDate localDate1 = LocalDate.parse("2021-11-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        LocalDate localDate2 = LocalDate.parse("2021-12-15", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    Period period = Period.between(localDate1, localDate2);
    int days = period.getDays();
    System.out.println("两个日期之间相差的天数:"+days);  // 0

    int months = period.getMonths();
    System.out.println("两个日期之间相差的月数:"+months);  // 1

    int years = period.getYears();
    System.out.println("两个日期之间相差的年数:"+years);   // 0
}

根据指定时间单位计算两个日期之间的时间差:until

private static void method7() {
		// 根据指定单位,计算两个日期之间的相差的时间
		// 注意:日期小的在前面,否则会出现负数的天数
		LocalDate nowLocalDate = LocalDate.now();
		LocalDate localDate = LocalDate.of(2021, 11, 10);
        long until = nowLocalDate.until(localDate, ChronoUnit.DAYS);
        System.out.println(until );  // 计算2021-11-14与2021-11-10之间相差的天数:-4天
}

根据给定时间以及指定时间间隔获取指定时间信息

private static void method8() {
		 LocalDate nowLocalDate = LocalDate.now();
        System.out.println(nowLocalDate);  // 2021-11-14

        /*with 用户根据当前时间以及指定时间间隔获取指定时间信息,支持两种参数:
        *   param:TemporalField field, long newValue,即指定时间单位以及时间数
        *   param:TemporalAdjuster adjuster,即指定时间格式*/

        // ChronoField.DAY_OF_YEAR表示以年为单位的天数
        LocalDate withLocalDate = nowLocalDate.with(ChronoField.DAY_OF_YEAR, 1);
        System.out.println(withLocalDate);  // 2021-11-14获取指定1天的时间:2021-01-01
        LocalDate withLocalDate2 = nowLocalDate.with(ChronoField.DAY_OF_YEAR, 30);
        System.out.println(withLocalDate2); // 2021-11-14获取指定30天的时间:2021-01-30

        // ChronoField.DAY_OF_MONTH表示以月为单位的天数
        LocalDate withLocalDate3 = nowLocalDate.with(ChronoField.DAY_OF_MONTH, 1);
        System.out.println(withLocalDate3); // 2021-11-14获取指定1天的时间:2021-11-01
        LocalDate withLocalDate4 = nowLocalDate.with(ChronoField.DAY_OF_MONTH, 20);
        System.out.println(withLocalDate4); // 2021-11-14获取指定20天的时间:2021-11-20

        // TemporalAdjusters.firstDayOfNextMonth():指定日期的下个月的第一天;同类型还支持一年(月/日)中的第一天或是最后一天、下一年(月/日)的第一天
        LocalDate withLocalDate5 = nowLocalDate.with(TemporalAdjusters.firstDayOfNextMonth());
        System.out.println(withLocalDate5); // 2021-11-14获取指定时间:2021-12-01

        // 获取第几个周的周几的对应的日期
        LocalDate withLocalDate6 = nowLocalDate.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.MONDAY));
        System.out.println(withLocalDate6); // 2021-11-14获取第二个周的周一对应日期:2021-12-01

        System.out.println("=====================================================================");
        // 根据指定日期获取下周几对应的日期,注意此处的下周非自然周,是以指定时间开始往后推7天的周数,下面给出示例可结合案例体会
        LocalDate localDate = LocalDate.of(2021, 11, 10);
        LocalDate withLocalDate7 = localDate.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
        System.out.println(withLocalDate7); // 2021-11-10下周一对应日期:2021-11-15
        LocalDate withLocalDate71 = localDate.with(TemporalAdjusters.next(DayOfWeek.TUESDAY));
        System.out.println(withLocalDate71); // 2021-11-10下周二对应日期:2021-11-16
        LocalDate withLocalDate72 = localDate.with(TemporalAdjusters.next(DayOfWeek.WEDNESDAY));
        System.out.println(withLocalDate72); // 2021-11-10下周三对应日期:2021-11-17
        LocalDate withLocalDate73 = localDate.with(TemporalAdjusters.next(DayOfWeek.THURSDAY));
        System.out.println(withLocalDate73); // 2021-11-10下周四对应日期:2021-11-11
        LocalDate withLocalDate74 = localDate.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));
        System.out.println(withLocalDate74); // 2021-11-10下周五对应日期:2021-11-12
        System.out.println("=====================================================================");

        // 根据指定日期获取下周几对应的日期(对于周几数与当前指定时间对应的周几数相同时返回当前指定时间),注意此处的下周非自然周,是以指定时间开始往后推7天的周数,
        LocalDate withLocalDate8 = localDate.with(TemporalAdjusters.nextOrSame(DayOfWeek.WEDNESDAY));
        System.out.println(withLocalDate8); // 2021-11-10下周三对应日期:2021-11-10,2021-11-10实际对应的是周三,使用此方法计算出周三对应的日期还是2021-11-10而不是2021-11-17,其余周几数计算日期同TemporalAdjusters.next(),详见源码
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
        // 根据指定日期获取上周几对应的日期,注意此处的上周指当前指定日期往前推7天的周数,非自然周,表示范围同TemporalAdjusters.next()
        LocalDate withLocalDate9 = localDate.with(TemporalAdjusters.previous(DayOfWeek.SUNDAY));
        System.out.println(withLocalDate9); // 2021-11-10上周天对应日期:2021-11-07
        LocalDate withLocalDate91 = localDate.with(TemporalAdjusters.previous(DayOfWeek.TUESDAY));
        System.out.println(withLocalDate91); // 2021-11-10上周二对应日期:2021-11-09

        // 根据指定日期获取上周几对应的日期(对于周几数与当前指定时间对应的周几数相同时返回当前指定时间),注意此处的上周非自然周,是以指定时间开始往前推7天的周数,
        LocalDate withLocalDate10 = localDate.with(TemporalAdjusters.previousOrSame(DayOfWeek.WEDNESDAY));
        System.out.println(withLocalDate10); // 2021-11-10上周天对应日期:2021-11-10,2021-11-10实际对应的是周三,使用此方法计算出周三对应的日期还是2021-11-10不是2021-11-03,其余周几数计算日期同TemporalAdjusters.previous(),详见源码
}

TemporalAdjusters.java中next与nextOrSame源码对比

public static TemporalAdjuster next(DayOfWeek dayOfWeek) {
    int dowValue = dayOfWeek.getValue();
    return (temporal) -> {
        int calDow = temporal.get(DAY_OF_WEEK);
        int daysDiff = calDow - dowValue;
        return temporal.plus(daysDiff >= 0 ? 7 - daysDiff : -daysDiff, DAYS);
    };
}
    public static TemporalAdjuster nextOrSame(DayOfWeek dayOfWeek) {
        int dowValue = dayOfWeek.getValue();
        return (temporal) -> {
            int calDow = temporal.get(DAY_OF_WEEK);
            // 注意此处传递的周几数如果等于当前指定时间对应的周几,则返回当前指定时间
            if (calDow == dowValue) {
                return temporal;
            }
            int daysDiff = calDow - dowValue;
            return temporal.plus(daysDiff >= 0 ? 7 - daysDiff : -daysDiff, DAYS);
        };
    }

TemporalAdjusters.java中previous与previousOrSame源码对比

  public static TemporalAdjuster previous(DayOfWeek dayOfWeek) {
    int dowValue = dayOfWeek.getValue();
    return (temporal) -> {
        int calDow = temporal.get(DAY_OF_WEEK);
        int daysDiff = dowValue - calDow;
        return temporal.minus(daysDiff >= 0 ? 7 - daysDiff : -daysDiff, DAYS);
    };
}

public static TemporalAdjuster previousOrSame(DayOfWeek dayOfWeek) {
    int dowValue = dayOfWeek.getValue();
    return (temporal) -> {
        int calDow = temporal.get(DAY_OF_WEEK);
        // 注意此处传递的周几数如果等于当前指定时间对应的周几,则返回当前指定时间
        if (calDow == dowValue) {
            return temporal;
        }
        int daysDiff = dowValue - calDow;
        return temporal.minus(daysDiff >= 0 ? 7 - daysDiff : -daysDiff, DAYS);
    };
}

当前周根据周几转化为对应日期

 	LocalDate now = LocalDate.now();
    WeekFields weekFields= WeekFields.ISO;
    // 第二个参数表示是周几,注意数据类型为long
    LocalDate withLocalDate = now.with(weekFields.dayOfWeek(),7l);
    System.out.println(withLocalDate);  // 2022-01-16

根据日期获取对应的周几

   LocalDate.now().getDayOfWeek().getValue()

计算两个日期之间的时间差并转化为时分秒

   public static void main(String[] args) {

        // 计算两个时间之间的毫秒差值
        long until = LocalDateTime.now().until(LocalDateTime.now().minusSeconds(20), ChronoUnit.SECONDS);
        System.out.println(until);  // 20
        
        int totalSecond=3602;
        // 日期相差秒数转化为小时
        int hour=totalSecond/3600;
        // 日期相差秒数取余为整数小时之外的相差秒数
        int restSecond=totalSecond%3600;
        // 日期相差秒数取商转化为分钟数
        int minute=restSecond/60;
        // 剩余秒数
        int second=restSecond%60;

        System.out.println(hour); // 1
        System.out.println(minute); // 0
        System.out.println(second); // 2
    }