投稿
  1. 极客之音首页
  2. 技术随笔

JDK8日期API解析

飞熊 • • 技术随笔 • 阅读 224

有时候，不是因为你没有能力，也不是因为你缺少勇气，只是因为你付出的努力还太少，所以，成功便不会走向你。而你所需要做的，就是坚定你的梦想，你的目标，你的未来，然后以不达目的誓不罢休的那股劲，去付出你的努力，成功就会慢慢向你靠近。

导读：本篇文章讲解 JDK8日期API解析，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

文章目录

1、java.time包下基本类使用

1.1、now方法在日期时间类的使用

Date-Time API中的所有类均生成不可变实例,它们是线程安全的,并且这些类
不提供公共构造函数,也就是说没办法通过new的方式直接创建,需要采用工厂方法加以实例化

public class Java8TimeClassMethodDemo1 {
    public static void main(String[] args) {
        //使用now方法创建Instant的实例对象.
        Instant instantNow = Instant.now();
        // 使用now方法创建LocalDate的实例对象.
        LocalDate localDateNow = LocalDate.now();
        // 使用now方法创建LocalTime的实例对象.
        LocalTime localTimeNow = LocalTime.now();
        // 使用now方法创建LocalDateTime的实例对象.
        LocalDateTime localDateTimeNow = LocalDateTime.now();
        // 使用now方法创建ZonedDateTime的实例对象.
        ZonedDateTime zonedDateTimeNow = ZonedDateTime.now();
        // 将实例对象打印到控制台.
        System.out.println("Instant:"+instantNow);
        System.out.println("LocalDate:"+localDateNow);
        System.out.println("LocalTime:"+localTimeNow);
        System.out.println("LocalDateTime:"+localDateTimeNow);
        System.out.println("ZonedDateTime:"+zonedDateTimeNow);
    }
}

输出结果：

Instant:2022-04-01T12:35:04.780Z
LocalDate:2022-04-01
LocalTime:20:35:04.884
LocalDateTime:2022-04-01T20:35:04.885
ZonedDateTime:2022-04-01T20:35:04.885+08:00[Asia/Shanghai]

各个类封装时间所表示的特点

  1. Instant封装的时间为祖鲁时间并非当前时间.
    祖鲁时间也是格林尼治时间,也就是国际标准时间.
  2. LocalDate封装的只有年月日,没有时分秒,格式为yyyy-MM-dd.
  3. LocalTime封装的只有时分秒,没有年月日,格式为hh:mm:ss.sss,最后的sss是纳秒.
  4. LocalDateTime将LocalDate和LocalTime合二为一,在年月日与时分秒中间使用T作为分隔.
  5. ZonedDateTime中封装了年月日时分秒,以及UTC(祖鲁时间)偏移量,并且还有一个地区名.
    +8:00代表中国是东八区,时间比国际标准时间快八小时.

1.2、年月日类

public class Java8TimeClassMethodDemo2 {
    public static void main(String[] args) {
        //初始化Year的实例化对象.
        Year year = Year.now();
        //初始化YearMonth的实例化对象
        YearMonth month = YearMonth.now();
        //初始化MonthDay的实例化对象.
        MonthDay day = MonthDay.now();

        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
    }
}

输出结果：

2022
2022-04
--04-01

1.3、of方法自定义日期时间类的应用

public class Java8TimeClassMethodDemo3 {
    public static void main(String[] args) {
        //初始化2018年8月8日的LocalDate对象.
        LocalDate date = LocalDate.of(2018, 8, 8);
        System.out.println("LocalDate:" + date);
        /*
        初始化晚上7点0分0秒的LocalTime对象.
        LocalTime.of方法的重载形式有以下几种,可以根据实际情况自行使用.
        LocalTime of(int hour, int minute) -> 根据小时/分钟生成对象.
        LocalTime of(int hour, int minute, int second) -> 根据小时/分钟/秒生成
        对象.
        LocalTime of(int hour, int minute, int second, int nanoOfSecond) ->
        根据小时/分钟/毫秒/纳秒生成对象.
        注意:如果秒和纳秒为0的话,那么默认不会封装这些数据,只显示小时和分钟.
        */
        LocalTime time = LocalTime.of(19, 0, 0, 0);
        System.out.println("LocalTime:" + time);
        /*为LocalDateTime添加时区信息(拓展)
        在学习ZonedDateTime的时候,发现了这个对象里面封装的不仅有时间日期,并且还有偏移量+时
        区,那么时区如何在Java中获取呢,通过提供的一个类ZoneId的getAvailableZoneIds方法可以
        获取到一个Set集合,集合中封装了600个时区.
        初始化2018年8月8日下午7点0分的LocalDateTime对象.
        LocalDateTime.of方法的重载形式有以下几种,可以根据事情自行使用.
        LocalDateTime of(int year, int month, int dayOfMonth, int hour, int
        minute, int second, int nanoOfSecond) -> 根据年/月/日/时/分/秒生成对象.
        LocalDateTime of(int year, int month, int dayOfMonth, int hour, int
        minute) -> 根据年/月/日/时/分生成对象.
        注意:LocalDateTime of(LocalDate date, LocalTime time)方法可以将一个
        LocalDate对象和一个LocalTime对象合并封装为一个LocalDateTime对象.
        */
        LocalDateTime.of(2018, 8, 8, 19, 0, 0, 0);
        LocalDateTime localDateTime = LocalDateTime.of(date, time);
        System.out.println("LocalDateTime:" + localDateTime);
    }
}

输出结果：

LocalDate:2018-08-08
LocalTime:19:00
LocalDateTime:2018-08-08T19:00

1.4、LocalDateTime添加时区信息

public static void main(String[] args) {
    //1.封装LocalDateTime对象,参数自定义 -> 2018年11月11日 8点54分38秒 
    LocalDateTime time = LocalDateTime.of(2018, 11, 11, 8, 54, 38);
    //2.封装完成后的time对象只是封装的是一个时间,并没有时区相关的数据,所以添加时区到 对象中,使用atZone方法.
    ZonedDateTime zonedDateTime = time.atZone(ZoneId.of("Asia/Shanghai"));
    System.out.println("Asia/Shanghai的时间是:" + zonedDateTime);
    //3.更改时区查看其它时区的当前时间,通过withZoneSameInstant方法即可更改. 
    ZonedDateTime otherZonedTime =
            zonedDateTime.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));
    System.out.println("在同一时刻,Asia/Tokyo的时间是:" + otherZonedTime);
}

输出结果：

Asia/Shanghai的时间是:2018-11-11T08:54:38+08:00[Asia/Shanghai]
在同一时刻,Asia/Tokyo的时间是:2018-11-11T09:54:38+09:00[Asia/Tokyo]

1.5、Month枚举类

推荐在初始化LocalDate和LocalDateTime对象的时候,月份的参数使用枚举的方式传入

public class Java8TimeClassMethodDemo6 {
    public static void main(String[] args) {
        //在初始化LocalDate和LocalDateTime的时候,月份的参数传入枚举类(2011年5月15日11时11分11秒)
        LocalDateTime.of(2011, Month.JUNE,15,11,11,11);
        //of方法可以根据传入的数字返回对应的月份.
        Month month = Month.of(12);
        System.out.println(month);
    }
}

输出结果：

DECEMBER

2、对日期时间的加减

2.1、LocalDate日期的加减

public class Java8TimeMethodPlusDemo1 {
    public static void main(String[] args) {
        //封装LocalDate对象参数为2016年2月13日.
        LocalDate date = LocalDate.of(2016, Month.FEBRUARY, 13);
        //计算当前时间的4天后的时间.
        LocalDate plusDaysTime = date.plusDays(4);
        //计算当前时间的3周后的时间.
        LocalDate plusWeeksTime = date.plusWeeks(3);
        //计算当前时间的5个月后的时间.
        LocalDate plusMonthsTime = date.plusMonths(5);
        //计算当前时间的2年后的时间.
        LocalDate plusYearsTime = date.plusYears(2);
        System.out.println("当前的时间是:"+date);
        System.out.println("4天后的时间是:"+plusDaysTime);
        System.out.println("3周后的时间是:"+plusWeeksTime);
        System.out.println("5个月后的时间是:"+plusMonthsTime);
        System.out.println("2年后的时间是:"+plusYearsTime);
    }
}

输出结果：

当前的时间是:2016-02-13
4天后的时间是:2016-02-17
3周后的时间是:2016-03-05
5个月后的时间是:2016-07-13
2年后的时间是:2018-02-13

2.2、LocalTime时间的加减

public class Java8TimeMethodPlusDemo2 {
    public static void main(String[] args) {
        //封装LocalTime对象参数为8时14分39秒218纳秒.
        LocalTime time = LocalTime.of(8, 14, 39, 218);

        //计算当前时间500纳秒后的时间.
        LocalTime plusNanosTime = time.plusNanos(500);
        //计算当前时间45秒后的时间.
        LocalTime plusSecondsTime = time.plusSeconds(45);
        //计算当前时间19分钟后的时间.
        LocalTime plusMinutesTime = time.plusMinutes(19);
        //计算当前时间3小时后的时间.
        LocalTime plusHoursTime = time.plusHours(3);

        System.out.println("当前的时间是:" + time);
        System.out.println("45秒后的时间是:" + plusSecondsTime);
        System.out.println("19分钟后的时间是:" + plusMinutesTime);
        System.out.println("500纳秒后的时间是:" + plusNanosTime);
        System.out.println("3小时后的时间是:" + plusHoursTime);
    }
}

输出结果：

当前的时间是:08:14:39.000000218
45秒后的时间是:08:15:24.000000218
19分钟后的时间是:08:33:39.000000218
500纳秒后的时间是:08:14:39.000000718
3小时后的时间是:11:14:39.000000218

2.3、with方法修改LocalDateTime类时间

● LocalDateTime withNano(int i) 修改纳秒
● LocalDateTime withSecond(int i) 修改秒
● LocalDateTime withMinute(int i) 修改分钟
● LocalDateTime withHour(int i) 修改小时
● LocalDateTime withDayOfMonth(int i) 修改日
● LocalDateTime withMonth(int i) 修改月
● LocalDateTime withYear(int i) 修改年

public class Java8TimeMethodWithDemo1 {
    public static void main(String[] args) {
        LocalDateTime time = LocalDateTime.now();
        //经过使用发现time中的时间有错误,应该是1日,在不知道原有时间的基础上,
        //无法进行增减操作,所以可以直接使用with方法进行修改.
        LocalDateTime endTime = time.withDayOfMonth(1);
        System.out.println("修改前错误的时间是:" + time);
        System.out.println("修改完成之后的时间是:" + endTime);
    }
}

输出结果：

修改前错误的时间是:2022-04-01T23:05:20.061
修改完成之后的时间是:2022-04-01T23:05:20.061

3、调节器TemporalAdjuster

3.1、TemporalAdjusters类中常用静态方法的使用

  1. static TemporalAdjuster firsyDayOfNextMonth()
    下个月的第一天
  2. static TemporalAdjuster firstDayOfNextYear()
    下一年的第一天
  3. static TemporalAdjuster firstDayOfYear()
    当年的第一天
  4. static TemporaAdjuster firstInMonth(DayOfWeek dayOfWeek)
    当月的第一个周x(通过参数确定)
  5. static TemporaAdjuster lastDayOfMonth()
    当月的最后一天
  6. static TemporaAdjuster lastDayOfYear()
    当年的最后一天
  7. static TemporaAdjuste lastInMonth(DayOfWeek dayOfWeek)
    当月的最后一个周x(通过参数确定)
  8. static TemporaAdjuster next(DayOfWeek dayOfWeek)
    下一个周x(通过参数确定)
  9. static TemporaAdjuster previous(DayOfWeek dayOfWeek)
    上一个周x(通过参数确定)
public class Java8TimeTemporalAdjusterDemo1 {
    public static void main(String[] args) {
        //封装日期时间对象为当前时间,LocalDate.
        LocalDate time = LocalDate.now();
        /*
        with方法可以修改time对象中封装的数据,需要传入一个TemporalAdjuster对象,
        通过查看发现TemporalAdjuster是一个接口,方法的参数是一个接口,
        那么实际上传入的是这个接口的实现类对象.
        TemporalAdjusters的类可以给我们提供一些常用的方法.
         */
        //with方法传入了TemporalAdjuster类的实现对象,
        //是由TemporalAdjusters类的方法实现了adjustInto方法,
        //当前的逻辑是:将时间修改为当月的第一天.
        LocalDate firstDayOfMonth = time.with(TemporalAdjusters.firstDayOfMonth());
        //将时间修改为下个月的第一天.
        LocalDate firstDayOfNextMonth = time.with(TemporalAdjusters.firstDayOfNextMonth());
        //将时间修改为下一年的第一天.
        LocalDate firstDayOfNextYear = time.with(TemporalAdjusters.firstDayOfNextYear());
        //将时间修改为本年的第一天.
        LocalDate firstDayOfYear = time.with(TemporalAdjusters.firstDayOfYear());
        //将时间修改为本月的最后一天.
        LocalDate lastDayOfMonth = time.with(TemporalAdjusters.lastDayOfMonth());
        //将时间修改为本年的最后一天.
        LocalDate lastDayOfYear = time.with(TemporalAdjusters.lastDayOfYear());

        System.out.println("当月的第一天是:" + firstDayOfMonth);
        System.out.println("下个月的第一天是:" + firstDayOfNextMonth);
        System.out.println("下一年的第一天是:" + firstDayOfNextYear);
        System.out.println("本年的第一天是:" + firstDayOfYear);
        System.out.println("本月的最后一天是:" + lastDayOfMonth);
        System.out.println("本年的最后一天是:" + lastDayOfYear);
    }
}

当月的第一天是:2022-04-01
下个月的第一天是:2022-05-01
下一年的第一天是:2023-01-01
本年的第一天是:2022-01-01
本月的最后一天是:2022-04-30
本年的最后一天是:2022-12-31

3.2、DayOfWeek的使用

public class Java8TimeTemporalAdjusterDemo2 {
    public static void main(String[] args) {
        //封装日期时间对象为当前时间,LocalDate.
        LocalDate time = LocalDate.now();
        /*
        DayOfWeek是一周中星期几的枚举类,其中封装了从周一到周日.
         */
        //将当前时间修改为下一个周日
        LocalDate nextSunday = time.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
        //将当前时间修改为上一个周三
        LocalDate previousWednesday = time.with(TemporalAdjusters.previous(DayOfWeek.WEDNESDAY));
        System.out.println("下一个周日是:"+nextSunday);
        System.out.println("上一个周三是:"+previousWednesday);
    }
}

输出结果：

public class Java8TimeTemporalAdjusterDemo2 {
    public static void main(String[] args) {
        //封装日期时间对象为当前时间,LocalDate.
        LocalDate time = LocalDate.now();
        /*
        DayOfWeek是一周中星期几的枚举类,其中封装了从周一到周日.
         */
        //将当前时间修改为下一个周日
        LocalDate nextSunday = time.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
        //将当前时间修改为上一个周三
        LocalDate previousWednesday = time.with(TemporalAdjusters.previous(DayOfWeek.WEDNESDAY));
        System.out.println("下一个周日是:"+nextSunday);
        System.out.println("上一个周三是:"+previousWednesday);
    }
}

输出结果：

下一个周日是:2022-04-03
上一个周三是:2022-03-30

4、java8时间类与旧版本的转换

4.1、LocalDate与Date相互转换

  • LocalDate转换为java.util.Date
LocalDate localDate = LocalDate.now();
ZoneId zone = ZoneId.systemDefault();
Instant instant = localDate.atStartOfDay().atZone(zone).toInstant();
Date date = Date.from(instant);
  • java.util.Date转换为LocalDate
Instant instant = new Date().toInstant();
ZoneId zone = ZoneId.systemDefault();
LocalDate localDate = instant.atZone(zone).toLocalDate();
  • LocalDate转换为String
LocalDate now = LocalDate.now();
String result = now.format(DateTimeFormatter.ofPattern("yyyyMMdd"));

4.2、LocalDateTime与Date相互转换

  • LocalDateTime转换为java.util.Date
LocalDateTime localDateTime = LocalDateTime.now();
//获取系统默认时区
ZoneId zoneId = ZoneId.systemDefault();
//时区的日期和时间
ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
//获取时刻
Date date = Date.from(zonedDateTime.toInstant());
  • java.util.Date转换为LocalDateTime
Date date = new Date();
ZoneId zoneId = ZoneId.systemDefault();
LocalDateTime localDateTime = date.toInstant().atZone(zoneId).toLocalDateTime();
  • LocalDateTime转换为String
//对LocalDateTime进行格式化与解析,初始化LocalDateTime对象.
LocalDateTime time = LocalDateTime.now();
//通过通过DateTimeFormatter的ofPattern方法可以自定义格式化模式.
String result = time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS"));
  • String转换为LocalDateTime
LocalDateTime localDateTime = LocalDateTime.parse("2012-10-01 10:10:20:111",
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS"));

4.3、LocalDateTime与Timestamp相互转换

  • LocalDateTime转换为Timestamp
Timestamp time = Timestamp.valueOf(LocalDateTime.now())
  • Timestamp转换为LocalDateTime
Timestamp time = new Timestamp(System.currentTimeMillis());
LocalDateTime lTime = time.toLocalDateTime();

4.4、LocalDateTime与时间戳相互转换

  • LocalDateTime转换为时间戳
ZoneId zone = ZoneId.systemDefault();
long timestamp = LocalDateTime.now().atZone(zone).toInstant().toEpochMilli();
  • 时间戳转换为LocalDateTime
Instant instant = Instant.ofEpochMilli(1653751657849L);
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/148617.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！