getmonth(getmonth为什么加1)太疯狂了

Java 8 推出了全新的日期时间API。 Java处理日期、日历和时间的方式一直为社区所诟病，将 java.util.Date设定为可变类型，

 

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

新API基于ISO标准日历系统，java.time包下的所有类都是不可变类型而且线程安全InstantInstant是Java 8中用于表示时间戳的类它具有以下特点：它是不可变的，保证了线程安全性它可以精确到纳秒级别，提供了高精度的时间度量。

它与时区无关，表示的是一个绝对的时间点下面是一些使用Instant类的方法和示例：1、 创建Instant对象：Instant.now(): 返回当前的时间戳，例如2021-06-18T02:23:09.123456789Z。

Instant.ofEpochMilli(long epochMilli): 从1970年1月1日开始的毫秒数创建一个Instant对象，例如Instant.ofEpochMilli(1623980589123L)。

Instant.ofEpochSecond(long epochSecond): 从1970年1月1日开始的秒数创建一个Instant对象，例如Instant.ofEpochSecond(1623980589L)。

2、 获取时间戳信息：getEpochSecond(): 获取从1970年1月1日开始的秒数，例如1623980589LgetNano(): 获取纳秒数，例如1234567893、 比较和判断：isAfter(Instant otherInstant)

: 判断当前Instant对象是否在另一个Instant对象之后，返回布尔值isBefore(Instant otherInstant): 判断当前Instant对象是否在另一个Instant对象之前，返回布尔值。

equals(Object otherObject): 判断两个Instant对象是否相等，返回布尔值4、 运算和调整：plus(Duration amountToAdd): 在当前Instant对象上增加指定的时间量，返回一个新的Instant对象。

minus(Duration amountToSubtract): 在当前Instant对象上减去指定的时间量，返回一个新的Instant对象plusSeconds(long secondsToAdd)。

: 在当前Instant对象上增加指定的秒数，返回一个新的Instant对象minusSeconds(long secondsToSubtract): 在当前Instant对象上减去指定的秒数，返回一个新的Instant对象。

5、 转换为其他时间表示：atZone(ZoneId zone): 将Instant对象转换为特定时区的ZonedDateTime对象，例如instant.atZone(ZoneId.of("Asia/Shanghai"))

toEpochMilli(): 获取从1970年1月1日开始的毫秒数，例如1623980589123LtoString(): 返回Instant对象的字符串表示形式，例如2021-06-18T02:23:09.123456789Z。

以上是Instant类中常用方法的介绍和示例通过这些方法，可以方便地创建、操作和比较时间戳，以及将它们转换为其他时间表示形式需要注意的是，Instant类在Java 8中引入，在Java 9中增加了一些新方法。

下面是一些使用Instant类的示例：// 获取当前时刻 Instant now = Instant.now(); System.out.println(now); // 2021-10-15T08:14:55.950Z // 从秒和纳秒创建时刻 Instant instant = Instant.ofEpochSecond(3, 0); System.out.println(instant); // 1970-01-01T00:00:03Z // 从毫秒创建时刻 Instant instant2 = Instant.ofEpochMilli(3000); System.out.println(instant2); // 1970-01-01T00:00:03Z // 从字符串解析时刻 Instant parsed = Instant.parse("2014-12-04T10:15:30.00Z"); System.out.println(parsed); // 2014-12-04T10:15:30Z // 从其他日期和时间对象转换为时刻 LocalDateTime dateTime = LocalDateTime.of(2021, 10, 15, 10, 15, 30); Instant converted = Instant.from(dateTime.atZone(ZoneId.systemDefault())); System.out.println(converted); // 2021-10-15T02:15:30Z // 获取秒数和纳秒数 long seconds = instant.getEpochSecond(); int nanos = instant.getNano(); System.out.println(seconds); // 3 System.out.println(nanos); // 0 // 比较两个时刻的先后顺序和相等性 System.out.println(now.isAfter(instant)); // true System.out.println(now.isBefore(instant)); // false System.out.println(now.compareTo(instant)); // 1 (greater than) System.out.println(now.equals(instant)); // false // 计算两个时刻之间的时间间隔，以不同时间单位表示 Duration duration = Duration.between(instant, now); System.out.println(duration.getSeconds()); // 1634286892 (seconds) System.out.println(duration.toMinutes()); // 27238114 (minutes) System.out.println(duration.toHours()); // 453968 (hours) System.out.println(duration.toDays()); // 18915 (days) // 修改时刻的某些字段，返回一个新的时刻对象 Instant newInstant = instant.with(ChronoField.NANO_OF_SECOND, 500); System.out.println(newInstant); // 1970-01-01T00:00:03.000000500Z // 使用预定义或自定义的调整器修改时刻，返回一个新的时刻对象 Instant adjusted = instant.with(TemporalAdjusters.firstDayOfNextMonth()); System.out.println(adjusted); // 1970-02-01T00:00:03Z // 加上或减去指定时间单位和数量的新时刻对象 Instant plus = instant.plus(5, ChronoUnit.DAYS); System.out.println(plus); // 1970-01-06T00:00:03Z Instant minus = instant.minus(3, ChronoUnit.SECONDS); System.out.println(minus); // 1970-01-01T00:00Z // 截断到指定时间单位的新时刻对象 Instant truncated = instant.truncatedTo(ChronoUnit.MINUTES); System.out.println(truncated); // 1970-01-01T00:00Z // 将时刻与偏移量或时区结合，创建OffsetDateTime或ZonedDateTime对象 OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8)); System.out.println(offsetDateTime); // 1970-01-01T08:00:03+08:00 ZonedDateTime zonedDateTime = instant.atZone(ZoneId.of("Asia/Shanghai")); System.out.println(zonedDateTime); // 1970-01-01T08:00:03+08:00[Asia/Shanghai]

DurationDuration是Java 8中用于表示时间间隔或持续时间的类它具有以下特点：它是不可变的，保证了线程安全性它可以精确到纳秒级别，提供了高精度的时间度量它可以用于在时间上执行各种算术和比较操作，例如加减、乘除、最大最小等。

下面是一些使用Duration类的方法和示例：1、 创建Duration对象：Duration.ofDays(long days): 创建一个持续时间，以指定的天数为单位，例如Duration.ofDays(3)

Duration.ofHours(long hours): 创建一个持续时间，以指定的小时数为单位，例如Duration.ofHours(12)Duration.ofMinutes(long minutes)。

: 创建一个持续时间，以指定的分钟数为单位，例如Duration.ofMinutes(30)Duration.ofSeconds(long seconds): 创建一个持续时间，以指定的秒数为单位，例如。

Duration.ofSeconds(10)Duration.ofMillis(long millis): 创建一个持续时间，以指定的毫秒数为单位，例如Duration.ofMillis(1000)Duration.ofNanos(long nanos)

: 创建一个持续时间，以指定的纳秒数为单位，例如Duration.ofNanos(1000000)2、 获取持续时间信息：getSeconds(): 获取持续时间的秒数部分，例如10LgetNano()。

: 获取持续时间的纳秒数部分，例如1000000toDays(): 将持续时间转换为天数，例如3LtoHours(): 将持续时间转换为小时数，例如12LtoMinutes(): 将持续时间转换为分钟数，例如。

30LtoMillis(): 将持续时间转换为毫秒数，例如1000LtoNanos(): 将持续时间转换为纳秒数，例如1000000L3、 比较和判断：isZero(): 判断持续时间是否为零，返回布尔值。

isNegative(): 判断持续时间是否为负数，返回布尔值compareTo(Duration otherDuration): 将持续时间与另一个持续时间进行比较，返回整数值如果当前持续时间小于、等于或大于另一个持续时间，则返回负数、零或正数。

4、 运算和调整：plus(Duration otherDuration): 将另一个持续时间添加到当前持续时间，返回一个新的Duration对象minus(Duration otherDuration)。

: 从当前持续时间减去另一个持续时间，返回一个新的Duration对象plusDays(long daysToAdd): 将指定的天数添加到当前持续时间，返回一个新的Duration对象minusDays(long daysToSubtract)。

: 从当前持续时间中减去指定的天数，返回一个新的Duration对象5、 转换为其他时间表示：toDaysPart(): 获取当前持续时间中不足一天的部分所对应的天数，例如0LtoHoursPart()。

: 获取当前持续时间中不足一小时的部分所对应的小时数，例如12LtoMinutesPart(): 获取当前持续时间中不足一分钟的部分所对应的分钟数，例如30LtoString(): 返回Duration对象的字符串表示形式，例如。

PT12H30M10.001S以上是Duration类中常用方法的介绍和示例通过这些方法，可以方便地创建、操作和比较时间间隔，并将其转换为其他时间表示形式Duration类与Instant类结合使用，可以对时间戳进行运算和比较，以及计算两个时间戳之间的时间间隔。

下面是一些使用Duration类的示例： // 创建一个4分钟3秒的时间间隔 Duration duration = Duration.ofMinutes(4).plusSeconds(3); System.out.println(duration); // PT4M3S // 从字符串解析时间间隔 Duration parsed = Duration.parse("PT4M3S"); System.out.println(parsed); // PT4M3S // 获取时间间隔的秒数和纳秒数 long seconds = duration.getSeconds(); int nanos = duration.getNano(); System.out.println(seconds); // 243 System.out.println(nanos); // 0 // 判断时间间隔是否为零或负数 boolean isZero = duration.isZero(); boolean isNegative = duration.isNegative(); System.out.println(isZero); // false System.out.println(isNegative); // false // 比较两个时间间隔的大小和相等性 Duration another = Duration.ofSeconds(5); System.out.println(duration.compareTo(another)); // -1 (less than) System.out.println(duration.equals(another)); // false // 计算两个时刻之间的时间间隔，以不同时间单位表示 Instant start = Instant.parse("2017-10-03T10:15:30.00Z"); Instant end = Instant.parse("2017-10-03T10:16:30.00Z"); Duration between = Duration.between(start, end); System.out.println(between.getSeconds()); // 60 (seconds) System.out.println(between.toMillis()); // 60000 (milliseconds) System.out.println(between.toNanos()); // 60000000000 (nanoseconds) // 修改时刻的某些字段，返回一个新的时刻对象 Duration newDuration = duration.withSeconds(5).withNanos(500); System.out.println(newDuration); // PT4M5.000000500S // 使用预定义或自定义的调整器修改时刻，返回一个新的时刻对象（暂无） // 加上或减去指定时间单位和数量的新时刻对象 Duration plus = duration.plus(2, ChronoUnit.SECONDS); System.out.println(plus); // PT4M5S Duration minus = duration.minus(3, ChronoUnit.MINUTES); System.out.println(minus); // PT1M3S // 乘以或除以指定因子或除数的新时刻对象 Duration multiplied = duration.multipliedBy(2); System.out.println(multiplied); // PT8M6S Duration divided = duration.dividedBy(2); System.out.println(divided); // PT2M1.5S // 返回一个正数或取反的新时刻对象 Duration abs = duration.abs(); System.out.println(abs); // PT4M3S Duration negated = duration.negated(); System.out.println(negated); // PT-4M-3S

LocalDateLocalDate是Java 8中用于表示日期的类它具有以下特点：它是不可变的，保证了线程安全性它只存储了年、月、日的信息，不包含时间和时区的信息它提供了各种方法来进行日期的操作和计算，例如加减、比较、格式化等。

下面是一些使用LocalDate类的方法和示例：1、 创建LocalDate对象：LocalDate.now(): 返回当前的日期，例如2021-06-18LocalDate.of(int year, int month, int dayOfMonth)。

: 创建指定年、月、日的日期，例如LocalDate.of(2020, 12, 31)LocalDate.parse(CharSequence text): 根据指定的字符串解析为LocalDate对象，例如

LocalDate.parse("2020-12-31")2、 获取日期信息：getYear(): 获取年份，例如2020getMonthValue(): 获取月份，返回值为1到12之间的整数，例如12

getMonth(): 获取月份，返回值为Month枚举类型，例如Month.DECEMBERgetDayOfMonth(): 获取月份中的天数，例如31getDayOfWeek(): 获取星期几，返回值为。

DayOfWeek枚举类型，例如DayOfWeek.THURSDAYgetDayOfYear(): 获取一年中的第几天，例如3663、 比较和判断：isBefore(LocalDate otherDate)。

: 判断当前日期是否在另一个日期之前，返回布尔值isAfter(LocalDate otherDate): 判断当前日期是否在另一个日期之后，返回布尔值isEqual(LocalDate otherDate)。

: 判断两个日期是否相等，返回布尔值4、 运算和调整：plusDays(long daysToAdd): 在当前日期上增加指定的天数，返回一个新的LocalDate对象minusDays(long daysToSubtract)。

: 在当前日期上减去指定的天数，返回一个新的LocalDate对象plusWeeks(long weeksToAdd): 在当前日期上增加指定的周数，返回一个新的LocalDate对象minusWeeks(long weeksToSubtract)。

: 在当前日期上减去指定的周数，返回一个新的LocalDate对象plusMonths(long monthsToAdd): 在当前日期上增加指定的月数，返回一个新的LocalDate对象minusMonths(long monthsToSubtract)。

: 在当前日期上减去指定的月数，返回一个新的LocalDate对象plusYears(long yearsToAdd): 在当前日期上增加指定的年数，返回一个新的LocalDate对象minusYears(long yearsToSubtract)。

: 在当前日期上减去指定的年数，返回一个新的LocalDate对象5、 转换为其他时间表示：atStartOfDay(): 将LocalDate转换为LocalDateTime，时间部分设置为午夜开始，例如。

2020-12-31T00:00:00.000000000ZtoEpochDay(): 获取从1970年1月1日开始的天数，例如18627LtoString(): 返回LocalDate对象的字符串表示形式，例如。

2020-12-31以上是LocalDate类中常用方法的介绍和示例通过这些方法，可以方便地创建、操作和比较日期，并计算日期之间的差距和调整还有许多其他有用的方法，例如处理闰年、格式化日期、计算日期范围等。

下面是一些使用LocalDate类的示例：// 获取当前日期 LocalDate today = LocalDate.now(); System.out.println(today); // 2021-10-15 // 从年月日创建日期 LocalDate date = LocalDate.of(2020, 2, 29); System.out.println(date); // 2020-02-29 // 从字符串解析日期 LocalDate parsed = LocalDate.parse("2020-02-29"); System.out.println(parsed); // 2020-02-29 // 获取年月日星期等信息 int year = date.getYear(); Month month = date.getMonth(); int monthValue = date.getMonthValue(); int dayOfMonth = date.getDayOfMonth(); DayOfWeek dayOfWeek = date.getDayOfWeek(); int dayOfYear = date.getDayOfYear(); System.out.println(year); // 2020 System.out.println(month); // FEBRUARY System.out.println(monthValue); // 2 System.out.println(dayOfMonth); // 29 System.out.println(dayOfWeek); // SATURDAY System.out.println(dayOfYear); // 60 // 判断是否为闰年和当月或当年的天数 boolean isLeapYear = date.isLeapYear(); int lengthOfMonth = date.lengthOfMonth(); int lengthOfYear = date.lengthOfYear(); System.out.println(isLeapYear); // true System.out.println(lengthOfMonth); // 29 System.out.println(lengthOfYear); // 366 // 比较两个日期的先后顺序和相等性 LocalDate another = LocalDate.of(2021, 10, 15); System.out.println(date.isAfter(another)); // false System.out.println(date.isBefore(another)); // true System.out.println(date.compareTo(another)); // -1 (less than) System.out.println(date.equals(another)); // false

LocalTimeLocalTime是Java 8中用于表示时间的类它具有以下特点：它是不可变的，保证了线程安全性它只存储了时、分、秒以及纳秒的信息，不包含日期和时区的信息它提供了各种方法来进行时间的操作和计算，例如加减、比较、格式化等。

下面是一些使用LocalTime类的方法和示例：1、 创建LocalTime对象：LocalTime.now(): 返回当前的时间，例如10:23:09.123456789LocalTime.of(int hour, int minute)。

: 创建指定时和分的时间，例如LocalTime.of(23, 59)LocalTime.of(int hour, int minute, int second): 创建指定时、分、秒的时间，例如LocalTime.of(23, 59, 59)。

LocalTime.of(int hour, int minute, int second, int nanoOfSecond): 创建指定时、分、秒、纳秒的时间，例如LocalTime.of(23, 59, 59, 999999999)。

LocalTime.parse(CharSequence text): 根据指定的字符串解析为LocalTime对象，例如LocalTime.parse("23:59:59.999999999")2、 获取时间信息：

getHour(): 获取小时部分，例如23getMinute(): 获取分钟部分，例如59getSecond(): 获取秒部分，例如59getNano(): 获取纳秒部分，例如9999999993、 比较和判断：。

isBefore(LocalTime otherTime): 判断当前时间是否在另一个时间之前，返回布尔值isAfter(LocalTime otherTime): 判断当前时间是否在另一个时间之后，返回布尔值。

isEqual(LocalTime otherTime): 判断两个时间是否相等，返回布尔值4、 运算和调整：plusHours(long hoursToAdd): 在当前时间上增加指定的小时数，返回一个新的LocalTime对象。

minusHours(long hoursToSubtract): 在当前时间上减去指定的小时数，返回一个新的LocalTime对象plusMinutes(long minutesToAdd): 在当前时间上增加指定的分钟数，返回一个新的LocalTime对象。

minusMinutes(long minutesToSubtract): 在当前时间上减去指定的分钟数，返回一个新的LocalTime对象plusSeconds(long secondsToAdd): 在当前时间上增加指定的秒数，返回一个新的LocalTime对象。

minusSeconds(long secondsToSubtract): 在当前时间上减去指定的秒数，返回一个新的LocalTime对象plusNanos(long nanosToAdd): 在当前时间上增加指定的纳秒数，返回一个新的LocalTime对象。

minusNanos(long nanosToSubtract): 在当前时间上减去指定的纳秒数，返回一个新的LocalTime对象5、 转换为其他时间表示：atDate(LocalDate date)。

: 将LocalTime与指定的LocalDate组合成LocalDateTime对象，例如2020-12-31T23:59:59.999999999ZtoString(): 返回LocalTime对象的字符串表示形式，例如

23:59:59.999999999Z以上是LocalTime类中常用方法的介绍和示例通过这些方法，可以方便地创建、操作和比较时间，并计算时间之间的差距和调整还有许多其他有用的方法，例如格式化时间、获取时间范围等。

下面是一些使用LocalTime类的示例： // 获取当前时间 LocalTime now = LocalTime.now(); System.out.println(now); // 16:38:43.123456789 // 从时分秒纳秒创建时间 LocalTime time = LocalTime.of(10, 15, 30, 500); System.out.println(time); // 10:15:30.000000500 // 从字符串解析时间 LocalTime parsed = LocalTime.parse("10:15:30"); System.out.println(parsed); // 10:15:30 // 获取时分秒纳秒等信息 int hour = time.getHour(); int minute = time.getMinute(); int second = time.getSecond(); int nano = time.getNano(); System.out.println(hour); // 10 System.out.println(minute); // 15 System.out.println(second); // 30 System.out.println(nano); // 500 // 比较两个时间的先后顺序和相等性 LocalTime another = LocalTime.of(16, 38, 43); System.out.println(time.isAfter(another)); // false System.out.println(time.isBefore(another)); // true System.out.println(time.compareTo(another)); // -1 (less than) System.out.println(time.equals(another)); // false

LocalDateTimeLocalDateTime是Java 8中用于表示日期和时间的类，它结合了LocalDate和LocalTime的功能它具有以下特点：它是不可变的，保证了线程安全性它存储了年、月、日、时、分、秒以及纳秒的信息，并提供了各种方法来进行日期和时间的操作和计算。

它不包含时区的信息，表示的是一个本地的日期和时间下面是一些使用LocalDateTime类的方法和示例：1、 创建LocalDateTime对象：LocalDateTime.now(): 返回当前的日期和时间，例如。

2021-06-18T10:23:09.123456789LocalDateTime.of(int year, int month, int dayOfMonth, int hour, int minute)。

: 创建指定年、月、日、时、分的日期和时间，例如LocalDateTime.of(2020, 12, 31, 23, 59)LocalDateTime.of(int year, int month, int dayOfMonth, int hour, int minute, int second)。

: 创建指定年、月、日、时、分、秒的日期和时间，例如LocalDateTime.of(2020, 12, 31, 23, 59, 59)LocalDateTime.of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond)。

: 创建指定年、月、日、时、分、秒、纳秒的日期和时间，例如LocalDateTime.of(2020, 12, 31, 23, 59, 59, 999999999)LocalDateTime.parse(CharSequence text)。

: 根据指定的字符串解析为LocalDateTime对象，例如LocalDateTime.parse("2020-12-31T23:59:59.999999999")2、 获取日期和时间信息：getYear()。

: 获取年份，例如2020getMonthValue(): 获取月份，返回值为1到12之间的整数，例如12getMonth(): 获取月份，返回值为Month枚举类型，例如Month.DECEMBERgetDayOfMonth()

: 获取月份中的天数，例如31getDayOfWeek(): 获取星期几，返回值为DayOfWeek枚举类型，例如DayOfWeek.THURSDAYgetHour(): 获取小时部分，例如23getMinute()

: 获取分钟部分，例如59getSecond(): 获取秒部分，例如59getNano(): 获取纳秒部分，例如9999999993、 比较和判断：isBefore(LocalDateTime otherDateTime)。

: 判断当前日期和时间是否在另一个日期和时间之前，返回布尔值isAfter(LocalDateTime otherDateTime): 判断当前日期和时间是否在另一个日期和时间之后，返回布尔值isEqual(LocalDateTime otherDateTime)。

: 判断两个日期和时间是否相等，返回布尔值4、 运算和调整：plusYears(long yearsToAdd): 在当前日期和时间上增加指定的年数，返回一个新的LocalDateTime对象minusYears(long yearsToSubtract)。

: 在当前日期和时间上减去指定的年数，返回一个新的LocalDateTime对象plusMonths(long monthsToAdd): 在当前日期和时间上增加指定的月数，返回一个新的LocalDateTime对象。

minusMonths(long monthsToSubtract): 在当前日期和时间上减去指定的月数，返回一个新的LocalDateTime对象plusDays(long daysToAdd): 在当前日期和时间上增加指定的天数，返回一个新的LocalDateTime对象。

minusDays(long daysToSubtract): 在当前日期和时间上减去指定的天数，返回一个新的LocalDateTime对象plusHours(long hoursToAdd): 在当前日期和时间上增加指定的小时数，返回一个新的LocalDateTime对象。

minusHours(long hoursToSubtract): 在当前日期和时间上减去指定的小时数，返回一个新的LocalDateTime对象plusMinutes(long minutesToAdd)。

: 在当前日期和时间上增加指定的分钟数，返回一个新的LocalDateTime对象minusMinutes(long minutesToSubtract): 在当前日期和时间上减去指定的分钟数，返回一个新的LocalDateTime对象。

plusSeconds(long secondsToAdd): 在当前日期和时间上增加指定的秒数，返回一个新的LocalDateTime对象minusSeconds(long secondsToSubtract)。

: 在当前日期和时间上减去指定的秒数，返回一个新的LocalDateTime对象plusNanos(long nanosToAdd): 在当前日期和时间上增加指定的纳秒数，返回一个新的LocalDateTime对象。

minusNanos(long nanosToSubtract): 在当前日期和时间上减去指定的纳秒数，返回一个新的LocalDateTime对象5、 转换为其他时间表示：toLocalDate(): 获取日期部分，返回

LocalDate对象，例如2020-12-31toLocalTime(): 获取时间部分，返回LocalTime对象，例如23:59:59.999999999toString(): 返回LocalDateTime。

对象的字符串表示形式，例如2020-12-31T23:59:59.999999999以上是LocalDateTime类中常用方法的介绍和示例通过这些方法，可以方便地创建、操作和比较日期和时间，并计算它们之间的差距和调整。

还有许多其他有用的方法，例如格式化日期和时间、处理时区等下面是一些使用LocalDateTime类的示例： // 获取当前日期时间 LocalDateTime now = LocalDateTime.now(); System.out.println(now); // 2021-10-15T16:38:43.123456789 // 从年月日时分秒纳秒创建日期时间 LocalDateTime dateTime = LocalDateTime.of(2020, 2, 29, 10, 15, 30, 500); System.out.println(dateTime); // 2020-02-29T10:15:30.000000500 // 从字符串解析日期时间 LocalDateTime parsed = LocalDateTime.parse("2020-02-29T10:15:30"); System.out.println(parsed); // 2020-02-29T10:15:30

PeriodPeriod是Java 8中用于表示日期间隔的类它具有以下特点：它是不可变的，保证了线程安全性它只存储了年、月、日的信息，不包含时间和时区的信息它可以用来计算两个日期之间的差距，例如天数、月数和年数。

下面是一些使用Period类的方法和示例：1、 创建Period对象：Period.ofYears(int years): 创建指定年数的Period对象，例如Period.ofYears(3)Period.ofMonths(int months)。

: 创建指定月数的Period对象，例如Period.ofMonths(6)Period.ofWeeks(int weeks): 创建指定周数的Period对象，等价于以7天为单位创建Period对象，例如。

Period.ofWeeks(2)Period.ofDays(int days): 创建指定天数的Period对象，例如Period.ofDays(10)Period.between(LocalDate startDateInclusive, LocalDate endDateExclusive)。

: 根据开始日期和结束日期创建Period对象，例如Period.between(LocalDate.of(2020, 1, 1), LocalDate.of(2021, 1, 1))2、 获取日期间隔信息：。

getYears(): 获取年数，例如3getMonths(): 获取月数，例如6getDays(): 获取天数，例如10toTotalMonths(): 获取总月数，将年数乘以12并加上月数，例如42L

3、 运算和调整：plusYears(long yearsToAdd): 在当前日期间隔上增加指定的年数，返回一个新的Period对象minusYears(long yearsToSubtract): 在当前日期间隔上减去指定的年数，返回一个新的Period对象。

plusMonths(long monthsToAdd): 在当前日期间隔上增加指定的月数，返回一个新的Period对象minusMonths(long monthsToSubtract): 在当前日期间隔上减去指定的月数，返回一个新的Period对象。

plusDays(long daysToAdd): 在当前日期间隔上增加指定的天数，返回一个新的Period对象minusDays(long daysToSubtract): 在当前日期间隔上减去指定的天数，返回一个新的Period对象。

4、 比较和判断：isZero(): 判断日期间隔是否为零，即年、月、日都为0，返回布尔值isNegative(): 判断日期间隔是否为负值，即至少有一个部分为负值，返回布尔值以上是Period类中常用方法的介绍和示例。

通过这些方法，可以创建、操作和比较日期间隔，并计算两个日期之间的差距还有许多其他有用的方法，例如格式化日期间隔、将日期间隔与日期进行调整等下面是一些使用Period类的示例：// 获取两个日期之间的时间量 LocalDate startDate = LocalDate.of(2020, 1, 1); LocalDate endDate = LocalDate.of(2021, 10, 15); Period period = Period.between(startDate, endDate); System.out.println(period); // P1Y9M14D // 从字符串解析时间量 Period parsed = Period.parse("P1Y9M14D"); System.out.println(parsed); // P1Y9M14D // 获取年月日等信息 int years = period.getYears(); int months = period.getMonths(); int days = period.getDays(); System.out.println(years); // 1 System.out.println(months); // 9 System.out.println(days); // 14 // 创建一个5年4个月3天的天数间隔 Period period = Period.of(5, 4, 3); // 从字符串解析天数间隔 Period parsed = Period.parse("P5Y4M3D"); // 获取天数间隔的年月日信息 int years = period.getYears(); int months = period.getMonths(); int days = period.getDays(); // 判断天数间隔是否为零或负数 boolean isZero = period.isZero(); boolean isNegative = period.isNegative(); // 计算两个日期之间的天数间隔 Period between = Period.between(date1, date2); // 修改天数间隔的某些字段，返回一个新的天数间隔对象 Period newPeriod = period.withYears(6).withMonths(5).withDays(4);

ZoneOffset在Java 8中，ZoneOffset是一个用于表示时区偏移量的类它表示相对于UTC（协调世界时）的偏移量，以小时和分钟为单位ZoneOffset类提供了各种方法来创建、操作和比较时区偏移量。

下面是对ZoneOffset的介绍以及一些常用方法的说明：1、 创建ZoneOffset对象：ZoneOffset.ofTotalSeconds(int totalSeconds): 根据总秒数创建ZoneOffset

对象ZoneOffset.ofHours(int hours): 根据小时数创建ZoneOffset对象ZoneOffset.ofHoursMinutes(int hours, int minutes)。

: 根据小时数和分钟数创建ZoneOffset对象ZoneOffset.UTC: 表示UTC（协调世界时）的时区偏移量2、 获取时区偏移信息：getTotalSeconds(): 获取总秒数，包括小时和分钟的偏移量。

getRules(): 获取适用于此偏移量的规则，返回ZoneRules对象3、 比较和判断：equals(Object obj): 判断与另一个对象是否相等compareTo(ZoneOffset other)。

: 将此偏移量与另一个偏移量进行比较4、 调整时间：getOffset(LocalDateTime dateTime): 获取指定日期和时间的偏移量getOffset(LocalDateTime localDateTime, ZoneRules rules)。

: 获取指定日期和时间以及规则的偏移量adjustInto(Temporal temporal): 将此偏移量调整到指定的Temporal对象5、 转换和格式化：toString(): 返回ZoneOffset。

对象的字符串表示形式这些是ZoneOffset类中的一些常用方法使用这些方法，可以创建、操作和比较时区偏移量，以及将其应用于日期和时间对象ZoneOffset类还提供了其他一些有用的方法，例如获取常用的时区偏移量常量、将时区偏移量与时区ID进行转换等。

下面是一些使用ZoneOffset类的示例： // 从字符串创建偏移量 ZoneOffset offset = ZoneOffset.of("+02:00"); System.out.println(offset); // +02:00 // 从小时数、分钟数和秒数创建偏移量 ZoneOffset offset2 = ZoneOffset.ofHoursMinutesSeconds(1, 30, 45); System.out.println(offset2); // +01:30:45 // 获取偏移量的标准化ID和总秒数 String id = offset.getId(); int totalSeconds = offset.getTotalSeconds(); System.out.println(id); // +02:00 System.out.println(totalSeconds); // 7200

ZonedDateTime在Java 8中，ZonedDateTime是一个用于表示带有时区信息的日期和时间的类它结合了LocalDateTime和ZoneId，用于表示一个特定时区的完整日期和时间ZonedDateTime

提供了各种方法来创建、操作和比较带有时区信息的日期和时间下面是对ZonedDateTime的介绍以及一些常用方法的说明：1、 创建ZonedDateTime对象：ZonedDateTime.now(): 返回当前的日期和时间，使用系统默认时区。

ZonedDateTime.now(ZoneId zone): 返回当前的日期和时间，使用指定的时区ZonedDateTime.of(LocalDateTime localDateTime, ZoneId zone)。

: 创建指定的LocalDateTime和时区的ZonedDateTime对象ZonedDateTime.of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneId zone)。

: 创建指定年、月、日、时、分、秒、纳秒和时区的ZonedDateTime对象ZonedDateTime.parse(CharSequence text): 根据指定的字符串解析为ZonedDateTime。

对象2、 获取日期和时间信息：toLocalDateTime(): 获取不带时区信息的LocalDateTime对象toLocalDate(): 获取日期部分，返回LocalDate对象toLocalTime()。

: 获取时间部分，返回LocalTime对象getYear(): 获取年份getMonthValue(): 获取月份，返回值为1到12之间的整数getMonth(): 获取月份，返回值为Month枚举类型。

getDayOfMonth(): 获取月份中的天数getDayOfWeek(): 获取星期几，返回值为DayOfWeek枚举类型getHour(): 获取小时部分getMinute(): 获取分钟部分getSecond()

: 获取秒部分getNano(): 获取纳秒部分3、 获取时区信息：getZone(): 获取时区，返回ZoneId对象getOffset(): 获取与UTC的偏移量，返回ZoneOffset对象4、 比较和判断：

isBefore(ZonedDateTime otherDateTime): 判断当前日期和时间是否在另一个日期和时间之前isAfter(ZonedDateTime otherDateTime): 判断当前日期和时间是否在另一个日期和时间之后。

isEqual(ZonedDateTime otherDateTime): 判断两个日期和时间是否相等5、 运算和调整：plusYears(long yearsToAdd): 在当前日期和时间上增加指定的年数。

minusYears(long yearsToSubtract): 在当前日期和时间上减去指定的年数plusMonths(long monthsToAdd): 在当前日期和时间上增加指定的月数minusMonths(long monthsToSubtract)。

: 在当前日期和时间上减去指定的月数plusDays(long daysToAdd):在当前日期和时间上增加指定的天数minusDays(long daysToSubtract): 在当前日期和时间上减去指定的天数。

plusHours(long hoursToAdd): 在当前日期和时间上增加指定的小时数minusHours(long hoursToSubtract): 在当前日期和时间上减去指定的小时数plusMinutes(long minutesToAdd)。

: 在当前日期和时间上增加指定的分钟数minusMinutes(long minutesToSubtract): 在当前日期和时间上减去指定的分钟数plusSeconds(long secondsToAdd)。

: 在当前日期和时间上增加指定的秒数minusSeconds(long secondsToSubtract): 在当前日期和时间上减去指定的秒数plusNanos(long nanosToAdd): 在当前日期和时间上增加指定的纳秒数。

minusNanos(long nanosToSubtract): 在当前日期和时间上减去指定的纳秒数这些是ZonedDateTime类中的一些常用方法使用这些方法，可以创建、操作和比较带有时区信息的日期和时间，以及进行日期和时间的运算和调整。

ZonedDateTime类还提供了其他一些有用的方法，例如格式化日期和时间、获取支持的时区列表等下面是一些使用ZonedDateTime类的示例：// 获取当前日期和时间，以及系统默认的时区 ZonedDateTime now = ZonedDateTime.now(); // 从年月日时分秒纳秒和时区创建日期和时间 ZonedDateTime dateTime = ZonedDateTime.of(2021, 1, 15, 10, 15, 30, 500, ZoneId.of("Asia/Shanghai")); // 从字符串解析日期和时间 ZonedDateTime parsed = ZonedDateTime.parse("2021-01-15T10:15:30+08:00[Asia/Shanghai]"); // 获取日期和时间的年月日时分秒纳秒信息，方法同上述类似，不再赘述。

... // 获取日期和时间的时区信息 ZoneId zone = dateTime.getZone(); ZoneOffset offset = dateTime.getOffset(); // 比较两个日期和时间 int compare = now.compareTo(dateTime); // 计算两个日期和时间之间的时间间隔，方法同上述类似，不再赘述。

... // 修改日期和时间的某些字段，返回一个新的日期和时间对象，方法同上述类似，不再赘述 ... // 转换日期和时间到另一个时区，返回一个新的日期和时间对象 ZonedDateTime converted = dateTime.withZoneSameInstant(ZoneId.of("Europe/Paris"));。

Clock在Java 8中，Clock是一个用于提供当前时间和日期的类它是用于获取当前时间的抽象类，可以根据不同的时区和精度创建不同类型的Clock实例Clock类提供了各种方法来获取当前时间和日期，并支持时区的操作。

下面是对Clock的介绍以及一些常用方法的说明：1、 创建Clock对象：Clock.systemDefaultZone(): 创建使用系统默认时区的Clock对象Clock.systemUTC(): 创建使用UTC（协调世界时）时区的

Clock对象Clock.system(ZoneId zone): 创建使用指定时区的Clock对象Clock.fixed(Instant fixedInstant, ZoneId zone): 创建一个固定的时钟，它始终返回指定的固定时间。

2、 获取当前时间和日期：instant(): 获取当前的Instant对象，表示从1970年1月1日开始计算的时间戳millis(): 获取当前时间的毫秒数getZone(): 获取时区，返回ZoneId。

对象withZone(ZoneId zone): 返回一个新的Clock对象，使用指定的时区3、 判断和比较：equals(Object obj): 判断与另一个对象是否相等hashCode(): 返回哈希码值。

4、 其他方法：tick(Clock baseClock, Duration tickDuration): 创建一个基于给定Clock的新Clock，每经过指定的持续时间就会递增offset(Clock baseClock, Duration offsetDuration)。

: 创建一个基于给定Clock的新Clock，通过添加指定的持续时间来偏移时间这些是Clock类中的一些常用方法使用这些方法，可以获取当前的时间和日期，切换不同的时区，以及进行时间的比较和操作Clock。

类还提供了其他一些有用的方法，例如获取支持的时区列表、创建固定时间的Instant对象等下面是一些使用Clock类的示例：// 获取系统默认时区的当前日期和时间 Clock clock = Clock.systemDefaultZone(); Instant instant = clock.instant(); // 获取当前时刻 long millis = clock.millis(); // 获取当前毫秒数 LocalDateTime dateTime = LocalDateTime.now(clock); // 获取当前日期和时间 // 获取指定时区的当前日期和时间 Clock anotherClock = Clock.system(ZoneId.of("Europe/Paris")); Instant anotherInstant = anotherClock.instant(); // 获取当前时刻 long anotherMillis = anotherClock.millis(); // 获取当前毫秒数 LocalDateTime anotherDateTime = LocalDateTime.now(anotherClock); // 获取当前日期和时间 // 获取固定的日期和时间，用于测试或模拟场景 Clock fixedClock = Clock.fixed(instant, ZoneId.of("Asia/Shanghai")); Instant fixedInstant = fixedClock.instant(); // 返回固定的时刻 long fixedMillis = fixedClock.millis(); // 返回固定的毫秒数 LocalDateTime fixedDateTime = LocalDateTime.now(fixedClock); // 返回固定的日期和时间 。

DateTimeFormatterDateTimeFormatter是Java 8中用于格式化和解析日期时间对象的类它具有以下特点：它是不可变的，保证了线程安全性它提供了各种方法来定义日期时间的格式，以及将字符串解析为日期时间对象。

它使用预定义的模式或自定义模式来进行格式化和解析操作，支持本地化和时区下面是一些使用DateTimeFormatter类的方法和示例：1、 创建DateTimeFormatter对象：ofPattern(String pattern)。

: 使用指定的模式字符串创建DateTimeFormatter对象，例如DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")2、 格式化日期时间：format(TemporalAccessor temporal)。

: 将日期时间对象格式化为字符串，例如formatter.format(LocalDateTime.now())3、 解析字符串为日期时间：parse(CharSequence text): 将字符串解析为日期时间对象，例如。

formatter.parse("2020-12-31 23:59:59")4、 定义模式：ofLocalizedDate(FormatStyle dateStyle): 创建使用本地化日期格式的DateTimeFormatter。

对象，例如DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)ofLocalizedTime(FormatStyle timeStyle): 创建使用本地化时间格式的。

DateTimeFormatter对象，例如DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)ofLocalizedDateTime(FormatStyle dateTimeStyle)。

: 创建使用本地化日期时间格式的DateTimeFormatter对象，例如DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM)withLocale(Locale locale)。

: 设置用于本地化的Locale，例如formatter.withLocale(Locale.CHINA)5、 模式符号：y: 年份，例如2020M: 月份，例如12或者Decemberd: 日期，例如。

31H: 小时（24小时制），例如23h: 小时（12小时制），例如11m: 分钟，例如59s: 秒，例如59S: 毫秒，例如999999999.E: 星期几，例如Thursday.L: 月份，例如12

.a: 上午/下午标记，例如PM.z: 时区偏移量，例如+08:00.6、 格式化和解析选项：withResolverStyle(ResolverStyle resolverStyle): 设置解析器样式，指定如何处理日期时间字符串中的非法或缺失字段。

有三种样式可选：严格（STRICT）、智能（SMART）和宽松（LENIENT）以上是DateTimeFormatter类中常用方法的介绍和示例通过这些方法，可以创建自定义的日期时间格式，将日期时间对象格式化为字符串，以及将字符串解析为日期时间对象。

还有许多其他有用的方法，例如使用预定义的格式、设置时区等下面是一些使用DateTimeFormatter类的示例：// 使用预定义的标准格式 DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME; // 格式化日期和时间对象为字符串 String formatted = formatter.format(LocalDateTime.now()); // 解析字符串为日期和时间对象 LocalDateTime parsed = LocalDateTime.parse("2021-01-15T10:15:30", formatter); // 使用自定义的模式 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"); // 格式化日期和时间对象为字符串 String formatted = formatter.format(LocalDateTime.now()); // 解析字符串为日期和时间对象 LocalDateTime parsed = LocalDateTime.parse("2021/01/15 10:15:30", formatter); // 使用与语言环境相关的格式 DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM).withLocale(Locale.CHINA); // 格式化日期和时间对象为字符串 String formatted = formatter.format(LocalDateTime.now()); // 解析字符串为日期和时间对象 LocalDateTime parsed = LocalDateTime.parse("2021-1-15 10:15:30", formatter);