模块  java.base
软件包  java.time

Class LocalDateTime

  • 实现的所有接口
    SerializableComparable<ChronoLocalDateTime<?>>ChronoLocalDateTime<LocalDate>TemporalTemporalAccessorTemporalAdjuster

    public final class LocalDateTime
    extends Object
    implements Temporal, TemporalAdjuster, ChronoLocalDateTime<LocalDate>, Serializable
    ISO- 2007-12-03T10:15:30 ,例如2007-12-03T10:15:30

    LocalDateTime是一个不可变的日期时间对象,表示日期时间,通常被视为年 - 月 - 日 - 小时 - 分 - 秒。 还可以访问其他日期和时间字段,例如日期,星期几和星期。 时间表示为纳秒精度。 例如,值“2007年10月2日13:45.30.123456789”可以存储在LocalDateTime

    此类不存储或表示时区。 相反,它是用于生日的日期的描述,结合在挂钟上看到的当地时间。 如果没有附加信息(如偏移或时区),它不能代表时间线上的瞬间。

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

    这是一个value-based类; LocalDateTime实例上使用身份敏感操作(包括引用相等( == ),标识哈希码或同步)可能会产生不可预测的结果,应该避免使用。 应使用equals方法进行比较。

    实现要求:
    这个类是不可变的和线程安全的。
    从以下版本开始:
    1.8
    另请参见:
    Serialized Form
    • 字段详细信息

      • MIN

        public static final LocalDateTime MIN
        支持的最小值为LocalDateTime ,' - LocalDateTime :00:00'。 这是最短日期开始时的午夜的本地日期时间。 这个结合了LocalDate.MINLocalTime.MIN 这可以被应用程序用作“远远过去”的日期时间。
      • MAX

        public static final LocalDateTime MAX
        支持的最大值为LocalDateTime ,'+ 999999999-12-31T23:59:59.999999999'。 这是在最大日期结束时午夜之前的本地日期时间。 它结合了LocalDate.MAXLocalTime.MAX 这可以被应用程序用作“远期未来”的日期时间。
    • 方法详细信息

      • now

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

        这将在默认时区中查询system clock以获取当前日期时间。

        使用此方法将无法使用备用时钟进行测试,因为时钟是硬编码的。

        结果
        使用系统时钟和默认时区的当前日期时间,不为空
      • now

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

        这将查询system clock以获取当前日期时间。 指定时区可避免依赖于默认时区。

        使用此方法将无法使用备用时钟进行测试,因为时钟是硬编码的。

        参数
        zone - 要使用的区域ID,不为空
        结果
        使用系统时钟的当前日期时间,不为空
      • now

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

        这将查询指定的时钟以获取当前日期时间。 使用此方法允许使用备用时钟进行测试。 可以使用dependency injection引入备用时钟。

        参数
        clock - 要使用的时钟,不为空
        结果
        当前日期时间,不为空
      • of

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

        这将返回LocalDateTime其中包含指定的年,月,日,小时和分钟。 该日必须对年和月有效,否则将抛出异常。 第二个和纳秒字段将设置为零。

        参数
        year - 表示年份,从MIN_YEAR到MAX_YEAR
        month - 表示的月份,而不是空
        dayOfMonth - 表示的日期,从1到31
        hour - 表示从0到23的小时
        minute - 表示从0到59的分钟
        结果
        本地日期时间,不为空
        异常
        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 - 表示的月份,而不是空
        dayOfMonth - 表示从1到31的月份的日期
        hour - 表示从0到23的小时
        minute - 表示从0到59的分钟
        second - 代表的第二分钟,从0到59
        结果
        本地日期时间,不为空
        异常
        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 - 表示的月份,而不是空
        dayOfMonth - 表示的日期,从1到31
        hour - 表示从0到23的小时
        minute - 表示从0到59的小时
        second - 代表的第二分钟,从0到59
        nanoOfSecond - 代表的纳秒数,从0到999,999,999
        结果
        本地日期时间,不为空
        异常
        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月(1月)到12月(12月)的月份
        dayOfMonth - 表示的日期,范围是1到31
        hour - 表示从0到23的小时
        minute - 表示从0到59的小时
        结果
        本地日期时间,不为空
        异常
        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(1月)到12(12月)的月份
        dayOfMonth - 表示的日期,从1到31
        hour - 表示从0到23的小时
        minute - 表示从0到59的小时
        second - 表示从0到59的秒分钟
        结果
        本地日期时间,不为空
        异常
        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月(1月)到12月(12月)的月份
        dayOfMonth - 表示的日期,从1到31
        hour - 表示从0到23的小时
        minute - 表示从0到59的小时
        second - 表示从0到59的秒分钟
        nanoOfSecond - 代表的纳秒数,从0到999,999,999
        结果
        本地日期时间,不为空
        异常
        DateTimeException - 如果任何字段的值超出范围,或者月份的月份无效
      • of

        public static LocalDateTime of​(LocalDate date,
                                       LocalTime time)
        从日期和时间获得 LocalDateTime的实例。
        参数
        date - 本地日期,不为空
        time - 当地时间,非空
        结果
        本地日期时间,不为空
      • ofInstant

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

        这将根据指定的时刻创建本地日期时间。 首先,使用区域ID和瞬间获得UTC /格林威治的偏移量,这很简单,因为每个瞬间只有一个有效偏移量。 然后,使用instant和offset来计算本地日期时间。

        参数
        instant - 创建日期时间的瞬间,而不是null
        zone - 时区,可以是偏移量,不为空
        结果
        本地日期时间,不为空
        异常
        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 - 区域偏移量,不为空
        结果
        本地日期时间,不为空
        异常
        DateTimeException - 如果结果超出支持的范围,或者纳秒级无效
      • from

        public static LocalDateTime from​(TemporalAccessor temporal)
        从时态对象获得LocalDateTime的实例。

        这基于指定的时间获得本地日期时间。 TemporalAccessor表示一组任意日期和时间信息,该工厂将其转换为LocalDateTime的实例。

        转换从时间对象中提取并组合LocalDateLocalTime 允许实现执行优化,例如访问与相关对象等效的那些字段。

        该方法匹配功能接口TemporalQuery的签名,允许其通过方法参考LocalDateTime::from用作查询。

        参数
        temporal - 要转换的临时对象,而不是null
        结果
        本地日期时间,不为空
        异常
        DateTimeException - 如果无法转换为 LocalDateTime
        另请参见:
        Chronology.localDateTime(TemporalAccessor)
      • parse

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

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

        参数
        text - 要解析的文本,例如“2007-12-03T10:15:30”,不为null
        结果
        解析的本地日期时间,而不是null
        异常
        DateTimeParseException - 如果无法解析文本
      • parse

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

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

        参数
        text - 要解析的文本,而不是null
        formatter - 要使用的格式化程序,而不是null
        结果
        解析的本地日期时间,而不是null
        异常
        DateTimeParseException - 如果无法解析文本
      • isSupported

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

        这将检查是否可以查询指定字段的日期时间。 如果是假,然后调用rangegetwith(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作为参数来获得此方法的结果。 字段是否受支持由字段确定。

        Specified by:
        isSupported在界面 ChronoLocalDateTime<LocalDate>
        Specified by:
        isSupported ,界面 TemporalAccessor
        参数
        字段 - 要检查的字段,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作为参数来获得此方法的结果。 设备是否受支持由设备决定。

        Specified by:
        isSupported在界面 ChronoLocalDateTime<LocalDate>
        Specified by:
        isSupported ,界面 Temporal
        参数
        unit - 要检查的单位,null返回false
        结果
        如果可以添加/减去单位,则为true,否则为false
      • range

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

        范围对象表示字段的最小和最大有效值。 此日期时间用于提高返回范围的准确性。 如果无法返回范围,因为不支持该字段或由于某些其他原因,将引发异常。

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

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用获得TemporalField.rangeRefinedBy(TemporalAccessor)传递this作为参数。 是否可以获得范围由该字段确定。

        Specified by:
        range接口 TemporalAccessor
        参数
        字段 - 要查询范围的字段,而不是null
        结果
        字段的有效值范围,不为null
        异常
        DateTimeException - 如果无法获得该字段的范围
        UnsupportedTemporalTypeException - 如果不支持该字段
      • get

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

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

        如果该字段是ChronoField则在此处执行查询。 supported fields将返回基于此日期时间有效值,除了NANO_OF_DAYMICRO_OF_DAYEPOCH_DAYPROLEPTIC_MONTH这是太大,无法在int并抛出UnsupportedTemporalTypeException 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段不是ChronoField ,则通过调用TemporalField.getFrom(TemporalAccessor)传递this作为参数来获得此方法的结果。 是否可以获得该值以及该值表示的值由该字段确定。

        Specified by:
        get在界面 TemporalAccessor
        参数
        字段 - 要获取的字段,而不是null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值范围
        UnsupportedTemporalTypeException - 如果不支持该字段或值的范围超过 int
        ArithmeticException - 如果发生数字溢出
      • getLong

        public long getLong​(TemporalField field)
        从此日期时间获取指定字段的值,作为long

        这将查询此日期时间以获取指定字段的值。 如果无法返回该值,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处执行查询。 supported fields将根据此日期时间返回有效值。 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段不是ChronoField ,则通过调用TemporalField.getFrom(TemporalAccessor)传递this作为参数来获得此方法的结果。 是否可以获得该值以及该值表示的值由该字段确定。

        Specified by:
        getLong ,界面 TemporalAccessor
        参数
        字段 - 要获取的字段,而不是null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获得该字段的值
        UnsupportedTemporalTypeException - 如果不支持该字段
        ArithmeticException - 如果发生数字溢出
      • toLocalDate

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

        这将返回LocalDate ,其年,月,日为该日期时间。

        Specified by:
        toLocalDate在界面 ChronoLocalDateTime<LocalDate>
        结果
        此日期时间的日期部分,不为空
      • getYear

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

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

        根据get(YEAR) ,此方法返回的年份是get(YEAR) 要获得年代,请使用get(YEAR_OF_ERA)

        结果
        年份,从MIN_YEAR到MAX_YEAR
      • getMonthValue

        public int getMonthValue()
        获取1到12之间的月份字段。

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

        结果
        月份,从1到12
        另请参见:
        getMonth()
      • getMonth

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

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

        结果
        一年中的月份,不是空的
        另请参见:
        getMonthValue()
      • 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 ,其时间,分钟,秒和纳秒与此日期时间相同。

        Specified by:
        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接口,例如MonthMonthDay 理算员负责处理特殊情况,例如不同长度的月份和闰年。

        例如,此代码返回7月最后一天的日期:

          import static java.time.Month.*;
          import static java.time.temporal.TemporalAdjusters.*;
        
          result = localDateTime.with(JULY).with(lastDayOfMonth()); 

        LocalDateLocalTime实现TemporalAdjuster ,因此该方法可用于更改日期,时间或偏移量:

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

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

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

        Specified by:
        with in interface ChronoLocalDateTime<LocalDate>
        Specified by:
        with在界面 Temporal
        参数
        adjuster - 要使用的调整器,而不是null
        结果
        a LocalDateTime基于 this并进行了调整,而不是null
        异常
        DateTimeException - 如果无法进行调整
        ArithmeticException - 如果发生数字溢出
      • with

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

        这将返回一个LocalDateTime ,基于此值,更改指定字段的值。 这可用于更改任何支持的字段,例如年,月或日。 如果无法设置该值,因为不支持该字段或由于某些其他原因,将引发异常。

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

        如果该字段是ChronoField则在此处执行调整。 supported fields将按照LocalDateLocalTime上的匹配方法运行 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段不是ChronoField ,则通过调用TemporalField.adjustInto(Temporal, long)传递this作为参数来获得此方法的结果。 在这种情况下,该字段确定是否以及如何调整瞬间。

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

        Specified by:
        with在界面 ChronoLocalDateTime<LocalDate>
        Specified by:
        with在界面 Temporal
        参数
        字段 - 要在结果中设置的字段,不为null
        newValue - 结果中字段的新值
        结果
        一个 LocalDateTime基于 this使用指定的字段设置,不为空
        异常
        DateTimeException - 如果无法设置该字段
        UnsupportedTemporalTypeException - 如果不支持该字段
        ArithmeticException - 如果发生数字溢出
      • withYear

        public LocalDateTime withYear​(int year)
        返回此LocalDateTime的副本,并更改年份。

        时间不影响计算,结果也一样。 如果该年的某一天无效,则会将其更改为该月的最后一个有效日期。

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

        参数
        year - 结果中设置的年份,从MIN_YEAR到MAX_YEAR
        结果
        a LocalDateTime基于此请求年份的日期时间,不为空
        异常
        DateTimeException - 如果年份值无效
      • withMonth

        public LocalDateTime withMonth​(int month)
        返回此LocalDateTime的副本,其中年份已更改。

        时间不影响计算,结果也一样。 如果该年的某一天无效,则会将其更改为该月的最后一个有效日期。

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

        参数
        month - 结果中设置的月份,从1(1月)到12(12月)
        结果
        a 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 - 在结果中设置的 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单位截断将第二分钟和纳秒级字段设置为零。

        该单位必须有一个duration ,分为标准日的长度,没有余数。 这包括ChronoUnitDAYS上提供的所有时间单位。 其他单位抛出异常。

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

        参数
        unit - 要截断的单位,而不是null
        结果
        基于此日期时间的 LocalDateTime ,截断时间,不为空
        异常
        DateTimeException - 如果无法截断
        UnsupportedTemporalTypeException - 如果不支持该装置
      • 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作为参数来获得此方法的结果。 在这种情况下,该单元确定是否以及如何执行添加。

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

        Specified by:
        plus在界面 ChronoLocalDateTime<LocalDate>
        Specified by:
        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的副本,并添加指定的月份数。

        此方法分三个步骤将指定的数量添加到months字段:

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

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

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

        参数
        months - 要添加的月份可能是负数
        结果
        基于此日期时间的 LocalDateTime ,添加月份,不为空
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • plusWeeks

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

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

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

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

        参数
        weeks - 要添加的周数,可能是负数
        结果
        基于此日期时间的 LocalDateTime ,添加周数,不为空
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • plusDays

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

        此方法将指定的金额添加到days字段,根据需要递增月份和年份字段,以确保结果保持有效。 结果仅在超过最大/最小年份时无效。

        例如,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的副本, LocalDateTime添加了指定的纳秒数。

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

        参数
        nanos - 要添加的 nanos ,可能是负面的
        结果
        基于此日期时间的 LocalDateTime ,加上纳秒,不为空
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • minus

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

        这将返回一个LocalDateTime ,基于此值,减去单位的数量。 如果无法减去金额,因为不支持该单位或由于某些其他原因,则抛出异常。

        该方法相当于plus(long, TemporalUnit) ,其数量为负数 有关添加和减法如何工作的完整描述,请参阅该方法。

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

        Specified by:
        minus在界面 ChronoLocalDateTime<LocalDate>
        Specified by:
        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的副本,并减去指定的月数。

        此方法分三个步骤从months字段中减去指定的金额:

        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 - 要减去的 nanos ,可能是负的
        结果
        基于此日期时间的 LocalDateTime减去纳秒,而不是空
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • query

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

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

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

        Specified by:
        query在界面 ChronoLocalDateTime<LocalDate>
        Specified by:
        query在界面 TemporalAccessor
        参数类型
        R - 结果的类型
        参数
        query - 要调用的查询,而不是null
        结果
        查询结果,可以返回null(由查询定义)
        异常
        DateTimeException - 如果无法查询(由查询定义)
        ArithmeticException - 如果发生数字溢出(由查询定义)
      • until

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

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

        计算返回一个整数,表示两个日期之间的完整单位数。 例如,2012-06-15T00:00和2012-08-14T23:59之间的月份数量仅为一个月,因为它比两个月短一分钟。

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

          // these two lines are equivalent
           amount = start.until(end, MONTHS);
           amount = MONTHS.between(start, end); 
        应该根据哪个使代码更具可读性来做出选择。

        计算在此方法中针对ChronoUnit实施 单位NANOSMICROSMILLISSECONDSMINUTESHOURSHALF_DAYSDAYSWEEKSMONTHSYEARSDECADESCENTURIESMILLENNIAERAS支持。 其他ChronoUnit值将引发异常。

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

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

        Specified by:
        until在界面 Temporal
        参数
        endExclusive - 结束日期,不包括,转换为 LocalDateTime ,不为空
        unit - 计量金额的单位,而不是空
        结果
        此日期时间与结束日期时间之间的时间量
        异常
        DateTimeException - 如果金额无法计算,或者结束时间不能转换为 LocalDateTime
        UnsupportedTemporalTypeException - 如果不支持该装置
        ArithmeticException - 如果发生数字溢出
      • format

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

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

        Specified by:
        format在界面 ChronoLocalDateTime<LocalDate>
        参数
        formatter - 要使用的格式化程序,而不是null
        结果
        格式化的日期时间字符串,不为空
        异常
        DateTimeException - 如果在打印期间发生错误
      • atOffset

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

        这将返回由此日期时间在指定偏移量处形成的OffsetDateTime 日期时间和偏移的所有可能组合都是有效的。

        参数
        offset - 要与之结合的偏移量,而不是null
        结果
        从此日期时间和指定的偏移量形成的偏移日期时间,不为空
      • atZone

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

        这将返回在指定时区的此日期时间形成的ZonedDateTime 结果将尽可能与此日期时间匹配。 时区规则(例如夏令时)意味着并非每个本地日期时间对指定区域都有效,因此可以调整本地日期时间。

        本地日期时间在时间线上解析为单个瞬间。 这是通过从区域ID的rules定义的本地日期时间中找到UTC / Greenwich的有效偏移量来实现的。

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

        在间隙的情况下,时钟向前跳跃,没有有效的偏移。 相反,将本地日期时间调整为稍后的间隙长度。 对于典型的一小时夏令时变化,本地日期时间将在一小时后移动到通常对应于“夏天”的偏移量。

        要在重叠期间获得后续偏移,请对此方法的结果调用ZonedDateTime.withLaterOffsetAtOverlap() 要在存在间隙或重叠时抛出异常,请使用ZonedDateTime.ofStrict(LocalDateTime, ZoneOffset, ZoneId)

        Specified by:
        atZone在界面 ChronoLocalDateTime<LocalDate>
        参数
        zone - 要使用的时区,不是空
        结果
        从此日期时间形成的分区日期时间,而不是null
      • 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()方法相同。

        Specified by:
        isAfter在界面 ChronoLocalDateTime<LocalDate>
        参数
        other - 要比较的其他日期时间,而不是null
        结果
        如果此日期时间在指定的日期时间之后,则为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()方法相同。

        Specified by:
        isBefore在界面 ChronoLocalDateTime<LocalDate>
        参数
        other - 要比较的其他日期时间,而不是null
        结果
        如果此日期时间早于指定的日期时间,则为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()方法相同。

        Specified by:
        isEqual在界面 ChronoLocalDateTime<LocalDate>
        参数
        other - 要比较的其他日期时间,而不是null
        结果
        如果此日期时间等于指定的日期时间,则为true
      • equals

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

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

        Specified by:
        equals在界面 ChronoLocalDateTime<LocalDate>
        重写:
        equals在课程 Object
        参数
        obj - 要检查的对象,null返回false
        结果
        如果这等于其他日期时间,则为true
        另请参见:
        Object.hashCode()HashMap
      • 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
        使用的格式将是最短的,输出省略的部分隐含为零的时间的完整值。
        Specified by:
        toString在界面 ChronoLocalDateTime<LocalDate>
        重写:
        toString in class Object
        结果
        此日期时间的字符串表示形式,不为null