Module  java.base
软件包  java.time

Class LocalDateTime

  • All Implemented Interfaces:
    SerializableComparable<LocalDate>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 - 要使用的时钟,不为空
        结果
        当前日期时间,不为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表示的小时
        结果
        本地日期时间,不为空
        异常
        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的秒表示
        结果
        本地日期时间,不为空
        异常
        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的纳秒
        结果
        本地日期时间,不为空
        异常
        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 - 即时创建日期时间,不为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的实例。

        这可以基于指定的时间获取本地日期时间。 A 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
        异常
        DateTimeParseException - 如果文本无法解析
      • parse

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

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

        参数
        text - 要解析的文本,不为空
        formatter - 使用的格式化程序,不为空
        结果
        解析的本地日期时间,不为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
        参数
        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作为参数。 设备是否受支持由本机决定。

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

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

        范围对象表示字段的最小和最大有效值。 此日期时间用于提高返回范围的准确性。 如果不可能返回范围,因为该字段不受支持或出于某种其他原因,则抛出异常。

        如果该字段是一个ChronoField那么查询是在这里实现的。 supported fields将返回适当的范围实例。 所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException

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

        Specified by:
        range在接口 TemporalAccessor
        参数
        field - 查询范围的字段,不为空
        结果
        字段的有效值的范围不为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
        参数
        field - 要获取的字段,不为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
        参数
        field - 要获取的字段,不为null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获取字段的值
        UnsupportedTemporalTypeException - 如果该字段不被支持
        ArithmeticException - 如果发生数字溢出
      • toLocalDate

        public LocalDate toLocalDate​()
        获取LocalDate这个日期时间的一部分。

        这将返回一个与此日期时间相同的年份,月份和日期的LocalDate

        Specified by:
        toLocalDate在接口 ChronoLocalDateTime<LocalDate>
        结果
        此日期时间的日期部分不为null
      • getYear

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

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

        通过这种方法返回的年份是按照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的原始值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>
        结果
        这个日期时间的一部分,不是null
      • 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); 

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

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

        Specified by:
        with在接口 ChronoLocalDateTime<LocalDate>
        Specified by:
        with在接口 Temporal
        参数
        adjuster - 调整器使用,不为空
        结果
        一个 LocalDateTime基于 this进行了调整,不为null
        异常
        DateTimeException - 如果不能进行调整
        ArithmeticException - 如果发生数字溢出
      • with

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

        这将返回一个LocalDateTime ,基于此,更改指定字段的值。 这可以用于更改任何支持的字段,例如年,月或月。 如果不可能设置该值,因为该字段不受支持或出于某种其他原因,则抛出异常。

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

        如果该字段是ChronoField则在此处实现调整。 supported fields将按照LocalDateLocalTime的匹配方法进行操作 所有其他ChronoField实例都会抛出一个UnsupportedTemporalTypeException

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

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

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

        public LocalDateTime withYear​(int year)
        返回该LocalDateTime的副本。

        时间不影响计算,结果将相同。 如果一年中的日期无效,它将被更改为该月的最后一个有效日期。

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

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

        public LocalDateTime withMonth​(int month)
        返回此LocalDateTime的副本,并更改月份。

        时间不影响计算,结果将相同。 如果一年中的日期无效,它将被更改为该月的最后一个有效日期。

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

        参数
        month - 从1月(1月)到12月(12月),确定结果的月份
        结果
        一个 LocalDateTime基于这个日期时间与请求的月份,不为null
        异常
        DateTimeException - 如果月份值无效
      • withDayOfMonth

        public LocalDateTime withDayOfMonth​(int dayOfMonth)
        返回LocalDateTime的副本,并更改日期。

        如果生成的日期时间无效,则抛出异常。 时间不影响计算,结果将相同。

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

        参数
        dayOfMonth - 在结果中设置的月份,从1到28-31
        结果
        一个 LocalDateTime基于这个日期时间与请求的一天,不为null
        异常
        DateTimeException - 如果月日的价值无效,或者月的月日无效月月
      • withDayOfYear

        public LocalDateTime withDayOfYear​(int dayOfYear)
        返回此LocalDateTime更改的LocalDateTime的副本。

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

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

        参数
        dayOfYear - 设定结果的日期,从1到365-366
        结果
        一个 LocalDateTime基于这个日期与请求的一天,不为null
        异常
        DateTimeException - 如果日期年值无效,或者如果当年的日期无效
      • withHour

        public LocalDateTime withHour​(int hour)
        返回此LocalDateTime的副本,并更改日期。

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

        参数
        hour - 设置结果的时间从0到23
        结果
        一个 LocalDateTime基于这个日期时间与请求的小时,不为null
        异常
        DateTimeException - 如果小时值无效
      • withMinute

        public LocalDateTime withMinute​(int minute)
        返回此LocalDateTime的副本,小时改变。

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

        参数
        minute - 结果中设置的小时从0到59
        结果
        一个 LocalDateTime基于这个日期时间与请求的分钟,不为null
        异常
        DateTimeException - 如果分钟值无效
      • withSecond

        public LocalDateTime withSecond​(int second)
        返回此LocalDateTime的副本,其中第二分钟更改。

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

        参数
        second - 设置结果的 second ,从0到59
        结果
        一个 LocalDateTime基于这个日期时间与请求的第二个,不为null
        异常
        DateTimeException - 如果第二个值无效
      • withNano

        public LocalDateTime withNano​(int nanoOfSecond)
        返回此LocalDateTime的副本,其中纳秒修改。

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

        参数
        nanoOfSecond - 纳秒在结果中设置,从0到999,999,999
        结果
        一个 LocalDateTime基于这个日期时间与请求的纳秒,不为null
        异常
        DateTimeException - 如果纳米值无效
      • truncatedTo

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

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

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

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

        参数
        unit - 截断到的单位,不为null
        结果
        一个 LocalDateTime基于此日期时间截断,不为null
        异常
        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 - 要添加的单位,不为null
        结果
        一个 LocalDateTime基于这个日期时间加上指定的数量,不为null
        异常
        DateTimeException - 如果不能添加
        UnsupportedTemporalTypeException - 如果不支持本机
        ArithmeticException - 如果发生数字溢出
      • plusYears

        public LocalDateTime plusYears​(long years)
        返回此LocalDateTime的副本,并附加指定的年数。

        该方法通过三个步骤将指定的数量添加到年份字段:

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

        例如,2008-02-29(闰年)加上一年将导致无效日期2009-02-29(标准年)。 而不是返回无效结果,而是选择2009-02-28的最后一个有效日期。

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

        参数
        years - 多年来补充,可能是负数
        结果
        一个 LocalDateTime基于这个日期时间与添加的年份,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • plusMonths

        public LocalDateTime plusMonths​(long months)
        返回此LocalDateTime的副本,并附加指定的月数。

        此方法通过三个步骤将指定的数量添加到月份字段:

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

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

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

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

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

        该方法将指定的数量以周为单位,根据需要增加月份和年份字段的日期字段,以确保结果保持有效。 如果超过最大/最小年份,结果将无效。

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

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

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

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

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

        例如,2008-12-31加上一天会导致2009-01-01。

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

        参数
        days - 添加的日子可能为负数
        结果
        一个 LocalDateTime基于这个日期时间与添加的天数,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • plusHours

        public LocalDateTime plusHours​(long hours)
        返回此LocalDateTime的副本,并附加指定的小时数。

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

        参数
        hours - 要添加的时间可能为负数
        结果
        一个 LocalDateTime基于这个日期时间加上小时,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • plusMinutes

        public LocalDateTime plusMinutes​(long minutes)
        返回此LocalDateTime的副本,并附加指定的分钟数。

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

        参数
        minutes - 要添加的分钟,可能为负数
        结果
        一个 LocalDateTime基于这个日期时间添加分钟,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • plusSeconds

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

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

        参数
        seconds - 添加的秒数可能为负数
        结果
        一个 LocalDateTime基于这个日期时间添加的秒,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • plusNanos

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

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

        参数
        nanos - nanos添加,可能为负数
        结果
        一个 LocalDateTime基于这个日期时间加上纳秒,不为null
        异常
        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基于此日期时间减去指定的数量,不为null
        异常
        DateTimeException - 如果不能进行减法
        UnsupportedTemporalTypeException - 如果不支持本机
        ArithmeticException - 如果发生数字溢出
      • minusYears

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

        该方法从三个步骤中减去指定的数量:

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

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

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

        参数
        years - 减去年份,可能为负数
        结果
        一个 LocalDateTime基于这个日期时间与减去的年份,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • minusMonths

        public LocalDateTime minusMonths​(long months)
        返回此LocalDateTime的副本,并减去指定的月数。

        该方法从以下三个步骤中减去月份字段中指定的数量:

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

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

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

        参数
        months - 减去数月,可能为负数
        结果
        一个 LocalDateTime基于这个日期时间与减去的月份,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • minusWeeks

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

        该方法从必要的日期字段减去月和年字段中减去指定的数量,以确保结果保持有效。 如果超过最大/最小年份,结果将无效。

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

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

        参数
        weeks - 减去星期,可能为负数
        结果
        一个 LocalDateTime基于这个日期时间与减去的星期,不为null
        异常
        DateTimeException - 如果结果超出了支持的日期范围
      • minusDays

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

        该方法根据需要减去月份和年份字段的日期字段减去指定的金额,以确保结果保持有效。 如果超过最大/最小年份,结果将无效。

        例如,2009-01-01减去一天会导致2008-12-31。

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

        参数
        days - 减去的日子,可能是负数
        结果
        一个 LocalDateTime基于这个日期时间减去的日期,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • minusHours

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

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

        参数
        hours - 减去的时间可能为负数
        结果
        一个 LocalDateTime基于这个日期时间减去小时,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • minusMinutes

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

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

        参数
        minutes - 减去的分数可能为负数
        结果
        一个 LocalDateTime基于这个日期时间减去分钟,而不是null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • minusSeconds

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

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

        参数
        seconds - 减去的秒数可能为负数
        结果
        一个 LocalDateTime基于此日期时间减去秒,不为空
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • minusNanos

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

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

        参数
        nanos - nanos减去,可能是负的
        结果
        一个 LocalDateTime基于这个日期时间减去纳秒,不为null
        异常
        DateTimeException - 如果结果超出支持的日期范围
      • query

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

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

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

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

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

        这可以计算一个LocalDateTime对象之间的时间量,单个TemporalUnit 起点和终点是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 - 要组合的偏移量,不为空
        结果
        从此日期时间形成的偏移日期时间和指定的偏移量,不为空
      • atZone

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

        这将从指定时区的此日期时间返回一个ZonedDateTime 结果将尽可能接近日期时间。 时区规则(如夏令时)意味着并非每个本地日期时间对指定的区域都有效,因此可能会调整本地日期时间。

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

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

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

        要在重叠期间获得稍后的偏移量,请致电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类型的LocalDateTime进行比较,其他类型返回false。

        Specified by:
        equals在接口 ChronoLocalDateTime<LocalDate>
        重写:
        equalsObject
        参数
        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>
        重写:
        toStringObject
        结果
        此日期时间的字符串表示形式,不为null