Java 8 新特新 工具类 ZonedDateTime

类ZonedDateTime

  • 所有实现的接口：
    Serializable，Comparable < ChronoZonedDateTime <？>>，ChronoZonedDateTime < LocalDate >，Temporal，TemporalAccessor

    public final class ZonedDateTime 
extends Object 
实现Temporal，ChronoZonedDateTime < LocalDate >，Serializable
    带有ISO-8601日历系统中的时区的日期时间，例如2007-12-03T10:15:30+01:00 Europe/Paris。

    ZonedDateTime是具有时区的日期时间的不可变表示。该类将所有日期和时间字段存储为精确度为纳秒的时区以及用于处理模糊的本地日期时间的区域偏移量的时区。例如，可以将“2007年10月2日在13：45.30.123456789 +02：00在欧洲/巴黎时区”的值存储在a中ZonedDateTime。

    这个类处理从本地时间线LocalDateTime 到即时时间线的转换Instant。两条时间线之间的差异是UTC /格林威治的偏移量，用a表示ZoneOffset。

    在两条时间线之间转换涉及使用rules从中访问的偏移量来计算偏移量 ZoneId。获得瞬间偏移很简单，因为每个瞬间只有一个有效偏移量。相比之下，获取本地日期时间的偏移量并不简单。有三种情况：

    • 正常，有一个有效的偏移量。对于一年中绝大多数时间，正常情况下适用，当地日期时间有一个有效偏移量。
    • 差距，零有效抵消。这通常是由于春季夏令时从“冬季”变为“夏季”时，时钟向前跳跃。在缺口中存在没有有效偏移量的本地日期 - 时间值。
    • 重叠，有两个有效的偏移量。这通常是由于秋季夏令时从“夏季”变为“冬季”，因此时钟退回。在重叠处有本地日期时间值和两个有效偏移量。

    任何通过获取偏移量直接或隐式地从本地日期时间转换为瞬间的方法都有可能变得复杂。

    对于差距，一般策略是，如果当地日期时间落在间隙的中间，则所产生的分区日期时间将具有当地日期时间向前偏移Gap的长度，从而导致日期 - 时间在后面的偏移中，通常是“夏天”时间。

    对于重叠，一般策略是，如果本地日期 - 时间落在重叠的中间，那么之前的偏移将被保留。如果没有先前的偏移量，或者先前的偏移量无效，则使用较早的偏移量，通常为“夏季”时间。另外两种方法，withEarlierOffsetAtOverlap()并withLaterOffsetAtOverlap()帮助管理重叠情况。

    在设计方面，这个类应该主要被看作是a LocalDateTime和a 的组合ZoneId。这ZoneOffset是一个重要但次要的信息，用于确保课程表示一个瞬间，特别是在夏令时重叠期间。

    这是一个基于价值的 课程; ==对实例使用身份敏感操作（包括引用相等（），身份哈希代码或同步） ZonedDateTime可能会产生不可预知的结果，应予以避免。该equals方法应该用于比较。

    实施要求：
    一个ZonedDateTime持有状态相当于三个单独的对象，a LocalDateTime，a ZoneId和已解决ZoneOffset。偏移量和本地日期时间用于在必要时定义一个瞬间。区域ID用于获取偏移量如何以及何时更改的规则。偏移不能自由设置，因为区域控制哪些偏移有效。

    这个类是不可变的，线程安全的。

    以来：
    1.8
    也可以看看：
    序列化表格

    • 方法细节

      • 现在

        公共静态  ZonedDateTime  now（）
        从默认时区的系统时钟获取当前日期时间。

        这将查询system clock默认时区以获取当前日期时间。区域和偏移量将根据时钟中的时区进行设置。

        使用这种方法会阻止使用备用时钟进行测试，因为时钟是硬编码的。

        返回：
        当前使用系统时钟的日期时间不为空

      • 现在

        公共静态  ZonedDateTime  现在（ZoneId  区域）
        从指定时区的系统时钟获取当前日期时间。

        这将查询system clock获取当前的日期时间。指定时区避免了对默认时区的依赖。偏移量将从指定的时区计算得出。

        使用这种方法会阻止使用备用时钟进行测试，因为时钟是硬编码的。

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

      • 现在

        公共静态  ZonedDateTime  现在（时钟  钟）
        从指定时钟获取当前日期时间。

        这将查询指定时钟以获取当前日期时间。区域和偏移量将根据时钟中的时区进行设置。

        使用这种方法允许使用另一个时钟进行测试。备用时钟可能会使用dependency injection。

        参数：
        clock - 使用的时钟，不为空
        返回：
        当前的日期时间，不为空

      • 的

        公共静态  ZonedDateTime  的（LOCALDATE的  日期，
                                本地时间  时，
                                了zoneid  区）
        获取ZonedDateTime当地日期和时间的实例。

        这将尽可能地创建与输入的本地日期和时间相匹配的分区日期时间。时区规则（如夏令时）意味着并非每个本地日期时间对指定区域均有效，因此可以调整本地日期时间。

        本地日期时间和第一次合并形成本地日期时间。然后，本地日期时间将在时间线上解析为一个瞬间。这是通过根据rules区域ID 所定义的本地日期时间找到UTC /格林威治的有效偏移量来实现的。

        在大多数情况下，本地日期时间只有一个有效偏移量。在重叠的情况下，当时钟恢复时，有两个有效的偏移量。此方法使用通常对应于“夏季”的较早的偏移量。

        在差距的情况下，当时钟向前跳转时，没有有效的偏移量。相反，将本地日期时间调整为稍后的差距。对于典型的一小时夏令时更改，本地日期时间将在一小时后移至通常对应于“夏季”的偏移量。

        参数：
        date - 本地日期，不为空
        time - 当地时间，不为空
        zone - 时区，不为空
        返回：
        偏移日期时间，不为空

      • 的

         （LocalDateTime  localDateTime，
                                ZoneId  区域）的公共静态  ZonedDateTime
        获取ZonedDateTime当地日期时间的实例。

        这会尽可能地创建与输入本地日期时间匹配的分区日期时间。时区规则（如夏令时）意味着并非每个本地日期时间对指定区域均有效，因此可以调整本地日期时间。

        本地日期时间在时间​​线上被解析为一个瞬间。这是通过根据rules区域ID 所定义的本地日期时间找到UTC /格林威治的有效偏移量来实现的。

        在大多数情况下，本地日期时间只有一个有效偏移量。在重叠的情况下，当时钟恢复时，有两个有效的偏移量。此方法使用通常对应于“夏季”的较早的偏移量。

        在差距的情况下，当时钟向前跳转时，没有有效的偏移量。相反，将本地日期时间调整为稍后的差距。对于典型的一小时夏令时更改，本地日期时间将在一小时后移至通常对应于“夏季”的偏移量。

        参数：
        localDateTime - 本地日期时间，不为空
        zone - 时区，不为空
        返回：
        分区日期时间，不为空

      • 的

        公共静态  ZonedDateTime  （int年，
                               int月份，
                               int dayOfMonth，
                               int小时，
                               int分钟，
                               int second，
                               int nanoOfSecond，
                               ZoneId  区域）
        获取ZonedDateTime年，月，日，时，分，秒，纳秒和时区的实例。

        这将尽可能地创建与七个指定字段的本地日期时间相匹配的分区日期时间。时区规则（如夏令时）意味着并非每个本地日期时间对指定区域均有效，因此可以调整本地日期时间。

        本地日期时间在时间​​线上被解析为一个瞬间。这是通过根据rules区域ID 所定义的本地日期时间找到UTC /格林威治的有效偏移量来实现的。

        在大多数情况下，本地日期时间只有一个有效偏移量。在重叠的情况下，当时钟恢复时，有两个有效的偏移量。此方法使用通常对应于“夏季”的较早的偏移量。

        在差距的情况下，当时钟向前跳转时，没有有效的偏移量。相反，将本地日期时间调整为稍后的差距。对于典型的一小时夏令时更改，本地日期时间将在一小时后移至通常对应于“夏季”的偏移量。

        此方法主要用于编写测试用例。非测试代码通常会使用其他方法来创建偏移时间。 LocalDateTime有五个额外的方便变体等价的工厂方法，参数较少。这里没有提供它们来减少API的占用空间。

        参数：
        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代表纳秒级
        zone - 时区，不为空
        返回：
        偏移日期时间，不为空
        抛出：
        DateTimeException - 如果任何字段的值超出范围，或者月份的月份对该月份无效

      • ofLocal

        公共静态  ZonedDateTime  ofLocal（LocalDateTime  localDateTime，
                                     ZoneId  区域，
                                     ZoneOffset  preferredOffset）
        ZonedDateTime如果可能，使用偏好的偏移量从本地日期时间获取实例。

        本地日期时间在时间​​线上被解析为一个瞬间。这是通过根据rules区域ID 所定义的本地日期时间找到UTC /格林威治的有效偏移量来实现的。

        在大多数情况下，本地日期时间只有一个有效偏移量。在时钟重新设置的情况下，有两个有效的偏移量。如果首选偏移量是有效偏移量之一，则使用它。否则使用较早的有效偏移量，通常对应于“夏季”。

        在时钟向前跳转的情况下，没有有效的偏移量。相反，将本地日期时间调整为稍后的差距。对于典型的一小时夏令时更改，本地日期时间将在一小时后移至通常对应于“夏季”的偏移量。

        参数：
        localDateTime - 本地日期时间，不为空
        zone - 时区，不为空
        preferredOffset - 区域偏移量，如果没有首选项，则为null
        返回：
        分区日期时间，不为空

      • ofInstant

        公共静态  ZonedDateTime  ofInstant（即时  即时，
                                       ZoneId  区域）
        ZonedDateTime从一个实例中获得一个实例Instant。

        这将创建一个与指定时间相同的分区日期时间。呼叫ChronoZonedDateTime.toInstant()将返回与此处使用的相同的时刻。

        将瞬间转换为分区日期时间非常简单，因为每个时刻只有一个有效偏移量。

        参数：
        instant - 从非null创建日期时间的时刻
        zone - 时区，不为空
        返回：
        分区日期时间，不为空
        抛出：
        DateTimeException - 如果结果超出支持的范围

      • ofInstant

        公共静态  ZonedDateTime  ofInstant（LocalDateTime  localDateTime，
                                       ZoneOffset  偏移量，
                                       ZoneId  区域）
        ZonedDateTime从组合本地日期时间和偏移量所获得的瞬间获得一个实例。

        这将创建一个分区的日期时间combining 的LocalDateTime和ZoneOffset。这种组合唯一地指定了一个没有歧义的时刻。

        将瞬间转换为分区日期时间非常简单，因为每个时刻只有一个有效偏移量。如果有效偏移量与指定偏移量不同，则划分日期时间的日期时间和偏移量将与指定的不同。

        如果ZoneId要使用的是a ZoneOffset，则此方法等同于of(LocalDateTime, ZoneId)。

        参数：
        localDateTime - 本地日期时间，不为空
        offset - 区域偏移量，不为空
        zone - 时区，不为空
        返回：
        分区日期时间，不为空

      • ofStrict

        公共静态  ZonedDateTime  ofStrict（LocalDateTime  localDateTime，
                                      ZoneOffset  偏移量，
                                      ZoneId  区域）
        获取ZonedDateTime严格验证本地日期时间，偏移量和区域ID组合的实例。

        这会根据指定区域的规则创建分区日期时间，以确保偏移对本地日期时间有效。如果偏移量无效，则抛出异常。

        参数：
        localDateTime - 本地日期时间，不为空
        offset - 区域偏移量，不为空
        zone - 时区，不为空
        返回：
        分区日期时间，不为空

      • 从

        公共静态  ZonedDateTime  来自（TemporalAccessor  temporal）
        ZonedDateTime从一个时间对象中获得一个实例。

        这将根据指定的时间获取分区日期时间。A TemporalAccessor表示一组任意的日期和时间信息，该工厂将其转换为一个实例ZonedDateTime。

        该转换将首先ZoneId从时间对象中获得一个，ZoneOffset如果需要的话，将转换回来。然后它会尝试获得一个Instant，LocalDateTime如果有必要的话，会回落。结果将是ZoneId或ZoneOffset与Instant或的组合LocalDateTime。允许实现执行优化，例如访问与相关对象等效的那些字段。

        该方法匹配功能接口的签名，TemporalQuery 允许通过方法引用将其用作查询ZonedDateTime::from。

        指定者：
        from 在界面中 ChronoZonedDateTime<LocalDate>
        参数：
        temporal - 要转换的时间对象，不为null
        返回：
        分区日期时间，不为空
        抛出：
        DateTimeException - 如果无法转换为 ZonedDateTime
        也可以看看：
        Chronology.zonedDateTime(TemporalAccessor)

      • 解析

        公共静态  ZonedDateTime  解析（CharSequence  文本）
        ZonedDateTime从文本字符串中获得一个实例，如 2007-12-03T10:15:30+01:00[Europe/Paris]。

        该字符串必须表示一个有效的日期时间，并使用该语法进行分析 DateTimeFormatter.ISO_ZONED_DATE_TIME。

        参数：
        text - 要解析的文本，例如“2007-12-03T10：15：30 + 01：00 [Europe / Paris]”，not null
        返回：
        解析后的分区日期时间不为空
        抛出：
        DateTimeParseException - 如果文本不能被解析

      • 解析

        公共静态  ZonedDateTime  解析（CharSequence  文本，
                                   DateTimeFormatter  格式化程序）
        ZonedDateTime使用特定格式化程序从文本字符串中获取实例。

        文本使用格式化程序进行分析，返回日期时间。

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

      • 则isSupported

        public boolean isSupported（TemporalField  field）
        检查指定的字段是否受支持。

        这将检查是否可以查询指定字段的日期时间。如果是假，然后调用range， get并且with(TemporalField, long) 方法会抛出异常。

        如果该字段是a，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
        • INSTANT_SECONDS
        • OFFSET_SECONDS
        所有其他ChronoField实例将返回false。

        如果该字段不是a ChronoField，则通过调用TemporalField.isSupportedBy(TemporalAccessor) 传递this作为参数来获得此方法的结果。该领域是否得到支持取决于该领域。

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

      • 则isSupported

        public boolean isSupported（TemporalUnit  unit）
        检查指定的单位是否受支持。

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

        如果单位是一个，ChronoUnit那么在这里执行查询。支持的单位是：

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

        如果单位不是a ChronoUnit，则通过调用TemporalUnit.isSupportedBy(Temporal) 传递this作为参数来获得此方法的结果。单位是否受支持取决于单位。

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

      • 范围

        公共  ValueRange  范围（TemporalField  字段）
        获取指定字段的有效值范围。

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

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

        如果该字段不是a ChronoField，则通过调用TemporalField.rangeRefinedBy(TemporalAccessor) 传递this作为参数来获得此方法的结果。范围是否可以取得是由现场决定的。

        指定者：
        range 在界面中 ChronoZonedDateTime<LocalDate>
        指定者：
        range 在界面中 TemporalAccessor
        参数：
        field - 查询范围的字段不为null
        返回：
        该字段的有效值范围不为空
        抛出：
        DateTimeException - 如果无法获得该字段的范围
        UnsupportedTemporalTypeException - 如果该字段不受支持

      • 得到

        public int get（TemporalField  field）
        从该日期时间获取指定字段的值作为int。

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

        如果该字段是a，ChronoField则在此处执行查询。该supported fields会返回基于此日期时间有效值，除了NANO_OF_DAY，MICRO_OF_DAY， EPOCH_DAY，PROLEPTIC_MONTH和INSTANT_SECONDS它是太大，无法在int和抛出DateTimeException。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。

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

        指定者：
        get 在界面中 ChronoZonedDateTime<LocalDate>
        指定者：
        get 在界面中 TemporalAccessor
        参数：
        field - 要获取的字段，而不是null
        返回：
        该字段的值
        抛出：
        DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值范围
        UnsupportedTemporalTypeException - 如果该字段不受支持或值的范围超过 int
        ArithmeticException - 如果数字溢出发生

      • getLong

        public long getLong（TemporalField  字段）
        从该日期时间获取指定字段的值作为a long。

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

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

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

        指定者：
        getLong 在界面中 ChronoZonedDateTime<LocalDate>
        指定者：
        getLong 在界面中 TemporalAccessor
        参数：
        field - 要获取的字段，而不是null
        返回：
        该字段的值
        抛出：
        DateTimeException - 如果无法获得该字段的值
        UnsupportedTemporalTypeException - 如果该字段不受支持
        ArithmeticException - 如果数字溢出发生

      • 的getOffset

        public  ZoneOffset  getOffset（）
        获取区域偏移量，例如'+01：00'。

        这是UTC /格林威治当地日期时间的偏移量。

        指定者：
        getOffset 在界面中 ChronoZonedDateTime<LocalDate>
        返回：
        区域偏移量不为空

      • withEarlierOffsetAtOverlap

        public  ZonedDateTime  withEarlierOffsetAtOverlap（）
        返回此日期时间的副本，将区域偏移更改为本地时间线重叠处的两个有效偏移中较早的一个。

        当本地时间线重叠时，例如在秋季夏令时切换时，此方法仅具有任何效果。在这种情况下，本地日期时间有两个有效的偏移量。调用此方法将返回一个分区日期时间与选定的两个中较早的时间。

        如果此方法在不重叠时被调用，this 则返回。

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

        指定者：
        withEarlierOffsetAtOverlap 在界面中 ChronoZonedDateTime<LocalDate>
        返回：
        一个ZonedDateTime基于此日期，时间与先前的偏移，不为空

      • withLaterOffsetAtOverlap

        公共  ZonedDateTime  withLaterOffsetAtOverlap（）
        返回此日期时间的副本，将区域偏移更改为在本地时间线重叠处的两个有效偏移中较晚的一个。

        当本地时间线重叠时，例如在秋季夏令时切换时，此方法仅具有任何效果。在这种情况下，本地日期时间有两个有效的偏移量。调用此方法将返回一个分区日期时间与所选两个中的后一个。

        如果此方法在不重叠时被调用，this 则返回。

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

        指定者：
        withLaterOffsetAtOverlap 在界面中 ChronoZonedDateTime<LocalDate>
        返回：
        一个ZonedDateTime基于此日期，时间与后来的偏移，不为空

      • getZone

        public  ZoneId  getZone（）
        获取时区，如“欧洲/巴黎”。

        这将返回区域ID。这确定了rules 确定何时以及如何与UTC /格林威治的偏差发生变化的时区。

        区域ID可能与偏移相同。如果这是真的，则任何未来的计算（例如加法或减法）都不会由于时区规则而导致复杂的边缘情况。另见withFixedOffsetZone()。

        指定者：
        getZone 在界面中 ChronoZonedDateTime<LocalDate>
        返回：
        时区，而不是空

      • withZoneSameLocal

        公共  ZonedDateTime  withZoneSameLocal（ZoneId  区域）
        使用不同的时区返回此日期时间的副本，并尽可能保留本地日期时间。

        此方法更改时区并保留本地日期时间。只有当本地日期时间对新区域无效时才会更改，使用与之相同的方法确定 ofLocal(LocalDateTime, ZoneId, ZoneOffset)。

        要更改区域并调整本地日期时间，请使用withZoneSameInstant(ZoneId)。

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

        指定者：
        withZoneSameLocal 在界面中 ChronoZonedDateTime<LocalDate>
        参数：
        zone - 要更改为的时区，而不是空
        返回：
        一个ZonedDateTime基于这个日期时间与请求的区域，不为空

      • withZoneSameInstant

        公共  ZonedDateTime  withZoneSameInstant（ZoneId  区域）
        使用不同的时区返回此日期时间的副本，并保留此时刻。

        此方法更改时区并保留时间。这通常会导致当地日期时间的更改。

        此方法基于保留相同的时刻，因此本地时间线中的间隙和重叠对结果没有影响。

        要在保持当地时间的情况下更改偏移量，请使用withZoneSameLocal(ZoneId)。

        指定者：
        withZoneSameInstant 在界面中 ChronoZonedDateTime<LocalDate>
        参数：
        zone - 要更改为的时区，而不是空
        返回：
        一个ZonedDateTime基于这个日期时间与请求的区域，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • withFixedOffsetZone

        public  ZonedDateTime  withFixedOffsetZone（）
        返回此日期时间的副本，并将区域ID设置为偏移量。

        这会返回区域ID与区域ID相同的区域日期时间getOffset()。结果的本地日期时间，偏移量和瞬间将与此日期时间相同。

        将日期时间设置为固定的单个偏移量意味着未来的任何计算（例如加法或减法）都不会因时区规则而导致复杂的边缘情况。由于大多数协议（如ISO-8601）仅处理偏移量，而不是基于区域的区域ID，因此在通过网络发送分区日期时间时可能也很有用。

        这相当于ZonedDateTime.of(zdt.toLocalDateTime(), zdt.getOffset())。

        返回：
        a ZonedDateTime区域ID设置为偏移量，不为空

      • toLocalDateTime

        public  LocalDateTime  toLocalDateTime（）
        获取LocalDateTime这个日期时间的一部分。

        这会返回LocalDateTime与此日期时间相同的年份，月份，日期和时间。

        指定者：
        toLocalDateTime 在界面中 ChronoZonedDateTime<LocalDate>
        返回：
        此日期时间的本地日期时间部分，不为空

      • toLocalDate

        public  LocalDate  toLocalDate（）
        获取LocalDate这个日期时间的一部分。

        这会返回LocalDate与此日期时间相同的年份，月份和日期。

        指定者：
        toLocalDate 在界面中 ChronoZonedDateTime<LocalDate>
        返回：
        此日期时间的日期部分，不为空

      • 得到年

        public int getYear（）
        获取年份字段。

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

        这种方法返回的年份是按照每种方式预测的get(YEAR)。要获得年代，请使用get(YEAR_OF_ERA)。

        返回：
        年份，从MIN_YEAR到MAX_YEAR

      • getMonthValue

        public int getMonthValue（）
        获取从1到12的月份字段。

        此方法返回int1到12 的月份。如果Month 通过调用使用枚举，则应用程序代码通常会更清晰getMonth()。

        返回：
        从1到12的月份
        也可以看看：
        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

        公共  本地时间  toLocalTime（）
        获取LocalTime这个日期时间的一部分。

        这会返回LocalTime与此日期时间相同的小时，分​​钟，秒和纳秒。

        指定者：
        toLocalTime 在界面中 ChronoZonedDateTime<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

      • 同

        公共  ZonedDateTime  （TemporalAdjuster  调节器）
        返回此日期时间的调整副本。

        ZonedDateTime基于 这个返回一个日期 - 时间调整。调整使用指定的调整策略对象进行。阅读调节器的文档以了解将做出什么调整。

        一个简单的调节器可以简单地设置其中一个字段，例如年份字段。一个更复杂的调整者可能会将该日期设置为该月的最后一天。提供了一些常用调整 TemporalAdjusters。这些包括找到“每月的最后一天”和“下周三”。关键日期 - 时间类还实现了TemporalAdjuster接口，如Month和MonthDay。调解员负责处理特殊情况，例如月份和闰年的变化长度。

        例如，这段代码在7月的最后一天返回一个日期：

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

  result = zonedDateTime.with（JULY）.with（lastDayOfMonth（））;

        类LocalDate和LocalTime实现TemporalAdjuster，因此这个方法可以用来更改日期，时间或偏移：

          result = zonedDateTime.with（date）;
  result = zonedDateTime.with（time）;

        ZoneOffset也实现，TemporalAdjuster但是使用它作为参数通常没有效果。a的偏移ZonedDateTime主要由时区控制。因此，更改偏移量通常并不合理，因为本地日期时间和区域只有一个有效偏移量。如果分区日期时间处于夏时制重叠状态，则使用该偏移量在两个有效偏移量之间切换。在所有其他情况下，偏移量将被忽略。

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

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

        指定者：
        with 在界面中 ChronoZonedDateTime<LocalDate>
        指定者：
        with 在界面中 Temporal
        参数：
        adjuster - 使用的调整器，不为null
        返回：
        一个ZonedDateTime基于this与制造，不为空调整
        抛出：
        DateTimeException - 如果无法进行调整
        ArithmeticException - 如果数字溢出发生

      • 同

        公共  ZonedDateTime  与（TemporalField  字段，
                          长的newValue）
        返回此日期时间的副本，并将指定的字段设置为新值。

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

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

        如果该字段是a，ChronoField则在此执行调整。

        该INSTANT_SECONDS字段将返回具有指定时间的日期时间。该区和纳秒级不变。结果将有一个从新的瞬间和原始区域派生的偏移量。如果新的瞬时值超出有效范围，DateTimeException则会抛出a。

        该OFFSET_SECONDS字段通常会被忽略。a的偏移ZonedDateTime主要由时区控制。因此，更改偏移量通常并不合理，因为本地日期时间和区域只有一个有效偏移量。如果分区日期时间处于夏时制重叠状态，则使用该偏移量在两个有效偏移量之间切换。在所有其他情况下，偏移量将被忽略。如果新的偏移值超出有效范围，DateTimeException则会抛出a。

        另一个supported fields将按照上的匹配方法行事LocalDateTime。该区域不是计算的一部分，将保持不变。在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

        所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。

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

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

        指定者：
        with 在界面中 ChronoZonedDateTime<LocalDate>
        指定者：
        with 在界面中 Temporal
        参数：
        field - 在结果中设置的字段不为空
        newValue - 结果中字段的新值
        返回：
        一个ZonedDateTime基于this使用指定的字段设置，不为空
        抛出：
        DateTimeException - 如果该字段不能设置
        UnsupportedTemporalTypeException - 如果该字段不受支持
        ArithmeticException - 如果数字溢出发生

      • withYear

        public  ZonedDateTime  withYear（int year）
        ZonedDateTime在修改年份后返回此副本。

        这在本地时间线上运行， changing the year当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        year - 结果中设置的年份，从MIN_YEAR到MAX_YEAR
        返回：
        一个ZonedDateTime基于这个日期时间与请求的一年，不为空
        抛出：
        DateTimeException - 如果年份值无效

      • withMonth

        public  ZonedDateTime  withMonth（int month）
        返回此ZonedDateTime年份的复制件。

        这在本地时间线上运行， changing the month当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        month - 从1月（1月）到12月（12月）的结果中设定的月份
        返回：
        一个ZonedDateTime基于这个日期时间与请求的一个月，不为空
        抛出：
        DateTimeException - 如果月份的年份值无效

      • withDayOfMonth

        public  ZonedDateTime  withDayOfMonth（int dayOfMonth）
        ZonedDateTime在月份改变的情况下返回此副本。

        这在本地时间线上运行， changing the day-of-month当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        dayOfMonth - 结果中的月份日期，从1到28-31
        返回：
        一个ZonedDateTime基于这个日期时间与请求的天，不为空
        抛出：
        DateTimeException - 如果月份的日期值无效，或者月份的月份对该月份无效

      • withDayOfYear

        public  ZonedDateTime  withDayOfYear（int dayOfYear）
        返回此ZonedDateTime日期的副本，并更改日期。

        这在本地时间线上运行， changing the day-of-year当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        dayOfYear - 从1到365-366之间的结果中设置的日期
        返回：
        一个ZonedDateTime基于此日期与所请求的天，不为空
        抛出：
        DateTimeException - 如果日期价值无效，或年度日期无效

      • withHour

        public  ZonedDateTime  withHour（int hour）
        ZonedDateTime按每天的小时数更改返回此副本。

        这在当地时间线上运行， 改变当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        hour - 从0到23的结果中设置的小时数
        返回：
        一个ZonedDateTime基于这个日期时间与请求小时，不为空
        抛出：
        DateTimeException - 如果小时值无效

      • withMinute

        public  ZonedDateTime  withMinute（int minute）
        ZonedDateTime按小时分钟更改返回此副本。

        这在当地时间线上运行， 改变当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        minute - 从0到59的结果中设置的分钟数
        返回：
        一个ZonedDateTime基于这个日期时间与请求分钟，不为空
        抛出：
        DateTimeException - 如果分钟值无效

      • withSecond

        public  ZonedDateTime  withSecond（int second）
        ZonedDateTime在第二分钟更改后返回此副本。

        这在当地时间线上运行， 改变当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        second - 第二分钟设置结果，从0到59
        返回：
        一个ZonedDateTime基于这个日期时间与请求第二，不为空
        抛出：
        DateTimeException - 如果第二个值无效

      • withNano

        public  ZonedDateTime  withNano（int nanoOfSecond）
        ZonedDateTime使用纳秒改变来返回此副本。

        这在当地时间线上运行， 改变当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        nanoOfSecond - 在结果中设置的纳秒级，从0到999,999,999
        返回：
        一个ZonedDateTime基于这个日期时间与请求纳秒，不为空
        抛出：
        DateTimeException - 如果纳米值无效

      • truncatedTo

        public  ZonedDateTime  truncatedTo（TemporalUnit  unit）
        ZonedDateTime以截断的时间返回此副本。

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

        该单位必须有一个持续时间 ，分为标准日的长度而没有剩余时间。这包括所有提供的时间单位ChronoUnit和 DAYS。其他单位抛出异常。

        这在当地时间线上执行， truncating 即当地的日期 - 时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        unit - 要截断的单位，不为null
        返回：
        一个ZonedDateTime基于此日期，时间与时间截断，不为空
        抛出：
        DateTimeException - 如果无法截断
        UnsupportedTemporalTypeException - 如果设备不受支持

      • 加

        公共  ZonedDateTime  加（long amountToAdd，
                           TemporalUnit  单位）
        返回此日期时间的副本，并添加指定的金额。

        ZonedDateTime基于 此，返回一个以所添加单位为单位的金额。如果无法添加金额，由于该单位不受支持或出于其他原因，会引发异常。

        如果字段是a，ChronoUnit那么在这里实现添加。该区域不是计算的一部分，在结果中将保持不变。日期和时间单位的计算有所不同。

        日期单位在当地时间线上运行。该时间段首先添加到本地日期时间，然后使用区域ID转换回划分的日期时间。该转换ofLocal(LocalDateTime, ZoneId, ZoneOffset) 在添加之前与偏移一起使用。

        时间单位在即时时间线上运行。该时间段首先添加到本地日期时间，然后使用区域ID转换回划分的日期时间。该转换ofInstant(LocalDateTime, ZoneOffset, ZoneId) 在添加之前与偏移一起使用。

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

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

        指定者：
        plus 在界面中 ChronoZonedDateTime<LocalDate>
        指定者：
        plus 在界面中 Temporal
        参数：
        amountToAdd - 要添加到结果中的单位数量可能为负数
        unit - 要添加的金额单位，不为空
        返回：
        一个ZonedDateTime基于此日期，时间与规定的添加量，没有空
        抛出：
        DateTimeException - 如果不能添加
        UnsupportedTemporalTypeException - 如果设备不受支持
        ArithmeticException - 如果数字溢出发生

      • plusYears

        公共  ZonedDateTime  plus年（长年）
        返回ZonedDateTime指定年份的副本。

        这在当地时间线上运行 adding years到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        years - 增加的年份可能是负面的
        返回：
        一个ZonedDateTime基于与年增加，不为空这个日期时间
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • plusMonths

        公共  ZonedDateTime  plusMonths（长月）
        ZonedDateTime以指定的月数返回此副本。

        这在当地时间线上运行 adding months到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        months - 增加的几个月可能是负面的
        返回：
        一个ZonedDateTime基于与几个月增加，不为空这个日期时间
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • plusWeeks

        公共  ZonedDateTime  plusWeeks（长周）
        ZonedDateTime以指定的添加周数返回此副本。

        这在当地时间线上运行 adding weeks到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        weeks - 增加的几周可能是负面的
        返回：
        一个ZonedDateTime基于与周增加，不为空这个日期时间
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • plusDays

        公共  ZonedDateTime  plusDays（长天）
        ZonedDateTime以指定的添加天数返回此副本。

        这在当地时间线上运行 adding days到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        days - 增加的日子可能是消极的
        返回：
        一个ZonedDateTime基于这个日期和时间添加的日子，不是空的
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • plusHours

        公共  ZonedDateTime  plusHours（长时间）
        ZonedDateTime以指定的小时数返回此副本。

        这在现时的时间线上运行，使得增加一个小时将总是一小时后的持续时间。这可能导致本地日期 - 时间改变不是一个小时。请注意，这是与日，月和年使用的方法不同的方法，因此添加一天与添加24小时不同。

        例如，考虑春季DST切换意味着当地时间01:00至01:59发生两次从偏移量+02：00变为+01：00的时区。

        • 在00：30 + 02：00加1小时将导致01：30 + 02：00
        • 在01：30 + 02：00加1小时将导致01：30 + 01：00
        • 将1小时加入01：30 + 01：00将导致02：30 + 01：00
        • 在00：30 + 02：00加上三个小时将导致02：30 + 01：00

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

        参数：
        hours - 要添加的时间可能是负面的
        返回：
        一个ZonedDateTime基于这个日期和时间添加的时间，不是null
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • plusMinutes

        公共  ZonedDateTime  plusMinutes（长时间）
        ZonedDateTime以指定的分钟数添加返回此副本。

        这在即时时间线上运行，使得增加一分钟将总是一分钟后的持续时间。这可能会导致本地日期时间改变一分钟以外的金额。请注意，这是与日，月和年使用的方法不同的方法。

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

        参数：
        minutes - 要添加的分钟数可能是负数
        返回：
        一个ZonedDateTime基于与分钟内添加，不为空这个日期时间
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • plusSeconds

        公共  ZonedDateTime  plusSeconds（长秒）
        ZonedDateTime以指定的秒数返回此副本。

        这在当前的时间线上运行，使得增加一秒将总是一秒钟的持续时间。这可能导致本地日期 - 时间改变一秒以外的量。请注意，这是与日，月和年使用的方法不同的方法。

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

        参数：
        seconds - 添加的秒数可能是负值
        返回：
        一个ZonedDateTime基于与秒添加，不为空这个日期时间
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • plusNanos

        公共  ZonedDateTime  plusNanos（长纳米）
        ZonedDateTime以指定的纳秒数添加，返回此副本。

        这是在即时时间线上运行的，因此添加一个纳米将始终是一纳米之后的持续时间。这可能会导致本地日期时间改变一个纳米以外的量。请注意，这是与日，月和年使用的方法不同的方法。

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

        参数：
        nanos - 纳米添加，可能是负面的
        返回：
        一个ZonedDateTime基于与纳秒增加，不为空这个日期时间
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • 减去

        public  ZonedDateTime  减去（long amountToSubtract，
                            TemporalUnit  单位）
        返回此日期时间的副本，并减去指定的金额。

        这将ZonedDateTime基于这个返回一个减去单位的金额。如果无法减去金额，由于该单位不受支持或出于其他原因，会引发异常。

        日期和时间单位的计算有所不同。

        日期单位在当地时间线上运行。首先从本地日期时间中减去该时间段，然后使用区域ID将其转换回分区日期时间。转换使用ofLocal(LocalDateTime, ZoneId, ZoneOffset) 减法之前的偏移量。

        时间单位在即时时间线上运行。首先从本地日期时间中减去该时间段，然后使用区域ID将其转换回分区日期时间。转换使用ofInstant(LocalDateTime, ZoneOffset, ZoneId) 减法之前的偏移量。

        这种方法相当于plus(long, TemporalUnit)取消金额。请参阅该方法以获取加法和减法如何工作的完整说明。

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

        指定者：
        minus 在界面中 ChronoZonedDateTime<LocalDate>
        指定者：
        minus 在界面中 Temporal
        参数：
        amountToSubtract - 从结果中减去单位的数量，可能是负数
        unit - 要减去的金额单位，不为空
        返回：
        一个ZonedDateTime基于这个日期时间与指定的金额中扣除，不为空
        抛出：
        DateTimeException - 如果不能进行减法
        UnsupportedTemporalTypeException - 如果设备不受支持
        ArithmeticException - 如果数字溢出发生

      • minusYears

        公共  ZonedDateTime  minus年（长年）
        ZonedDateTime以指定的年数减去返回此副本。

        这在当地时间线上运行 subtracting years到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        years - 减去的年份可能是负值
        返回：
        一个ZonedDateTime基于这个日期时间随着年龄的增长减去，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • minusMonths

        公共  ZonedDateTime  minusMonths（长月）
        以ZonedDateTime减去指定的月数返回此副本。

        这在当地时间线上运行 subtracting months到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        months - 减去的月份可能是负值
        返回：
        一个ZonedDateTime基于此日期，时间与月相减，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • minusWeeks

        公共  ZonedDateTime  minusWeeks（长周）
        ZonedDateTime以指定的星期数减去返回此副本。

        这在当地时间线上运行 subtracting weeks到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        weeks - 减去的周数可能是负值
        返回：
        一个ZonedDateTime基于此日期，时间与周中减去，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • minusDays

        公共  ZonedDateTime  minusDays（长天）
        ZonedDateTime以指定的天数减去返回此副本。

        这在当地时间线上运行 subtracting days到当地日期时间。然后将其转换回a ZonedDateTime，使用区域ID获取偏移量。

        在转换回时ZonedDateTime，如果本地日期时间处于重叠状态，则可能时将保留偏移量，否则将使用较早的偏移量。如果在差距中，本地日期时间将按差距的长度向前调整。

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

        参数：
        days - 减去的日子可能是负面的
        返回：
        一个ZonedDateTime基于此日期，时间与天相减，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • minusHours

        公共  ZonedDateTime  minusHours（长时间）
        ZonedDateTime以指定的小时数减去返回此副本。

        这在即时时间线上运行，使得减去一小时将总是一小时前的持续时间。这可能导致本地日期 - 时间改变不是一个小时。请注意，这是与日，月和年使用的方法不同的方法，因此扣除一天不等于增加24小时。

        例如，考虑春季DST切换意味着当地时间01:00至01:59发生两次从偏移量+02：00变为+01：00的时区。

        • 从02：30 + 01：00减去1小时将导致01：30 + 02：00
        • 从01：30 + 01：00减去1小时将导致01：30 + 02：00
        • 从01：30 + 02：00减去1小时将导致00：30 + 01：00
        • 从02：30 + 01：00减去3小时将导致00：30 + 02：00

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

        参数：
        hours - 减去的时间可能是负的
        返回：
        一个ZonedDateTime基于这个日期时间中减去，而不是空的时间
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • minusMinutes

        公共  ZonedDateTime  minus分钟（长分钟）
        ZonedDateTime以指定的分钟数减去返回此副本。

        这在即时时间线上运行，使得减去一分钟总是一分钟前的持续时间。这可能会导致本地日期时间改变一分钟以外的金额。请注意，这是与日，月和年使用的方法不同的方法。

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

        参数：
        minutes - 减去的分钟数可能是负数
        返回：
        一个ZonedDateTime基于此日期，时间与分钟减去，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • minusSeconds

        公共  ZonedDateTime  minusSeconds（长秒）
        ZonedDateTime以指定的秒数减去返回此副本。

        这是在即时时间线上运行的，因此减去一秒将始终是一秒的持续时间。这可能导致本地日期 - 时间改变一秒以外的量。请注意，这是与日，月和年使用的方法不同的方法。

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

        参数：
        seconds - 减去的秒数可能为负数
        返回：
        一个ZonedDateTime基于此日期，时间与秒中减去，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • minusNanos

        公共  ZonedDateTime minus  纳诺斯（长纳米）
        ZonedDateTime以指定的纳秒数减去返回此副本。

        这在当前的时间线上运行，使得减去一个纳米将始终是一个纳米早的持续时间。这可能会导致本地日期时间改变一个纳米以外的量。请注意，这是与日，月和年使用的方法不同的方法。

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

        参数：
        nanos - 纳米减去，可能是负面的
        返回：
        一个ZonedDateTime基于此日期，时间与纳秒扣除，不为空
        抛出：
        DateTimeException - 如果结果超出支持的日期范围

      • 询问

        public R R query（TemporalQuery <R>查询）
        使用指定的查询查询此日期时间。

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

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

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

      • 直到

        公众长期以来（Temporal  endExclusive，
                   TemporalUnit  单位）
        根据指定的单位计算直到另一个日期时间的时间量。

        这将根据ZonedDateTime 单个计算两个对象之间的时间量TemporalUnit。开始点和结束点是this指定的日期时间。如果结束在开始之前，结果将为负值。例如，可以使用计算两个日期时间之间的天数startDateTime.until(endDateTime, DAYS)。

        将Temporal传递给此方法被转换为 ZonedDateTime使用from(TemporalAccessor)。如果两个区划日期时间不同，指定的结束日期时间将被标准化为具有与此日期时间相同的区域。

        该计算返回一个整数，表示两个日期时间之间完整单位的数量。例如，2012-06-15T00：00Z和2012-08-14T23：59Z之间的月数将仅为一个月，因为这是两个月的一分钟。

        有两种使用此方法的等效方法。首先是调用这个方法。其次是使用TemporalUnit.between(Temporal, Temporal)：

           //这两行是相同的
   amount = start.until（end，MONTHS）;
   金额= MONTHS.between之间（开始，结束）;
        应该根据哪个选项使代码更具可读性。

        该计算在此方法中实现ChronoUnit。单位NANOS，MICROS，MILLIS，SECONDS， MINUTES，HOURS和HALF_DAYS，DAYS， WEEKS，MONTHS，YEARS，DECADES， CENTURIES，MILLENNIA和ERAS支持。其他ChronoUnit值将引发异常。

        日期和时间单位的计算有所不同。

        日期单位使用当地日期时间在当地时间线上运行。例如，从第1天中午到第二天中午（以天为单位）的时间段总是计为一天，而不管是否存在夏令时变化。

        时间单位在即时时间线上运行。该计算有效地将分区日期时间转换为时刻，然后计算时刻之间的时段。例如，取决于是否存在日光节约变化，从第1天中午到第二天中午的时间可以是23,24或25小时（或其他量）。

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

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

        指定者：
        until 在界面中 Temporal
        参数：
        endExclusive- 结束日期，排他，转换为ZonedDateTime，不为空
        unit - 测量金额的单位，不为零
        返回：
        该日期时间与结束日期之间的时间量
        抛出：
        DateTimeException - 如果无法计算金额，或者结束时间不能转换为 ZonedDateTime
        UnsupportedTemporalTypeException - 如果设备不受支持
        ArithmeticException - 如果数字溢出发生

      • 格式

        公共  字符串  格式（DateTimeFormatter  格式化程序）
        使用指定的格式化程序格式化此日期时间。

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

        指定者：
        format 在界面中 ChronoZonedDateTime<LocalDate>
        参数：
        formatter - 要使用的格式化程序，不为null
        返回：
        格式化的日期时间字符串，不为空
        抛出：
        DateTimeException - 如果打印过程中发生错误

      • toOffsetDateTime

        public  OffsetDateTime  toOffsetDateTime（）
        将此日期时间转换为OffsetDateTime。

        这会使用本地日期时间和偏移量创建偏移日期时间。区域ID被忽略。

        返回：
        表示相同的本地日期时间和偏移量的偏移日期时间，不为空

      • 等于

        public boolean equals（Object  obj）
        检查这个日期时间是否等于另一个日期时间。

        该比较基于偏移日期时间和区域。只有类型的对象ZonedDateTime被比较，其他类型返回false。

        指定者：
        equals 在界面中 ChronoZonedDateTime<LocalDate>
        覆盖：
        equals 在班上 Object
        参数：
        obj - 要检查的对象，null返回false
        返回：
        如果这与其他日期时间相同，则为true
        也可以看看：
        Object.hashCode()， HashMap

      •  

        public  String  toString（）
        将此日期时间输出为a String，例如 2007-12-03T10:15:30+01:00[Europe/Paris]。

        格式由LocalDateTime后面的ZoneOffset。如果与ZoneId偏移量不相同，则输出ID。如果偏移量和ID相同，则输出与ISO-8601兼容。

        指定者：
        toString 在界面中 ChronoZonedDateTime<LocalDate>
        覆盖：
        toString 在班上 Object
        返回：
        此日期时间的字符串表示形式，不为null
posted on 2018-06-24 18:17  lshan  阅读(6720)  评论(0)  编辑  收藏  举报
Copyright © 2024 lshan
Powered by .NET 8.0 on Kubernetes Powered by: 博客园