https://www.lilu.org.cn/https://www.lilu.org.cn/
第十二章：新的日期时间API
在Java 8之前，我们常用的日期时间API是java.util.Date和java.util.Calendar这两个类。
如果我们要构建一个指定年月日的日期时间对象，比如2019-9-2，使用java.util.Date类的构造方法Date(int year, int month, int date)，传入的年份year参数必须是年份2019减去1900，即传入119。每次创建对象前还需要先进行计算，很不方便。
JDK 1.1提供的java.util.Calendar类在使用时也有很多不方便的地方，比如对一个日期加两天，使用add方法，传入2；对一个日期减两天，也使用add方法，传入-2。还有一点是这个类默认每周第一天是周日。使用起来也有点不方便。
归根到底，JDK1.8之前的日期时间API都是可变的，是线程不安全的。
另外，对时间日期进行格式化的类SimpleDateFormat在java.text包下，该类的定义位置不规范。它也是线程不安全的。
而在Java 8中，时间格式转化器是java.time.format.DateTimeFormatter类，它被声明为final，是不可变的类，线程安全。
另外，Java 8中提供的新日期时间API包含两类：一个是为了便于人阅读使用，包含LocalDate、LocalTime、LocalDateTime这三个类，它们都是用final修饰的类，是不可变的对象，分别表示ISO-8601日历系统中的日期、时间、日期和时间。另外一个是便于机器处理的类，Instant：用来表示机器的日期和时间格式：时间戳。
ISO-8601日历系统：是国际标准化组织制定的现代公民的日期和时间的表示法。
时间戳：从UNIX元年：1970年1月1日 00:00:00到某个时间之间的毫秒值。
传统时间格式转换器SimpleDateFormat线程安全问题演示
当多个线程同时操作同一个SimpleDateFormat对象时，就会出现线程安全问题。
演示代码：
123456789101112131415161718 | public static void main(String[] args) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 使用线程池模拟多线程 ExecutorService threadPool = Executors.newFixedThreadPool(10); // 定义解析日期字符串任务：使用SimpleDateFormat对象解析 Callable<Date> task = () -> sdf.parse("2019-8-29"); // 存储结果容器 List<Future<Date>> result = new ArrayList<>(); for (int i = 0; i < 10; i++) { // 执行得到解析结果 result.add(threadPool.submit(task)); } // 遍历输出 for (Future<Date> r : result) { System.out.println(r.get()); } threadPool.shutdown();} |
异常信息如下：
1 | Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.NumberFormatException: multiple points |
解决方法：
1、将SimpleDateFormat定义为方法内的局部变量，且方法中没有多线程的操作。
2、使用ThreadLocal进行线程封闭。为每个线程保存一个SimpleDateFormat对象。
传统时间格式转换器线程安全问题解决方案：使用ThreadLocal进行线程封闭
线程封闭类代码：
1234567891011121314151617181920212223 | package cn.org.lilu.chapter12;import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.Date;/** * @Auther: lilu * @Date: 2019/8/29 * @Description: 传统时间格式转换器线程安全问题解决方案：使用ThreadLocal进行线程封闭 */public class TraditionalSimpleDateFormatThreadLocal { private static final ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() { @Override protected DateFormat initialValue() { return new SimpleDateFormat("yyyy-MM-dd"); } }; public static Date convert(String source) throws Exception { return threadLocal.get().parse(source); }} |
演示代码：
1234567891011121314151617 | public static void main(String[] args) throws Exception { // 使用线程池模拟多线程 ExecutorService threadPool = Executors.newFixedThreadPool(10); // 定义解析日期字符串任务：每个任务都有一份SimpleDateFormat对象的副本 Callable<Date> task = () -> TraditionalSimpleDateFormatThreadLocal.convert("2019-8-29"); // 解析结果容器 List<Future<Date>> result = new ArrayList<>(); for (int i = 0; i < 10; i++) { // 执行得到解析结果 result.add(threadPool.submit(task)); } // 遍历输出 for (Future<Date> r : result) { System.out.println(r.get()); } threadPool.shutdown();} |
运行结果正常。
Java 8新的时间格式转化器DateTimeFormatter
DateTimeFormatter类定义在java.time.format包下，且声明为final类，不可变，线程安全。
代码演示：
1234567891011121314151617 | public static void main(String[] args) throws Exception { // 按照哪种格式进行格式转换 // DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE; DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd"); // LocalDate.parse("20190829",dtf)：将第一个字符串参数按照第二个参数定义的格式器解析，返回一个LocalDate对象 Callable<LocalDate> task = () -> LocalDate.parse("20190829",dtf); ExecutorService threadPool = Executors.newFixedThreadPool(10); List<Future<LocalDate>> result = new ArrayList<>(); for (int i = 0; i < 10; i++) { result.add(threadPool.submit(task)); } // 遍历输出 for (Future<LocalDate> r : result) { System.out.println(r.get()); } threadPool.shutdown();} |
Java 8日期时间API：LocalDate、LocalTime、LocalDateTime
这三个类的用法几乎一样，LocalDate表示日期，LocalTime表示时间，LocalDateTime包含前两者，表示日期和时间。
可由前两个类组合出第三个类，也可由第三个类提取出前两个类。
年月日对象：LocalDate
可使用静态工厂方法now获取当前日期；
可使用静态工厂方法of创建一个LocalDate日期对象，可从一个LocalDate日期对象中获取该日期的年份、月份、这个月的第几天、这周的星期几、今年的第几天、这个月的长度（有几天）和是否为闰年等信息。
代码演示：
1234567891011121314151617181920212223242526272829303132 | /** * LocalDate：年月日 */@Testpublic void testLocalDate() { // 静态工厂方法now获取当前日期 LocalDate now = LocalDate.now(); // 静态工厂方法of创建一个LocalDate实例 LocalDate date = LocalDate.of(2019,8,26); // 年份 int year = date.getYear(); // 月份 Month month = date.getMonth(); // 这个月第几天 int dayOfMonth = date.getDayOfMonth(); // 这周星期几 DayOfWeek dayOfWeek = date.getDayOfWeek(); // 今年第几天 int dayOfYear = date.getDayOfYear(); // 这个月的长度（有几天） int lengthOfMonth = date.lengthOfMonth(); // 是否闰年 boolean leapYear = date.isLeapYear(); System.out.println(now); // 2019-09-02 System.out.println(year); // 2019 System.out.println(month); // AUGUST System.out.println(dayOfMonth); // 26 System.out.println(dayOfWeek); // MONDAY System.out.println(dayOfYear); // 238 System.out.println(lengthOfMonth); // 31 System.out.println(leapYear); // false} |
时分秒对象：LocalTime
可使用静态工厂方法now获取当前时间的时分秒（包含纳秒）。
可使用静态工厂方法of创建一个LocalTime时间对象，可从一个LocalTime时间对象中获取该时间的时、分、秒和纳秒等信息。
of方法包含三个重载，方法签名如下：
1234567891011121314151617181920 | /** * @param hour the hour-of-day to represent, from 0 to 23 * @param minute the minute-of-hour to represent, from 0 to 59 */public static LocalTime of(int hour, int minute);/** * @param hour the hour-of-day to represent, from 0 to 23 * @param minute the minute-of-hour to represent, from 0 to 59 * @param second the second-of-minute to represent, from 0 to 59 */public static LocalTime of(int hour, int minute, int second);/** * @param hour the hour-of-day to represent, from 0 to 23 * @param minute the minute-of-hour to represent, from 0 to 59 * @param second the second-of-minute to represent, from 0 to 59 * @param nanoOfSecond the nano-of-second to represent, from 0 to 999,999,999 */public static LocalTime of(int hour, int minute, int second, int nanoOfSecond); |
使用代码示例：
12345678910111213141516171819202122 | /** * LocalTime：时分秒 * 一天中的时间，比如：13:45:20，可以使用LocalTime类表示 * 可以使用of重载的三个静态工厂方法创建LocalTime实例 * 第一个重载方法接收小时和分钟 * 第二个重载方法同时还接收秒 * 第三个重载方法同时还接收纳秒 */@Testpublic void testLocalTime() { LocalTime now = LocalTime.now(); LocalTime localTime = LocalTime.of(13, 45, 20,1); int hour = localTime.getHour(); int minute = localTime.getMinute(); int second = localTime.getSecond(); int nano = localTime.getNano(); System.out.println(now); // 19:47:51.212 System.out.println(hour); // 13 System.out.println(minute); // 45 System.out.println(second); // 20 System.out.println(nano); // 1} |
日期时间字符串解析
LocalDate和LocalTime都可以通过解析代表它们的字符串创建。使用静态方法parse。一旦传递的字符串参数无法被解析为合法的LocalDate或LocalTime对象，这两个parse方法都会抛出一个继承自RuntimeException的DateTimeParseException异常。
代码示例：
12345678910111213 | /** * LocalDate和LocalTime都可以通过解析代表它们的字符串创建。使用静态方法parse。 * 一旦传递的字符串参数无法被解析为合法的LocalDate或LocalTime对象， * 这两个parse方法都会抛出一个继承自RuntimeException的DateTimeParseException异常。 */@Testpublic void testParse() { // 小于10的必须在前面补0，否则抛出异常 LocalDate localDate = LocalDate.parse("2019-08-26"); LocalTime localTime = LocalTime.parse("13:45:20"); System.out.println(localDate); System.out.println(localTime);} |
年月日时分秒对象：LocalDateTime
可使用静态工厂方法now获取当前时间的年月日时分秒纳秒；
可使用静态工厂方法of创建一个LocalDateTime日期时间对象；
可由LocalDate和LocalTime组合出LocalDateTime对象；
可从LocalDateTime对象中提取出LocalDate和LocalTime。
代码示例：
123456789101112131415161718192021222324252627 | /** * LocalDateTime：年月日时分秒 */@Testpublic void testLocalDateTime() { LocalDateTime localDateTime = LocalDateTime.now(); LocalDateTime localDateTime1 = LocalDateTime.of(2019, Month.AUGUST, 26, 10, 47, 20); LocalDate localDate = LocalDate.now(); LocalTime localTime = LocalTime.now(); // 由LocalDate和LocalTime组合出LocalDateTime LocalDateTime localDateTime2 = LocalDateTime.of(localDate,localTime); LocalDateTime localDateTime3 = localDate.atTime(10,51,32); LocalDateTime localDateTime4 = localDate.atTime(localTime); LocalDateTime localDateTime5 = localTime.atDate(localDate); // 由LocalDateTime提取出LocalDate和LocalTime LocalDate localDateFromLocalDateTime = localDateTime2.toLocalDate(); LocalTime localTimeFromLocalDateTime = localDateTime2.toLocalTime(); System.out.println(localDateTime); // 2019-09-02T19:57:16.516 System.out.println(localDateTime1); // 2019-08-26T10:47:20 System.out.println(localDateTime2); // 2019-09-02T19:57:16.517 System.out.println(localDateTime3); // 2019-09-02T10:51:32 System.out.println(localDateTime4); // 2019-09-02T19:57:16.517 System.out.println(localDateTime5); // 2019-09-02T19:57:16.517 System.out.println(localDateFromLocalDateTime); // 2019-09-02 System.out.println(localTimeFromLocalDateTime); // 19:57:16.517} |
时间戳对象：Instant
机器的日期和时间格式：从UNIX元年时间开始到现在所经过的秒数对时间进行建模。包含的是由秒及纳秒组成的数字。
使用静态工厂方法now获取当前时刻的时间戳，默认获取的是UTC时区（世界协调时间）所在的时刻，可做时区偏移运算获取带偏移量的日期时间对象OffsetDateTime。可使用toEpochMilli方法获取表示的时间戳秒数。
可使用静态工厂方法ofEpochSecond等对时间戳进行运算。
Instant的设计初衷是为了便于机器使用。它包含的是由秒及纳秒所构成的数字。所以，它无法处理那些我们非常容易理解的时间单位。比如下面这行代码：
1 | int day = Instant.now().get(ChronoField.DAY_OF_MONTH); |
它会抛出如下异常：
1 | java.time.temporal.UnsupportedTemporalTypeException: Unsupported field: DayOfMonth |
示例代码：
123456789101112131415161718192021222324252627282930313233 | /** * Instant：从UNIX元年时间开始到现在所经过的秒数对时间进行建模。包含的是由秒及纳秒组成的数字。 * * 静态工厂方法：ofEpochSecond包含两个重载版本 * // 传入一个代表秒数的值创建一个Instant实例 * Instant ofEpochSecond(long epochSecond) * // 第一个参数：代表秒数的值，第二个参数：纳秒数，对第一个参数传入的秒数进行调整，确保保存的纳秒分片在0到999 999 999之间。 * Instant ofEpochSecond(long epochSecond, long nanoAdjustment) * * 静态工厂方法：now */@Testpublic void testInstant() { Instant instant1 = Instant.ofEpochSecond(3); Instant instant2 = Instant.ofEpochSecond(3, 0); Instant instant3 = Instant.ofEpochSecond(2, 1_000_000_000); Instant instant4 = Instant.ofEpochSecond(4, -1_000_000_000); System.out.println(instant1); System.out.println(instant2); System.out.println(instant3); System.out.println(instant4); Instant now = Instant.now(); // 默认获取UTC时区的时间 System.out.println(now); // 时区偏移运算：获取偏移8小时的时区的时间。OffsetDateTime：带偏移量的日期时间对象 OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8)); System.out.println(offsetDateTime); // 转化成时间戳 System.out.println(now.toEpochMilli()); // java.time.temporal.UnsupportedTemporalTypeException: Unsupported field: DayOfMonth int day = now.get(ChronoField.DAY_OF_MONTH); System.out.println(day);} |
计算两个时间之间的间隔：Duration 和计算两个日期之间的间隔：Period
可以使用Duration类的静态方法between计算两个时间点之间的间隔，between方法接收的参数是两个Temporal对象，虽然LocalDateTime和Instant都是Temporal接口的实现类，但是它们是为不同的目的而设计的，一个是为了便于人阅读使用， 另一个是为了便于机器处理，所以我们不能将它们混用，即不能计算LocalDateTime和Instant对象之间的间隔。
可以使用Period类的静态方法between计算两个日期之间的间隔。
也可使用静态工厂方法直接创建Duration和Period类的对象。
示例代码：
12345678910111213141516171819202122232425262728293031323334 | /** * 计算两个时间之间的间隔：Duration * 计算两个日期之间的间隔：Period */@Testpublic void testDuration() throws Exception { LocalTime localTime1 = LocalTime.parse("13:45:20"); LocalTime localTime2 = LocalTime.parse("13:45:30"); LocalDateTime localDateTime1 = LocalDateTime.now(); Thread.sleep(100); LocalDateTime localDateTime2 = LocalDateTime.now(); Instant instant1 = Instant.ofEpochSecond(3); Instant instant2 = Instant.ofEpochSecond(6); System.out.println(Duration.between(localTime1,localTime2)); // PT10S System.out.println(Duration.between(localDateTime1,localDateTime2)); // PT0.1S System.out.println(Duration.between(instant1,instant2)); // PT3S // 计算两个LocalDate之间的时长 Period periodBetween = Period.between(LocalDate.of(2019, 8, 26), LocalDate.of(2019, 8, 28)); System.out.println(periodBetween); // P1D System.out.println(periodBetween.getDays()); // 2 // Duration和Period的静态工厂方法直接创建实例 Duration durationOfMinutes = Duration.ofMinutes(3); Duration durationOf = Duration.of(3, ChronoUnit.MINUTES); Period periodOfDays = Period.ofDays(10); Period periodOfWeeks = Period.ofWeeks(3); Period periodOf = Period.of(2, 6, 1); System.out.println(durationOfMinutes); // PT3M System.out.println(durationOf); // PT3M System.out.println(periodOfDays); // P10D System.out.println(periodOfWeeks); // P21D System.out.println(periodOf); // P2Y6M1D} |
操作、解析和格式化日期
LocalDate、LocalTime、LocalDateTime以及Instant这样表示时间点的日期-时间类提供了很多通用的方法用来操作日期-时间。所有的方法都返回一个修改了属性的对象。它们都不会修改原来的对象。
最直接也最简单的方法是使用”withAttribute“方法。”withAttribute“方法会创建对象的一个副本，并按照需要修改它的属性。
也可使用通用的with方法，它接受的第一个参数是一个TemporalField对象，第二个参数是需要修改的值。
with方法还有一个重载的方法，它接收一个日期调整器TemporalAdjuster对象，更加灵活地处理日期。
代码示例：
12345678910111213141516171819202122232425 | /** * 操纵、解析和格式化日期 * * LocalDate、LocalTime和LocalDateTime类都为final类，不可变，每次操作后都返回一个新的对应对象 */@Testpublic void testUpdateTime() { LocalDate date1 = LocalDate.of(2019, 8, 26); LocalDate date2 = date1.withYear(2020); LocalDate date3 = date2.withDayOfMonth(25); LocalDate date4 = date3.with(ChronoField.MONTH_OF_YEAR, 9); System.out.println(date1); // 2019-08-26 System.out.println(date2); // 2020-08-26 System.out.println(date3); // 2020-08-25 System.out.println(date4); // 2020-09-25 LocalDate date5 = LocalDate.of(2019,8,26); LocalDate date6 = date5.plusWeeks(1); // 加一周 LocalDate date7 = date6.minusYears(3); // 减三年 LocalDate date8 = date7.plus(6, ChronoUnit.MONTHS); // 加六月 System.out.println(date5); // 2019-08-26 System.out.println(date6); // 2019-09-02 System.out.println(date7); // 2016-09-02 System.out.println(date8); // 2017-03-02} |
日期调整器：TemporalAdjuster
TemporalAdjuster是一个函数式接口，接口方法签名如下：
1 | Temporal adjustInto(Temporal temporal); |
接收一个Temporal对象，返回一个Temporal对象。由于所有的日期时间API都实现了Temporal接口，故它可以用来自定义更加复杂的日期时间操作。
Java 8提供了TemporalAdjusters类，该类通过静态方法提供了大量的常用TemporalAdjuster的实现。
同时还支持定制TemporalAdjuster，定制的方式有两种：
一：实现TemporalAdjuster接口；
二：使用Lambda表达式定制TemporalAdjuster对象，推荐使用TemporalAdjusters类的静态工厂方法ofDateAdjuster，该方法签名如下：
1 | public static TemporalAdjuster ofDateAdjuster(UnaryOperator<LocalDate> dateBasedAdjuster) |
接收一个UnaryOperator函数式接口，返回一个TemporalAdjuster对象。
UnaryOperator函数式接口中方法签名如下，它总是返回它的输入。
123 | static <T> UnaryOperator<T> identity() { return t -> t;} |
相关代码示例如下：
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101 | /** * 日期调整器 */@Testpublic void testTemporalAdjuster() { LocalDate date1 = LocalDate.of(2019,8,26); // TemporalAdjuster dayOfWeekInMonth(int ordinal, DayOfWeek dayOfWeek) // dayOfWeek表示星期几 // 如果ordinal为0，则表示本日期所在的月的上一个月的最后一个星期几 // 如果ordinal为正数，则以本日期所在的月从前向后数，第ordinal个星期几 // 如果ordinal为负数，则以本日期所在的月从后往前数，第-ordinal个星期几 LocalDate date2 = date1.with(TemporalAdjusters.dayOfWeekInMonth(1, DayOfWeek.FRIDAY)); System.out.println("date2=" + date2); // TemporalAdjuster firstDayOfMonth()：创建一个新的日期，它的值为当月的第一天 LocalDate date3 = date1.with(TemporalAdjusters.firstDayOfMonth()); System.out.println("date3=" + date3); // TemporalAdjuster firstDayOfNextMonth()：创建一个新的日期，它的值为下月的第一天 LocalDate date4 = date1.with(TemporalAdjusters.firstDayOfNextMonth()); System.out.println("date4=" + date4); // TemporalAdjuster firstDayOfNextYear()：创建一个新的日期，它的值为明年的第一天 LocalDate date5 = date1.with(TemporalAdjusters.firstDayOfNextYear()); System.out.println("date5=" + date5); // TemporalAdjuster firstDayOfYear()：创建一个新的日期，它的值为今年的第一天 LocalDate date6 = date1.with(TemporalAdjusters.firstDayOfYear()); System.out.println("date6=" + date6); // TemporalAdjuster firstInMonth(DayOfWeek dayOfWeek)：创建一个新的日期，它的值为同一个月中，第一个符合星期几要求的日期（这个月的第一个星期几） LocalDate date7 = date1.with(TemporalAdjusters.firstInMonth(DayOfWeek.FRIDAY)); System.out.println("date7=" + date7); // TemporalAdjuster lastDayOfMonth()：创建一个新的日期，它的值为这个月的最后一天 LocalDate date8 = date1.with(TemporalAdjusters.lastDayOfMonth()); System.out.println("date8=" + date8); // TemporalAdjuster lastDayOfYear()：创建一个新的日期，它的值为今年的最后一天 LocalDate date9 = date1.with(TemporalAdjusters.lastDayOfYear()); System.out.println("date9=" + date9); // TemporalAdjuster lastInMonth(DayOfWeek dayOfWeek)：创建一个新的日期，它的值为同一个月中，最后一个符合星期几要求的日期 LocalDate date10 = date1.with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY)); System.out.println("date10=" + date10); // TemporalAdjuster next(DayOfWeek dayOfWeek)：创建一个新的日期，并将其值设定为指定日期之后第一个符合指定星期几的日期 LocalDate date11 = date1.with(TemporalAdjusters.next(DayOfWeek.MONDAY)); System.out.println("date11=" + date11); // TemporalAdjuster nextOrSame(DayOfWeek dayOfWeek)： // 创建一个新的日期，并将其值设定为指定日期之后第一个符合指定星期几的日期； // 如果指定日期已符合要求，则直接返回该日期 LocalDate date12 = date1.with(TemporalAdjusters.nextOrSame(DayOfWeek.MONDAY)); System.out.println("date12=" + date12); // TemporalAdjuster previous(DayOfWeek dayOfWeek)：创建一个新的日期，并将其值设定为指定日期之前第一个符合指定星期几的日期 LocalDate date13= date1.with(TemporalAdjusters.previous(DayOfWeek.MONDAY)); System.out.println("date13=" + date13); // TemporalAdjuster previousOrSame(DayOfWeek dayOfWeek)： // 创建一个新的日期，并将其值设定为指定日期之前第一个符合指定星期几的日期； // 如果指定日期已符合要求，则直接返回该日期 LocalDate date14 = date1.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)); System.out.println("date14=" + date14); // 使用Lambda表达式定制TemporalAdjuster对象，推荐使用TemporalAdjusters类的静态工厂方法ofDateAdjuster // TemporalAdjuster ofDateAdjuster(UnaryOperator<LocalDate> dateBasedAdjuster) TemporalAdjuster nextWorkingDay = TemporalAdjusters.ofDateAdjuster(temporal -> { DayOfWeek dayOfWeek = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK)); int dayToAdd = 1; if (dayOfWeek == DayOfWeek.FRIDAY) dayToAdd = 3; else if (dayOfWeek == DayOfWeek.SATURDAY) dayToAdd = 2; return temporal.plus(dayToAdd,ChronoUnit.DAYS); });}/** * 定制TemporalAdjuster * * 计算下一个工作日 */class NextWorkingDay implements TemporalAdjuster { /** * 周一到周五为工作日 * 如果是周日到周四，则返回下一天 * 如果是周五、周六、返回下周周一 * @param temporal * @return */ @Override public Temporal adjustInto(Temporal temporal) { // 得到今天星期几 DayOfWeek dayOfWeek = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK)); int dayToAdd = 1; if (dayOfWeek == DayOfWeek.FRIDAY) dayToAdd = 3; else if (dayOfWeek == DayOfWeek.SATURDAY) dayToAdd = 2; return temporal.plus(dayToAdd,ChronoUnit.DAYS); }} |
TemporalAdjusters类中包含的工厂方法列表：
| 方法签名 | 描述 |
|---|---|
TemporalAdjuster dayOfWeekInMonth(int ordinal, DayOfWeek dayOfWeek) |
dayOfWeek表示星期几 如果ordinal为0，则表示本日期所在的月的上一个月的最后一个星期几 如果ordinal为正数，则以本日期所在的月从前向后数，第ordinal个星期几 如果ordinal为负数，则以本日期所在的月从后往前数，第-ordinal个星期几 |
TemporalAdjuster firstDayOfMonth() |
创建一个新的日期，它的值为当月的第一天 |
TemporalAdjuster firstDayOfNextMonth() |
创建一个新的日期，它的值为下月的第一天 |
TemporalAdjuster firstDayOfNextYear() |
创建一个新的日期，它的值为明年的第一天 |
TemporalAdjuster firstDayOfYear() |
创建一个新的日期，它的值为今年的第一天 |
TemporalAdjuster firstInMonth(DayOfWeek dayOfWeek) |
创建一个新的日期，它的值为同一个月中，第一个符合星期几要求的日期（这个月的第一个星期几） |
TemporalAdjuster lastDayOfMonth() |
创建一个新的日期，它的值为这个月的最后一天 |
TemporalAdjuster lastDayOfYear() |
创建一个新的日期，它的值为今年的最后一天 |
TemporalAdjuster lastInMonth(DayOfWeek dayOfWeek) |
创建一个新的日期，它的值为同一个月中，最后一个符合星期几要求的日期 |
TemporalAdjuster next(DayOfWeek dayOfWeek) |
创建一个新的日期，并将其值设定为指定日期之后第一个符合指定星期几的日期 |
TemporalAdjuster nextOrSame(DayOfWeek dayOfWeek) |
创建一个新的日期，并将其值设定为指定日期之后第一个符合指定星期几的日期；如果指定日期已符合要求，则直接返回该日期 |
TemporalAdjuster previous(DayOfWeek dayOfWeek) |
创建一个新的日期，并将其值设定为指定日期之前第一个符合指定星期几的日期 |
TemporalAdjuster previousOrSame(DayOfWeek dayOfWeek) |
创建一个新的日期，并将其值设定为指定日期之前第一个符合指定星期几的日期；如果指定日期已符合要求，则直接返回该日期 |
时区
时区的处理是新版日期和时间API新增加的重要功能，使用新版日期和时间API时区的处理被极大地简化了。新的java.time.ZoneId类是老版java.util.TimeZone的替代品。它的设计目标就是要让你无需为时区处理的复杂和繁琐而操心，跟其他日期和时间类一 样，ZoneId类也是被final修饰而无法修改的。
代码示例：
123456789101112131415161718 | /** * 带时区的日期时间API */@Testpublic void testZoneLocalDateTime() { // 查看所有支持的时区 Set<String> availableZoneIds = ZoneId.getAvailableZoneIds(); for (String s: availableZoneIds) { System.out.println(s); } // 通过时区构建LocalDateTime对象 LocalDateTime localDateTimeNow = LocalDateTime.now(ZoneId.of("Asia/Shanghai")); // 指定时区构建带时区的日期时间对象 ZonedDateTime zonedDateTime = localDateTimeNow.atZone(ZoneId.of("Asia/Shanghai")); System.out.println(localDateTimeNow); // 2019-09-03T10:35:25.677 // 2019-09-03T10:35:25.677+08:00[Asia/Shanghai] 与UTC时间相差8小时 System.out.println(zonedDateTime);} |
日期时间API的部分UML图
以上介绍的新的日期时间API相关类的UML图如下：
下面这张图能帮助我们更好的理解LocaleDate、 LocalTime、LocalDateTime以及ZoneId之间的差异。
来源：https://www.cnblogs.com/lijianming180/p/12262455.html