Module java.base
Package java.time

Class LocalDateTime

java.lang.Object
java.time.LocalDateTime
所有已实现的接口:
Serializable, Comparable<ChronoLocalDateTime<?>>, ChronoLocalDateTime<LocalDate>, Temporal, TemporalAccessor, TemporalAdjuster
public final class LocalDateTime extends Object implements Temporal, TemporalAdjuster, ChronoLocalDateTime<LocalDate>, Serializable
一个不带时区的ISO-8601日历系统中的日期时间，例如2007-12-03T10:15:30。

LocalDateTime是一个不可变的日期时间对象，表示一个日期时间，通常被视为年-月-日-时-分-秒。其他日期和时间字段，如年中的第几天、星期几和年中的第几周，也可以被访问。时间精确到纳秒。例如，值"2007年10月2日13:45:30.123456789"可以存储在LocalDateTime中。

这个类不存储或表示时区。相反，它是日期的描述，就像生日一样，结合上墙时钟上看到的当地时间。它不能表示时间线上的一个瞬间，除非有额外的信息，如偏移量或时区。

ISO-8601日历系统是当今世界大部分地区使用的现代公民日历系统。它等同于推算的格里高利日历系统，其中适用于所有时间的今天的闰年规则。对于今天编写的大多数应用程序，ISO-8601规则完全合适。然而，任何使用历史日期并要求它们准确的应用程序将发现ISO-8601方法不合适。

这是一个基于值的类；程序员应该将相等的实例视为可互换的，不应该将实例用于同步，否则可能会发生不可预测的行为。例如，在将来的版本中，同步可能会失败。应该使用equals方法进行比较。

实现要求:
这个类是不可变的且线程安全的。
自从:
1.8
参见:

  • Field Details

    • MIN

      public static final LocalDateTime MIN
      支持的最小LocalDateTime，'-999999999-01-01T00:00:00'。这是最小日期开始时刻的本地日期时间。这结合了LocalDate.MIN和LocalTime.MIN。应用程序可以将其用作“遥远过去”的日期时间。

    • MAX

      public static final LocalDateTime MAX
      最大支持的LocalDateTime为'+999999999-12-31T23:59:59.999999999'。这是在最大日期结束之前的本地日期时间。它结合了LocalDate.MAX和LocalTime.MAX。这可以被应用程序用作“遥远的未来”日期时间。

  • Method Details

    • now

      public static LocalDateTime now()
      从系统时钟中获取默认时区的当前日期时间。

      这将查询默认时区中的系统时钟以获取当前日期时间。

      使用此方法将阻止使用替代时钟进行测试，因为时钟是硬编码的。

      返回:
      使用系统时钟和默认时区的当前日期时间，不为null

    • now

      public static LocalDateTime now(ZoneId zone)
      从指定时区的系统时钟获取当前日期时间。

      这将查询系统时钟以获取当前日期时间。指定时区避免了对默认时区的依赖。

      使用此方法将阻止使用替代时钟进行测试，因为时钟是硬编码的。

      参数:
      zone - 要使用的区域ID，不为null
      返回:
      使用系统时钟的当前日期时间，不为null

    • now

      public static LocalDateTime now(Clock clock)
      从指定时钟获取当前日期时间。

      这将查询指定的时钟以获取当前日期时间。使用此方法允许用于测试的替代时钟。可以使用依赖注入引入替代时钟。

      参数:
      clock - 要使用的时钟，不为null
      返回:
      当前日期时间，不为null

    • of

      public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute)
      从年、月、日、小时和分钟获取LocalDateTime的实例，将秒和纳秒设置为零。

      返回具有指定年、月、日、小时和分钟的LocalDateTime。日期必须对该年和月有效，否则将抛出异常。秒和纳秒字段将被设置为零。

      参数:
      year - 要表示的年份，从MIN_YEAR到MAX_YEAR
      month - 要表示的年份的月份，不为null
      dayOfMonth - 要表示的月份的日期，从1到31
      hour - 要表示的小时，从0到23
      minute - 要表示的小时的分钟，从0到59
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果任何字段的值超出范围，或者日期的日期对于该月份的年份无效

    • of

      public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second)
      从年、月、日、小时、分钟和秒获取LocalDateTime的实例，将纳秒设置为零。

      返回具有指定年、月、日、小时、分钟和秒的LocalDateTime。日期必须对该年和月有效，否则将抛出异常。纳秒字段将被设置为零。

      参数:
      year - 要表示的年份，从MIN_YEAR到MAX_YEAR
      month - 要表示的年份的月份，不为null
      dayOfMonth - 要表示的月份的日期，从1到31
      hour - 要表示的小时，从0到23
      minute - 要表示的小时的分钟，从0到59
      second - 要表示的分钟的秒，从0到59
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果任何字段的值超出范围，或者日期的日期对于该月份的年份无效

    • of

      public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond)
      从年、月、日、小时、分钟、秒和纳秒获取LocalDateTime的实例。

      返回具有指定年、月、日、小时、分钟、秒和纳秒的LocalDateTime。日期必须对该年和月有效，否则将抛出异常。

      参数:
      year - 要表示的年份，从MIN_YEAR到MAX_YEAR
      month - 要表示的年份的月份，不为null
      dayOfMonth - 要表示的月份的日期，从1到31
      hour - 要表示的小时，从0到23
      minute - 要表示的小时的分钟，从0到59
      second - 要表示的分钟的秒，从0到59
      nanoOfSecond - 要表示的秒的纳秒，从0到999,999,999
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果任何字段的值超出范围，或者日期的日期对于该月份的年份无效

    • of

      public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute)
      从年、月、日、小时和分钟获取LocalDateTime的实例，将秒和纳秒设置为零。

      返回具有指定年、月、日、小时和分钟的LocalDateTime。日期必须对该年和月有效，否则将抛出异常。秒和纳秒字段将被设置为零。

      参数:
      year - 要表示的年份，从MIN_YEAR到MAX_YEAR
      month - 要表示的年份的月份，从1（一月）到12（十二月）
      dayOfMonth - 要表示的月份的日期，从1到31
      hour - 要表示的小时，从0到23
      minute - 要表示的小时的分钟，从0到59
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果任何字段的值超出范围，或者日期的日期对于该月份的年份无效

    • of

      public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)
      从年、月、日、小时、分钟和秒获取LocalDateTime的实例，将纳秒设置为零。

      返回具有指定年、月、日、小时、分钟和秒的LocalDateTime。日期必须对该年和月有效，否则将抛出异常。纳秒字段将被设置为零。

      参数:
      year - 要表示的年份，从MIN_YEAR到MAX_YEAR
      month - 要表示的年份的月份，从1（一月）到12（十二月）
      dayOfMonth - 要表示的月份的日期，从1到31
      hour - 要表示的小时，从0到23
      minute - 要表示的小时的分钟，从0到59
      second - 要表示的分钟的秒，从0到59
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果任何字段的值超出范围，或者日期的日期对于该月份的年份无效

    • of

      public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond)
      从年、月、日、小时、分钟、秒和纳秒获取LocalDateTime的实例。

      返回具有指定年、月、日、小时、分钟、秒和纳秒的LocalDateTime。日期必须对该年和月有效，否则将抛出异常。

      参数:
      year - 要表示的年份，从MIN_YEAR到MAX_YEAR
      month - 要表示的年份的月份，从1（一月）到12（十二月）
      dayOfMonth - 要表示的月份的日期，从1到31
      hour - 要表示的小时，从0到23
      minute - 要表示的小时的分钟，从0到59
      second - 要表示的分钟的秒，从0到59
      nanoOfSecond - 要表示的秒的纳秒，从0到999,999,999
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果任何字段的值超出范围，或者日期的日期对于该月份的年份无效

    • of

      public static LocalDateTime of(LocalDate date, LocalTime time)
      从日期和时间获取LocalDateTime的实例。
      参数:
      date - 本地日期，不为null
      time - 本地时间，不为null
      返回:
      本地日期时间，不为null

    • ofInstant

      public static LocalDateTime ofInstant(Instant instant, ZoneId zone)
      从Instant和区域ID获取LocalDateTime的实例。

      基于指定的即时创建本地日期时间。首先，使用区域ID和即时获取与UTC/Greenwich的偏移量，这很简单，因为每个即时只有一个有效的偏移量。然后，使用即时和偏移量计算本地日期时间。

      参数:
      instant - 创建日期时间的即时，不为null
      zone - 时区，可以是偏移量，不为null
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果结果超出支持范围

    • ofEpochSecond

      public static LocalDateTime ofEpochSecond(long epochSecond, int nanoOfSecond, ZoneOffset offset)
      使用从1970-01-01T00:00:00Z的时代开始的秒数获取LocalDateTime的实例。

      这允许将epoch-second字段转换为本地日期时间。这主要用于低级别转换，而不是一般应用程序使用。

      参数:
      epochSecond - 从1970-01-01T00:00:00Z的时代开始的秒数
      nanoOfSecond - 秒内的纳秒，从0到999,999,999
      offset - 时区偏移，不为null
      返回:
      本地日期时间，不为null
      抛出:
      DateTimeException - 如果结果超出支持范围，或者纳秒无效

    • from

      public static LocalDateTime from(TemporalAccessor temporal)
      从时间对象获取LocalDateTime的实例。

      根据指定的时间对象获取本地日期时间。 TemporalAccessor表示一组任意的日期和时间信息，该工厂将其转换为LocalDateTime的实例。

      转换从时间对象中提取并组合LocalDate和LocalTime。实现允许执行优化，例如访问等效于相关对象的字段。

      此方法与函数接口TemporalQuery的签名匹配，允许通过方法引用LocalDateTime::from来使用它作为查询。

      参数：
      temporal - 要转换的时间对象，不能为空
      返回：
      本地日期时间，不能为空
      抛出：
      DateTimeException - 如果无法转换为LocalDateTime

    • parse

      public static LocalDateTime parse(CharSequence text)
      从文本字符串（如2007-12-03T10:15:30）获取LocalDateTime的实例。

      字符串必须表示有效的日期时间，并使用DateTimeFormatter.ISO_LOCAL_DATE_TIME进行解析。

      参数：
      text - 要解析的文本，例如"2007-12-03T10:15:30"，不能为空
      返回：
      解析后的本地日期时间，不能为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • parse

      public static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter)
      使用特定格式化程序从文本字符串获取LocalDateTime的实例。

      使用格式化程序解析文本，返回一个日期时间。

      参数：
      text - 要解析的文本，不能为空
      formatter - 要使用的格式化程序，不能为空
      返回：
      解析后的本地日期时间，不能为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • isSupported

      public boolean isSupported(TemporalField field)
      检查是否支持指定字段。

      检查此日期时间是否可以查询指定字段。如果为false，则调用range、get和with(TemporalField, long)方法将抛出异常。

      如果字段是ChronoField，则在此处实现查询。支持的字段包括：

      • NANO_OF_SECOND
      • NANO_OF_DAY
      • MICRO_OF_SECOND
      • MICRO_OF_DAY
      • MILLI_OF_SECOND
      • MILLI_OF_DAY
      • SECOND_OF_MINUTE
      • SECOND_OF_DAY
      • MINUTE_OF_HOUR
      • MINUTE_OF_DAY
      • HOUR_OF_AMPM
      • CLOCK_HOUR_OF_AMPM
      • HOUR_OF_DAY
      • CLOCK_HOUR_OF_DAY
      • AMPM_OF_DAY
      • DAY_OF_WEEK
      • ALIGNED_DAY_OF_WEEK_IN_MONTH
      • ALIGNED_DAY_OF_WEEK_IN_YEAR
      • DAY_OF_MONTH
      • DAY_OF_YEAR
      • EPOCH_DAY
      • ALIGNED_WEEK_OF_MONTH
      • ALIGNED_WEEK_OF_YEAR
      • MONTH_OF_YEAR
      • PROLEPTIC_MONTH
      • YEAR_OF_ERA
      • YEAR
      • ERA
      所有其他ChronoField实例将返回false。

      如果字段不是ChronoField，则通过调用TemporalField.isSupportedBy(TemporalAccessor)并将this作为参数来获取此方法的结果。字段是否受支持由字段确定。

      指定者：
      isSupported 在接口 ChronoLocalDateTime<LocalDate>
      指定者：
      isSupported 在接口 TemporalAccessor
      参数：
      field - 要检查的字段，null返回false
      返回：
      如果此日期时间支持该字段，则为true，否则为false

    • isSupported

      public boolean isSupported(TemporalUnit unit)
      检查是否支持指定单位。

      检查指定单位是否可以添加到此日期时间或从中减去。如果为false，则调用plus(long, TemporalUnit)和minus方法将抛出异常。

      如果单位是ChronoUnit，则在此处实现查询。支持的单位包括：

      • NANOS
      • MICROS
      • MILLIS
      • SECONDS
      • MINUTES
      • HOURS
      • HALF_DAYS
      • DAYS
      • WEEKS
      • MONTHS
      • YEARS
      • DECADES
      • CENTURIES
      • MILLENNIA
      • ERAS
      所有其他ChronoUnit实例将返回false。

      如果单位不是ChronoUnit，则通过调用TemporalUnit.isSupportedBy(Temporal)并将this作为参数来获取此方法的结果。单位是否受支持由单位确定。

      指定者：
      isSupported 在接口 ChronoLocalDateTime<LocalDate>
      指定者：
      isSupported 在接口 Temporal
      参数：
      unit - 要检查的单位，null返回false
      返回：
      如果单位可以添加/减去，则为true，否则为false

    • range

      public ValueRange range(TemporalField field)
      获取指定字段的有效值范围。

      范围对象表示字段的最小和最大有效值。此日期时间用于增强返回范围的准确性。如果无法返回范围，因为不支持字段或出于其他原因，将抛出异常。

      如果字段是ChronoField，则在此处实现查询。支持的字段将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

      如果字段不是ChronoField，则通过调用TemporalField.rangeRefinedBy(TemporalAccessor)并将this作为参数来获取此方法的结果。是否可以获取范围由字段确定。

      指定者：
      range 在接口 TemporalAccessor
      参数：
      field - 要查询范围的字段，不能为空
      返回：
      字段的有效值范围，不能为空
      抛出：
      DateTimeException - 如果无法获取字段的范围
      UnsupportedTemporalTypeException - 如果不支持该字段

    • get

      public int get(TemporalField field)
      从此日期时间获取指定字段的值作为int。

      查询此日期时间以获取指定字段的值。返回的值将始终在字段的有效值范围内。如果无法返回值，因为不支持字段或出于其他原因，将抛出异常。

      如果字段是ChronoField，则在此处实现查询。根据此日期时间，支持的字段将根据此日期时间返回有效值，除了NANO_OF_DAY、MICRO_OF_DAY、EPOCH_DAY和PROLEPTIC_MONTH，它们太大而无法适应int并抛出UnsupportedTemporalTypeException。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

      如果字段不是ChronoField，则通过调用TemporalField.getFrom(TemporalAccessor)并将this作为参数来获取此方法的结果。值是否可获取以及值代表什么由字段确定。

      指定者:
      get 在接口 TemporalAccessor中指定
      参数:
      field - 要获取的字段，不能为空
      返回值:
      字段的值
      抛出:
      DateTimeException - 如果无法获取字段的值或值超出字段的有效值范围
      UnsupportedTemporalTypeException - 如果不支持该字段或值范围超过int
      ArithmeticException - 如果发生数值溢出

    • getLong

      public long getLong(TemporalField field)
      从此日期时间中获取指定字段的值，返回一个long类型的值。

      此方法查询指定字段的值。如果由于字段不受支持或其他原因无法返回值，则会抛出异常。

      如果字段是ChronoField，则在此处实现查询。基于此日期时间，支持的字段将返回有效值。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException异常。

      如果字段不是ChronoField，则通过调用TemporalField.getFrom(TemporalAccessor)方法并将this作为参数来获取此方法的结果。值是否可以获取以及值代表什么由字段决定。

      指定者:
      getLong 在接口 TemporalAccessor中指定
      参数:
      field - 要获取的字段，不能为空
      返回值:
      字段的值
      抛出:
      DateTimeException - 如果无法获取字段的值
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数值溢出

    • toLocalDate

      public LocalDate toLocalDate()
      获取此日期时间的LocalDate部分。

      返回一个具有与此日期时间相同年份、月份和日期的LocalDate。

      指定者:
      toLocalDate 在接口 ChronoLocalDateTime<LocalDate>中指定
      返回值:
      此日期时间的日期部分，不能为空

    • getYear

      public int getYear()
      获取年份字段。

      此方法返回年份的原始int值。

      此方法返回的年份是根据get(YEAR)的规则。要获取时代年份，请使用get(YEAR_OF_ERA)。

      返回值:
      年份，从MIN_YEAR到MAX_YEAR

    • getMonthValue

      public int getMonthValue()
      获取月份字段，范围从1到12。

      此方法返回月份作为从1到12的int。应用代码通常更清晰，如果使用枚举Month通过调用getMonth()。

      返回值:
      月份，从1到12
      参见:

    • getMonth

      public Month getMonth()
      使用Month枚举获取月份字段。

      此方法返回月份的枚举Month。这样可以避免混淆int值的含义。如果需要访问原始int值，则枚举提供了int value。

      返回值:
      月份，不能为空
      参见:

    • getDayOfMonth

      public int getDayOfMonth()
      获取日期字段。

      此方法返回日期的原始int值。

      返回值:
      日期，从1到31

    • getDayOfYear

      public int getDayOfYear()
      获取一年中的日期字段。

      此方法返回一年中的日期的原始int值。

      返回值:
      一年中的日期，从1到365，闰年为366

    • getDayOfWeek

      public DayOfWeek getDayOfWeek()
      获取星期几字段，是一个枚举DayOfWeek。

      此方法返回星期几的枚举DayOfWeek。这样可以避免混淆int值的含义。如果需要访问原始int值，则枚举提供了int value。

      可以从DayOfWeek获取其他信息。这包括值的文本名称。

      返回值:
      星期几，不能为空

    • toLocalTime

      public LocalTime toLocalTime()
      获取此日期时间的LocalTime部分。

      返回一个具有与此日期时间相同小时、分钟、秒和纳秒的LocalTime。

      指定者:
      toLocalTime 在接口 ChronoLocalDateTime<LocalDate>中指定
      返回值:
      此日期时间的时间部分，不能为空

    • getHour

      public int getHour()
      获取一天中的小时字段。
      返回值:
      小时，从0到23

    • getMinute

      public int getMinute()
      获取一小时中的分钟字段。
      返回值:
      分钟，从0到59

    • getSecond

      public int getSecond()
      获取一分钟中的秒字段。
      返回值:
      秒，从0到59

    • getNano

      public int getNano()
      获取一秒中的纳秒字段。
      返回值:
      纳秒，从0到999,999,999

    • with

      public LocalDateTime with(TemporalAdjuster adjuster)
      返回此日期时间的调整副本。

      返回一个LocalDateTime，基于此日期时间进行调整。调整使用指定的调整策略对象进行。阅读调整器的文档以了解将进行的调整。

      简单的调整器可能只是设置一个字段，例如年份字段。更复杂的调整器可能将日期设置为月份的最后一天。

      TemporalAdjusters提供了一些常见的调整选项。这些包括查找“月底”和“下一个星期三”。关键的日期时间类也实现了TemporalAdjuster接口，例如Month和MonthDay。调整器负责处理特殊情况，例如不同长度的月份和闰年。

      例如，此代码返回七月的最后一天的日期：

        import static java.time.Month.*;
  import static java.time.temporal.TemporalAdjusters.*;

  result = localDateTime.with(JULY).with(lastDayOfMonth());

      LocalDate和LocalTime类实现了TemporalAdjuster，因此可以使用此方法更改日期、时间或偏移量：

        result = localDateTime.with(date);
  result = localDateTime.with(time);

      此方法的结果是通过在指定的调整器上调用TemporalAdjuster.adjustInto(Temporal)方法并将this作为参数来获取的。

      此实例是不可变的，不受此方法调用的影响。

      指定者:
      with 在接口 ChronoLocalDateTime<LocalDate>中指定
      指定者:
      with 在接口 Temporal中指定
      参数:
      adjuster - 要使用的调整器，不能为空
      返回值:
      基于this进行调整的LocalDateTime，不能为空
      抛出:
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数值溢出

    • with

      public LocalDateTime with(TemporalField field, long newValue)
      返回具有指定字段设置为新值的此日期时间的副本。

      返回一个LocalDateTime，基于此日期时间，指定字段的值已更改。这可用于更改任何支持的字段，例如年、月或日。如果无法设置值，因为不支持该字段或出于其他原因，将抛出异常。

      在某些情况下，更改指定字段可能导致生成的日期时间无效，例如将月份从1月31日更改为2月会使日期无效。在这种情况下，字段负责解析日期。通常它会选择前一个有效日期，例如在此示例中将是2月的最后一个有效日期。

      如果字段是一个ChronoField，则在此处实现调整。支持的字段将根据LocalDate或LocalTime上的匹配方法的行为。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

      如果字段不是ChronoField，则通过调用TemporalField.adjustInto(Temporal, long)并将this作为参数来获取此方法的结果。在这种情况下，字段确定是否以及如何调整时刻。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      with 在接口 ChronoLocalDateTime<LocalDate>
      指定者：
      with 在接口 Temporal
      参数：
      field - 要在结果中设置的字段，不能为空
      newValue - 结果中字段的新值
      返回：
      基于this的LocalDateTime，指定字段已设置，不能为空
      抛出：
      DateTimeException - 如果无法设置字段
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数值溢出

    • withYear

      public LocalDateTime withYear(int year)
      返回具有更改年份的此LocalDateTime的副本。

      时间不影响计算，并且在结果中将保持不变。如果对于该年份来说日期无效，则会更改为该月份的最后一个有效日期。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      year - 要在结果中设置的年份，从MIN_YEAR到MAX_YEAR
      返回：
      基于此日期时间的LocalDateTime，具有请求的年份，不能为空
      抛出：
      DateTimeException - 如果年份值无效

    • withMonth

      public LocalDateTime withMonth(int month)
      返回具有更改年份的此LocalDateTime的副本。

      时间不影响计算，并且在结果中将保持不变。如果对于该年份来说日期无效，则会更改为该月份的最后一个有效日期。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      month - 要在结果中设置的年份，从1（一月）到12（十二月）
      返回：
      基于此日期时间的LocalDateTime，具有请求的月份，不能为空
      抛出：
      DateTimeException - 如果月份值无效

    • withDayOfMonth

      public LocalDateTime withDayOfMonth(int dayOfMonth)
      返回具有更改月份的此LocalDateTime的副本。

      如果生成的日期时间无效，则会抛出异常。时间不影响计算，并且在结果中将保持不变。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      dayOfMonth - 要在结果中设置的月份日期，从1到28-31
      返回：
      基于此日期时间的LocalDateTime，具有请求的日期，不能为空
      抛出：
      DateTimeException - 如果日期值无效，或者如果日期对于该年份无效

    • withDayOfYear

      public LocalDateTime withDayOfYear(int dayOfYear)
      返回具有更改一年中日期的此LocalDateTime的副本。

      如果生成的日期时间无效，则会抛出异常。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      dayOfYear - 要在结果中设置的一年中的日期，从1到365-366
      返回：
      基于此日期的LocalDateTime，具有请求的日期，不能为空
      抛出：
      DateTimeException - 如果日期值无效，或者如果日期对于该年份无效

    • withHour

      public LocalDateTime withHour(int hour)
      返回具有更改一天中小时的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      hour - 要在结果中设置的小时，从0到23
      返回：
      基于此日期时间的LocalDateTime，具有请求的小时，不能为空
      抛出：
      DateTimeException - 如果小时值无效

    • withMinute

      public LocalDateTime withMinute(int minute)
      返回具有更改一小时中分钟的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      minute - 要在结果中设置的分钟，从0到59
      返回：
      基于此日期时间的LocalDateTime，具有请求的分钟，不能为空
      抛出：
      DateTimeException - 如果分钟值无效

    • withSecond

      public LocalDateTime withSecond(int second)
      返回具有更改一分钟中秒的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      second - 要在结果中设置的秒，从0到59
      返回：
      基于此日期时间的LocalDateTime，具有请求的秒，不能为空
      抛出：
      DateTimeException - 如果秒值无效

    • withNano

      public LocalDateTime withNano(int nanoOfSecond)
      返回具有更改一秒中纳秒的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      nanoOfSecond - 要在结果中设置的纳秒，从0到999,999,999
      返回：
      基于此日期时间的LocalDateTime，具有请求的纳秒，不能为空
      抛出：
      DateTimeException - 如果纳秒值无效

    • truncatedTo

      public LocalDateTime truncatedTo(TemporalUnit unit)
      返回截断时间的此LocalDateTime的副本。

      截断返回原始日期时间的副本，其中小于指定单位的字段设置为零。例如，使用minutes单位进行截断将会将秒和纳秒字段设置为零。

      该单位必须具有可将其持续时间除以标准天长度而不余数的持续时间。这包括所有提供的时间单位在ChronoUnit和DAYS上。其他单位会抛出异常。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      unit - 要截断到的单位，不能为空
      返回：
      基于此日期时间的LocalDateTime，已截断时间，不能为空
      抛出：
      DateTimeException - 如果无法截断
      UnsupportedTemporalTypeException - 如果不支持该单位

    • plus

      public LocalDateTime plus(TemporalAmount amountToAdd)
      返回添加指定数量后的此日期时间的副本。

      返回一个LocalDateTime，基于此日期时间，已添加指定数量。该数量通常是Period或Duration，但可以是实现TemporalAmount接口的任何其他类型。

      通过调用TemporalAmount.addTo(Temporal)将计算委托给数量对象。数量实现可以以任何希望的方式实现添加，但通常会回调到plus(long, TemporalUnit)。请查阅数量实现的文档，以确定是否可以成功添加。

      此实例是不可变的，不受此方法调用的影响。

      指定者:
      plus 在接口 ChronoLocalDateTime<LocalDate>中
      指定者:
      plus 在接口 Temporal中
      参数:
      amountToAdd - 要添加的数量，不能为空
      返回:
      基于此日期时间的LocalDateTime，添加后的结果，不能为空
      抛出:
      DateTimeException - 如果无法进行添加
      ArithmeticException - 如果发生数值溢出

    • plus

      public LocalDateTime plus(long amountToAdd, TemporalUnit unit)
      返回添加指定数量后的此日期时间的副本。

      这将返回一个LocalDateTime，基于此日期时间，添加了指定单位的数量。如果无法添加数量，因为该单位不受支持或出现其他原因，则会抛出异常。

      如果字段是ChronoUnit，则在此处实现添加。日期单位按照LocalDate.plus(long, TemporalUnit)添加。时间单位按照LocalTime.plus(long, TemporalUnit)添加，任何溢出的天数添加等效于使用plusDays(long)。

      如果字段不是ChronoUnit，则通过调用TemporalUnit.addTo(Temporal, long)并将this作为参数来获取此方法的结果。在这种情况下，单位确定是否以及如何执行添加。

      此实例是不可变的，不受此方法调用的影响。

      指定者:
      plus 在接口 ChronoLocalDateTime<LocalDate>中
      指定者:
      plus 在接口 Temporal中
      参数:
      amountToAdd - 要添加到结果的单位数量，可以为负数
      unit - 要添加的单位，不能为空
      返回:
      基于此日期时间的LocalDateTime，添加了指定数量的结果，不能为空
      抛出:
      DateTimeException - 如果无法进行添加
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • plusYears

      public LocalDateTime plusYears(long years)
      返回添加指定年数后的此LocalDateTime的副本。

      此方法将在三个步骤中将指定数量添加到年份字段中：

      1. 将输入年份添加到年份字段
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2008-02-29（闰年）加一年将导致无效日期2009-02-29（标准年）。而不是返回无效结果，选择月份的最后一个有效日期，即2009-02-28。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      years - 要添加的年数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了年数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusMonths

      public LocalDateTime plusMonths(long months)
      返回添加指定月数后的此LocalDateTime的副本。

      此方法将在三个步骤中将指定数量添加到月份字段中：

      1. 将输入月份添加到年份字段中的月份
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2007-03-31加一个月将导致无效日期2007-04-31。而不是返回无效结果，选择月份的最后一个有效日期，即2007-04-30。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      months - 要添加的月数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了月数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusWeeks

      public LocalDateTime plusWeeks(long weeks)
      返回添加指定周数后的此LocalDateTime的副本。

      此方法将指定周数添加到天数字段中，根据需要递增月份和年份字段以确保结果保持有效。仅当超出最大/最小年份时，结果才无效。

      例如，2008-12-31加一周将导致2009-01-07。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      weeks - 要添加的周数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了周数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusDays

      public LocalDateTime plusDays(long days)
      返回添加指定天数后的此LocalDateTime的副本。

      此方法将指定数量添加到天数字段中，根据需要递增月份和年份字段以确保结果保持有效。仅当超出最大/最小年份时，结果才无效。

      例如，2008-12-31加一天将导致2009-01-01。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      days - 要添加的天数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了天数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusHours

      public LocalDateTime plusHours(long hours)
      返回添加指定小时数后的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      hours - 要添加的小时数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了小时数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusMinutes

      public LocalDateTime plusMinutes(long minutes)
      返回添加指定分钟数后的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      minutes - 要添加的分钟数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了分钟数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusSeconds

      public LocalDateTime plusSeconds(long seconds)
      返回添加指定秒数后的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      seconds - 要添加的秒数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了秒数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusNanos

      public LocalDateTime plusNanos(long nanos)
      返回添加指定纳秒数后的此LocalDateTime的副本。

      此实例是不可变的，不受此方法调用的影响。

      参数:
      nanos - 要添加的纳秒数，可以为负数
      返回:
      基于此日期时间的LocalDateTime，添加了纳秒数的结果，不能为空
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • minus

      public LocalDateTime minus(TemporalAmount amountToSubtract)
      返回减去指定数量后的此日期时间的副本。

      这将返回一个LocalDateTime，基于此日期时间，减去了指定的数量。数量通常是Period或Duration，但也可以是实现TemporalAmount接口的任何其他类型。

      通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给数量对象。数量实现可以以任何希望的方式实现减法，但通常会回调minus(long, TemporalUnit)。请查阅数量实现的文档，以确定是否可以成功减去。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 ChronoLocalDateTime<LocalDate>中指定
      指定者：
      minus 在接口 Temporal中指定
      参数：
      amountToSubtract - 要减去的数量，不能为空
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果无法进行减法运算
      ArithmeticException - 如果发生数值溢出

    • minus

      public LocalDateTime minus(long amountToSubtract, TemporalUnit unit)
      返回此日期时间的副本，减去指定的数量。

      这将返回一个LocalDateTime，基于此日期时间，减去指定单位的数量。如果无法减去数量，因为该单位不受支持或出现其他原因，则会抛出异常。

      此方法等同于使用数量取反的plus(long, TemporalUnit)方法。查看该方法以获取有关加法（因此减法）运算方式的完整描述。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 ChronoLocalDateTime<LocalDate>中指定
      指定者：
      minus 在接口 Temporal中指定
      参数：
      amountToSubtract - 要从结果中减去的单位数量，可以为负数
      unit - 要减去的数量的单位，不能为空
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果无法进行减法运算
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • minusYears

      public LocalDateTime minusYears(long years)
      返回此LocalDateTime的副本，减去指定数量的年份。

      此方法通过以下三个步骤从年份字段中减去指定数量：

      1. 从年份字段中减去输入的年份
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2008-02-29（闰年）减去一年将导致无效日期2007-02-29（标准年）。而不是返回无效结果，将选择该月的最后一个有效日期，即2007-02-28。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      years - 要减去的年份，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusMonths

      public LocalDateTime minusMonths(long months)
      返回此LocalDateTime的副本，减去指定数量的月份。

      此方法通过以下三个步骤从月份字段中减去指定数量：

      1. 从月份字段中减去输入的月份
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2007-03-31减去一个月将导致无效日期2007-02-31。而不是返回无效结果，将选择该月的最后一个有效日期，即2007-02-28。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      months - 要减去的月份，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusWeeks

      public LocalDateTime minusWeeks(long weeks)
      返回此LocalDateTime的副本，减去指定数量的周数。

      此方法从天数字段中减去指定数量的周数，根据需要递减月份和年份字段以确保结果保持有效。仅当超出最大/最小年份时，结果才无效。

      例如，2009-01-07减去一周将导致2008-12-31。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      weeks - 要减去的周数，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusDays

      public LocalDateTime minusDays(long days)
      返回此LocalDateTime的副本，减去指定数量的天数。

      此方法从天数字段中减去指定数量，根据需要递减月份和年份字段以确保结果保持有效。仅当超出最大/最小年份时，结果才无效。

      例如，2009-01-01减去一天将导致2008-12-31。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      days - 要减去的天数，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusHours

      public LocalDateTime minusHours(long hours)
      返回此LocalDateTime的副本，减去指定数量的小时。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      hours - 要减去的小时数，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusMinutes

      public LocalDateTime minusMinutes(long minutes)
      返回此LocalDateTime的副本，减去指定数量的分钟。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      minutes - 要减去的分钟数，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusSeconds

      public LocalDateTime minusSeconds(long seconds)
      返回此LocalDateTime的副本，减去指定数量的秒数。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      seconds - 要减去的秒数，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusNanos

      public LocalDateTime minusNanos(long nanos)
      返回此LocalDateTime的副本，减去指定数量的纳秒数。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      nanos - 要减去的纳秒数，可以为负数
      返回：
      基于此日期时间进行减法运算后的LocalDateTime，不能为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • query

      public <R> R query(TemporalQuery<R> query)
      使用指定的查询对此日期时间进行查询。

      使用指定的查询策略对象对此日期时间进行查询。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档以了解此方法的结果。

      此方法的结果是通过在指定查询上调用TemporalQuery.queryFrom(TemporalAccessor)方法获取的，传递this作为参数。

      指定者:
      query 在接口 ChronoLocalDateTime<LocalDate>中
      指定者:
      query 在接口 TemporalAccessor中
      类型参数:
      R - 结果的类型
      参数:
      query - 要调用的查询，不能为空
      返回值:
      查询结果，可能返回null（由查询定义）
      抛出:
      DateTimeException - 如果无法查询（由查询定义）
      ArithmeticException - 如果发生数值溢出（由查询定义）

    • adjustInto

      public Temporal adjustInto(Temporal temporal)
      调整指定的时间对象，使其具有与此对象相同的日期和时间。

      返回一个与输入的可观察类型相同的时间对象，日期和时间更改为与此相同。

      该调整等同于两次使用Temporal.with(TemporalField, long)，传递ChronoField.EPOCH_DAY和ChronoField.NANO_OF_DAY作为字段。

      在大多数情况下，通过使用Temporal.with(TemporalAdjuster)来反转调用模式更清晰：

         // 这两行是等效的，但推荐第二种方法
   temporal = thisLocalDateTime.adjustInto(temporal);
   temporal = temporal.with(thisLocalDateTime);

      此实例是不可变的，不受此方法调用的影响。

      指定者:
      adjustInto 在接口 ChronoLocalDateTime<LocalDate>中
      指定者:
      adjustInto 在接口 TemporalAdjuster中
      参数:
      temporal - 要调整的目标对象，不能为空
      返回值:
      调整后的对象，不能为空
      抛出:
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数值溢出

    • until

      public long until(Temporal endExclusive, TemporalUnit unit)
      根据指定单位计算到另一个日期时间的时间量。

      这将根据单个TemporalUnit计算两个LocalDateTime对象之间的时间量。起始点和结束点分别为this和指定的日期时间。如果结束在开始之前，则结果将为负数。传递给此方法的Temporal将使用from(TemporalAccessor)转换为LocalDateTime。例如，可以使用startDateTime.until(endDateTime, DAYS)来计算两个日期时间之间的天数。

      计算返回一个整数，表示两个日期时间之间完整单位的数量。例如，在2012-06-15T00:00和2012-08-14T23:59之间的月份数量将只有一个月，因为它距离两个月仅差一分钟。

      有两种等效的使用方法。第一种是调用此方法。第二种是使用TemporalUnit.between(Temporal, Temporal)：

         // 这两行是等效的
   amount = start.until(end, MONTHS);
   amount = MONTHS.between(start, end);
      应根据哪种方法使代码更易读来进行选择。

      此方法为ChronoUnit中的单位实现了计算。支持单位NANOS、MICROS、MILLIS、SECONDS、MINUTES、HOURS和HALF_DAYS、DAYS、WEEKS、MONTHS、YEARS、DECADES、CENTURIES、MILLENNIA和ERAS。其他ChronoUnit值将抛出异常。

      如果单位不是ChronoUnit，则通过调用TemporalUnit.between(Temporal, Temporal)传递this作为第一个参数和转换后的输入时间作为第二个参数来获得此方法的结果。

      此实例是不可变的，不受此方法调用的影响。

      指定者:
      until 在接口 Temporal中
      参数:
      endExclusive - 结束日期（不包括），将其转换为LocalDateTime，不能为空
      unit - 用于测量时间量的单位，不能为空
      返回值:
      此日期时间与结束日期时间之间的时间量
      抛出:
      DateTimeException - 如果无法计算时间量，或者无法将结束时间转换为LocalDateTime
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • format

      public String format(DateTimeFormatter formatter)
      使用指定的格式化程序格式化此日期时间。

      将此日期时间传递给格式化程序以生成一个字符串。

      指定者:
      format 在接口 ChronoLocalDateTime<LocalDate>中
      参数:
      formatter - 要使用的格式化程序，不能为空
      返回值:
      格式化后的日期时间字符串，不能为空
      抛出:
      DateTimeException - 在打印过程中发生错误

    • atOffset

      public OffsetDateTime atOffset(ZoneOffset offset)
      将此日期时间与偏移组合以创建一个OffsetDateTime。

      这将从指定偏移的此日期时间形成一个OffsetDateTime。所有日期时间和偏移的可能组合都是有效的。

      参数:
      offset - 要组合的偏移，不能为空
      返回值:
      从此日期时间和指定偏移形成的偏移日期时间，不能为空

    • atZone

      public ZonedDateTime atZone(ZoneId zone)
      将此日期时间与时区组合以创建一个ZonedDateTime。

      这将从指定时区的此日期时间形成一个ZonedDateTime。结果将尽可能与此日期时间匹配。时区规则，如夏令时，意味着并非每个本地日期时间对于指定时区都是有效的，因此本地日期时间可能会被调整。

      本地日期时间将解析为时间线上的单个瞬时。这是通过找到由时区ID的规则定义的本地日期时间相对于UTC/Greenwich的有效偏移来实现的。

      在大多数情况下，本地日期时间只有一个有效偏移。在重叠的情况下，其中时钟被设置回去，有两个有效偏移。此方法通常使用较早的偏移，通常对应于“夏季”。

      在间隙的情况下，其中时钟向前跳跃，没有有效偏移。相反，本地日期时间将调整为间隙的长度后面。对于典型的一小时夏令时更改，本地日期时间将被移动一小时到后面，进入通常对应于“夏季”的偏移。

      在重叠时获得较晚偏移，调用此方法的结果上的ZonedDateTime.withLaterOffsetAtOverlap()。在间隙或重叠时抛出异常，使用ZonedDateTime.ofStrict(LocalDateTime, ZoneOffset, ZoneId)。

      指定者:
      atZone 在接口 ChronoLocalDateTime<LocalDate>中
      参数:
      zone - 要使用的时区，不能为空
      返回值:
      从此日期时间形成的分区日期时间，不能为空

    • compareTo

      public int compareTo(ChronoLocalDateTime<?> other)
      将此日期时间与另一个日期时间进行比较。

      比较主要基于日期时间，从最早到最晚。它是“与equals一致”的，如Comparable所定义。

      如果所有被比较的日期时间都是LocalDateTime的实例，则比较将完全基于日期时间。如果要比较的一些日期在不同的年表中，则还将考虑年表，参见ChronoLocalDateTime.compareTo(java.time.chrono.ChronoLocalDateTime<?>)。

      指定者:
      compareTo 在接口 ChronoLocalDateTime<LocalDate>中被指定
      指定者:
      compareTo 在接口 Comparable<ChronoLocalDateTime<?>>中被指定
      参数:
      other - 要比较的另一个日期时间，不能为空
      返回值:
      比较器值，即此本地日期时间与other本地日期时间以及此年表与other年表的比较，按顺序返回第一个非零结果，否则返回零
      参见:

    • isAfter

      public boolean isAfter(ChronoLocalDateTime<?> other)
      检查此日期时间是否在指定日期时间之后。

      这将检查此日期时间是否表示本地时间线上的一个点在另一个日期时间之后。

         LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00);
   LocalDate b = LocalDateTime.of(2012, 7, 1, 12, 00);
   a.isAfter(b) == false
   a.isAfter(a) == false
   b.isAfter(a) == true

      此方法仅考虑两个日期时间在本地时间线上的位置。它不考虑年表或日历系统。这与compareTo(ChronoLocalDateTime)中的比较不同，但与ChronoLocalDateTime.timeLineOrder()的方法相同。

      指定者:
      isAfter 在接口 ChronoLocalDateTime<LocalDate>中被指定
      参数:
      other - 要比较的另一个日期时间，不能为空
      返回值:
      如果此日期时间在指定日期时间之后，则为true

    • isBefore

      public boolean isBefore(ChronoLocalDateTime<?> other)
      检查此日期时间是否在指定日期时间之前。

      这将检查此日期时间是否表示本地时间线上的一个点在另一个日期时间之前。

         LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00);
   LocalDate b = LocalDateTime.of(2012, 7, 1, 12, 00);
   a.isBefore(b) == true
   a.isBefore(a) == false
   b.isBefore(a) == false

      此方法仅考虑两个日期时间在本地时间线上的位置。它不考虑年表或日历系统。这与compareTo(ChronoLocalDateTime)中的比较不同，但与ChronoLocalDateTime.timeLineOrder()的方法相同。

      指定者:
      isBefore 在接口 ChronoLocalDateTime<LocalDate>中被指定
      参数:
      other - 要比较的另一个日期时间，不能为空
      返回值:
      如果此日期时间在指定日期时间之前，则为true

    • isEqual

      public boolean isEqual(ChronoLocalDateTime<?> other)
      检查此日期时间是否等于指定日期时间。

      这将检查此日期时间是否表示本地时间线上与另一个日期时间相同的点。

         LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00);
   LocalDate b = LocalDateTime.of(2012, 7, 1, 12, 00);
   a.isEqual(b) == false
   a.isEqual(a) == true
   b.isEqual(a) == false

      此方法仅考虑两个日期时间在本地时间线上的位置。它不考虑年表或日历系统。这与compareTo(ChronoLocalDateTime)中的比较不同，但与ChronoLocalDateTime.timeLineOrder()的方法相同。

      指定者:
      isEqual 在接口 ChronoLocalDateTime<LocalDate>中被指定
      参数:
      other - 要比较的另一个日期时间，不能为空
      返回值:
      如果此日期时间等于指定日期时间，则为true

    • equals

      public boolean equals(Object obj)
      检查此日期时间是否等于另一个日期时间。

      将此LocalDateTime与另一个进行比较，确保日期时间相同。仅比较LocalDateTime类型的对象，其他类型返回false。

      指定者:
      equals 在接口 ChronoLocalDateTime<LocalDate>中被指定
      覆盖:
      equals 在类 Object中被覆盖
      参数:
      obj - 要检查的对象，null返回false
      返回值:
      如果此对象等于另一个日期时间，则为true
      参见:

    • hashCode

      public int hashCode()
      此日期时间的哈希码。
      指定者:
      hashCode 在接口 ChronoLocalDateTime<LocalDate>中被指定
      覆盖:
      hashCode 在类 Object中被覆盖
      返回值:
      适当的哈希码
      参见:

    • toString

      public String toString()
      将此日期时间输出为String，例如2007-12-03T10:15:30。

      输出将是以下ISO-8601格式之一：

      • uuuu-MM-dd'T'HH:mm
      • uuuu-MM-dd'T'HH:mm:ss
      • uuuu-MM-dd'T'HH:mm:ss.SSS
      • uuuu-MM-dd'T'HH:mm:ss.SSSSSS
      • uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSS
      使用的格式将是输出完整值的最短格式，其中省略的部分被假定为零。
      指定者:
      toString 在接口 ChronoLocalDateTime<LocalDate>中被指定
      覆盖:
      toString 在类 Object中被覆盖
      返回值:
      此日期时间的字符串表示，不能为空