Java8日期时间API

java.time.temporal

TemporalAccessor

框架级接口，定义对时间对象的只读访问，例如日期、时间、偏移量或它们的组合。

default int get(TemporalField field)
long    getLong(TemporalField field)
boolean isSupported(TemporalField field)
default <R> R   query(TemporalQuery<R> query)
default ValueRange  range(TemporalField field)

Temporal

框架级接口,继承了TemporalAccessor，增加了对日期、时间、偏移对象的plus和minus操作。

// 检查是否支持指定的单元。
boolean isSupported(TemporalUnit unit)
​
// 减法操作
default Temporal    minus(long amountToSubtract, TemporalUnit unit)
default Temporal    minus(TemporalAmount amount)
    
// 加法操作
Temporal    plus(long amountToAdd, TemporalUnit unit)
default Temporal    plus(TemporalAmount amount)
​
// 计算差值，并以指定单位返回
long    until(Temporal endExclusive, TemporalUnit unit)
​
// 根据参数对日期进行调整
default Temporal    with(TemporalAdjuster adjuster)
Temporal    with(TemporalField field, long newValue)

TemporalAdjuster

函数式接口，提供对Temporal对象的调整策略

Temporal    adjustInto(Temporal temporal)
    
 // 这两种操作都是等值的，通常选择第二种
   temporal = thisAdjuster.adjustInto(temporal);
   temporal = temporal.with(thisAdjuster);

TemporalAmount

框架级别的接口，定义了时间量，如："6 hours", "8 days" or "2 years and 3 months".

这个时间量可以看成是TemporalUnit到long值的映射。

一个简单的案例可能只有一个单位值对，比如“6小时”。更复杂的情况可能有多个单位值对，例如“7年、3个月和5天”。

两个实现类：

Period：

Period是基于日期的实现，存储年、月和日

Duration：

Duration是基于时间的实现，存储秒和纳秒，但使用其他基于持续时间的单位（如分钟、小时和固定的24小时工作日）提供一些访问。

Temporal    addTo(Temporal temporal)
long    get(TemporalUnit unit)
List<TemporalUnit>  getUnits()
Temporal    subtractFrom(Temporal temporal)

TemporalField

日期时间字段接口，例如一年中的月份或一分钟中的小时。

常用的单位定义在ChronoField.

在IsoFields、WeekFields和JulianFields中提供了更多字段

<R extends Temporal> R  adjustInto(R temporal, long newValue)
TemporalUnit    getBaseUnit()
default String  getDisplayName(Locale locale)
long    getFrom(TemporalAccessor temporal)
TemporalUnit    getRangeUnit()
boolean isDateBased()
boolean isSupportedBy(TemporalAccessor temporal)
boolean isTimeBased()
ValueRange  range()
ValueRange  rangeRefinedBy(TemporalAccessor temporal)
default TemporalAccessor    resolve(Map<TemporalField,Long> fieldValues, TemporalAccessor partialTemporal, ResolverStyle resolverStyle)
String  toString()

TemporalQuery

函数式接口，定义了查询Temporal对象的策略。

Modifier and Type	Method and Description
R	queryFrom(TemporalAccessor temporal)Queries the specified temporal object.

  // these two lines are equivalent, but the second approach is recommended
   temporal = thisQuery.queryFrom(temporal);
   temporal = temporal.query(thisQuery);

TemporalUnit

时间单位接口，常用的时间单位定义在ChronoUnit。其他IsoFields提供

Modifier and Type	Method and Description
<R extends Temporal>R	addTo(R temporal, long amount)Returns a copy of the specified temporal object with the specified period added.
long	between(Temporal temporal1Inclusive, Temporal temporal2Exclusive)Calculates the amount of time between two temporal objects.
Duration	getDuration()Gets the duration of this unit, which may be an estimate.
boolean	isDateBased()Checks if this unit represents a component of a date.
boolean	isDurationEstimated()Checks if the duration of the unit is an estimate.
default boolean	isSupportedBy(Temporal temporal)Checks if this unit is supported by the specified temporal object.
boolean	isTimeBased()Checks if this unit represents a component of a time.
String	toString()Gets a descriptive name for the unit.

IsoFields

特定于 ISO-8601 日历系统的字段和单位，包括季度和基于周的年度。

Modifier and Type	Field and Description
static TemporalField	DAY_OF_QUARTER The field that represents the day-of-quarter.
static TemporalField	QUARTER_OF_YEAR The field that represents the quarter-of-year.
static TemporalUnit	QUARTER_YEARS Unit that represents the concept of a quarter-year.
static TemporalField	WEEK_BASED_YEAR The field that represents the week-based-year.
static TemporalUnit	WEEK_BASED_YEARS The unit that represents week-based-years for the purpose of addition and subtraction.
static TemporalField	WEEK_OF_WEEK_BASED_YEAR The field that represents the week-of-week-based-year.

JulianFields

一组日期字段，用于访问Julian Days。

朱利安日是科学界常用的表达日期和时间的标准方式。

TemporalAdjusters

定义静态方法返回TemporalAdjuster

Modifier and Type	Method and Description
static TemporalAdjuster	dayOfWeekInMonth(int ordinal, DayOfWeek dayOfWeek) 一个月中的第几个星期几
static TemporalAdjuster	firstDayOfMonth() 一个月中的第一天
static TemporalAdjuster	firstDayOfNextMonth() 下个月的第一天
static TemporalAdjuster	firstDayOfNextYear() 下一年的第一天
static TemporalAdjuster	firstDayOfYear() 一年中的第一天
static TemporalAdjuster	firstInMonth(DayOfWeek dayOfWeek) 一个月中的第一个星期几
static TemporalAdjuster	lastDayOfMonth() 一个月的最后一天
static TemporalAdjuster	lastDayOfYear() 一年的最后一天
static TemporalAdjuster	lastInMonth(DayOfWeek dayOfWeek) 一月中最后一个星期几
static TemporalAdjuster	next(DayOfWeek dayOfWeek) 返回下一个星期几 The input 2011-01-15 (a Saturday) for parameter (SATURDAY) will return 2011-01-22 (seven days later).
static TemporalAdjuster	nextOrSame(DayOfWeek dayOfWeek) 返回下一个星期几，如果当前日期和dayOfWeek相同，则返回该对象 The input 2011-01-15 (a Saturday) for parameter (SATURDAY) will return 2011-01-15 (same as input).
static TemporalAdjuster	ofDateAdjuster(UnaryOperator<LocalDate> dateBasedAdjuster) Obtains a TemporalAdjuster that wraps a date adjuster.
static TemporalAdjuster	previous(DayOfWeek dayOfWeek) 返回上一个星期几 The input 2011-01-15 (a Saturday) for parameter (SATURDAY) will return 2011-01-08 (seven days earlier).
static TemporalAdjuster	previousOrSame(DayOfWeek dayOfWeek) 返回上一个星期几，如果当前日期和dayOfWeek相同，则返回该对象 The input 2011-01-15 (a Saturday) for parameter (SATURDAY) will return 2011-01-15 (same as input).

TemporalQueries

定义静态方法返回TemporalQuery

Modifier and Type	Method and Description
static TemporalQuery<Chronology>	chronology() 查询 Chronology.
static TemporalQuery<LocalDate>	localDate() 查询 LocalDate returning null if not found.
static TemporalQuery<LocalTime>	localTime() 查询 LocalTime returning null if not found.
static TemporalQuery<ZoneOffset>	offset() 查询 ZoneOffset returning null if not found.
static TemporalQuery<TemporalUnit>	precision() 查询 for the smallest supported unit.
static TemporalQuery<ZoneId>	zone() 查询 ZoneId, falling back to the ZoneOffset.
static TemporalQuery<ZoneId>	zoneId() 查询 ZoneId.

ValueRange

日期时间字段的有效值范围。

例如，ISO月日从1到28到31

Modifier and Type	Method and Description
int	checkValidIntValue(long value, TemporalField field)Checks that the specified value is valid and fits in an int.
long	checkValidValue(long value, TemporalField field)Checks that the specified value is valid.
boolean	equals(Object obj)Checks if this range is equal to another range.
long	getLargestMinimum() 获取该字段可以接受的最大可能最小值。
long	getMaximum() 获取该字段可以接受的最大值。
long	getMinimum() 获取该字段可以接受的最小值。
long	getSmallestMaximum() 获取该字段可以接受的最小可能最大值。
int	hashCode()A hash code for this range.
boolean	isFixed() 是固定的且完全已知的值范围。 例如，ISO月日从1到28到31。由于最大值存在不确定性，因此范围不是固定的。但是，对于1月份，范围始终为1到31，因此是固定的。
boolean	isIntValue()Checks if all values in the range fit in an int.
boolean	isValidIntValue(long value)Checks if the value is within the valid range and that all values in the range fit in an int.
boolean	isValidValue(long value)Checks if the value is within the valid range.
static ValueRange	of(long min, long max) 获取一个固定的值范围。 For example, the ISO month-of-year always runs from 1 to 12
static ValueRange	of(long min, long maxSmallest, long maxLargest) 该工厂获得一个范围，其中最小值是固定的，最大值可能会变化 For example, the ISO day-of-month always starts at 1, but ends between 28 and 31.
static ValueRange	of(long minSmallest, long minLargest, long maxSmallest, long maxLargest)Obtains a fully variable value range.

WeekFields

本地化定义day-of-week, week-of-month and week-of-year fields.

WeekFields 提供了五种字段，dayOfWeek(), weekOfMonth(), weekOfYear(), weekOfWeekBasedYear(), and weekBasedYear()

两个字段用于基于周的年weekOfWeekBasedYear(), and weekBasedYear()

在基于周的年中，每周只属于一年。 一年中的第 1 周是从一周的第一天开始的第一周，并且至少有最少的天数。 一年的第一周和最后一周可能分别包含上一个日历年或下一个日历年的天数。

Date	Day-of-week	First day: Monday Minimal days: 4	First day: Monday Minimal days: 5
2008-12-31	Wednesday	Week 1 of 2009	Week 53 of 2008
2009-01-01	Thursday	Week 1 of 2009	Week 53 of 2008
2009-01-04	Sunday	Week 1 of 2009	Week 53 of 2008
2009-01-05	Monday	Week 2 of 2009	Week 1 of 2009

Modifier and Type	Method and Description
static WeekFields	of(Locale locale) 获取适用于区域设置的WeekFields实例
static WeekFields	of(DayOfWeek firstDayOfWeek, int minimalDaysInFirstWeek) 获取适用于区域设置的WeekFields实例
DayOfWeek	getFirstDayOfWeek() 一周的第一天。the US uses Sunday, while France and the ISO-8601 standard use Monday
TemporalField	weekBasedYear() Returns a field to access the year of a week-based-year based on this WeekFields.
TemporalField	weekOfMonth() Returns a field to access the week of month based on this WeekFields.
TemporalField	weekOfWeekBasedYear() Returns a field to access the week of a week-based-year based on this WeekFields.
TemporalField	weekOfYear() Returns a field to access the week of year based on this WeekFields.
TemporalField	dayOfWeek() 根据此 WeekFields 返回一个字段以访问星期几。 这类似于 ChronoField.DAY_OF_WEEK，但使用基于此 WeekFields 的星期几的值。 天数从 1 到 7 编号，其中一周中的第一天被赋值为 1。 例如，如果一周中的第一天是星期日，那么它将具有值 1，而其他日期的范围从星期一为 2 到星期六为 7。
int	getMinimalDaysInFirstWeek() 获取第一周的最少天数。 定义一个月或一年的第一周的天数因文化而异。 例如，ISO-8601 要求在计算第一周之前存在 4 天（超过半周）。

ChronoField

Enum Constant and Description
ALIGNED_DAY_OF_WEEK_IN_MONTH The aligned day-of-week within a month.
ALIGNED_DAY_OF_WEEK_IN_YEAR The aligned day-of-week within a year.
ALIGNED_WEEK_OF_MONTH The aligned week within a month.
ALIGNED_WEEK_OF_YEAR The aligned week within a year.
AMPM_OF_DAY The am-pm-of-day.
CLOCK_HOUR_OF_AMPM The clock-hour-of-am-pm.
CLOCK_HOUR_OF_DAY The clock-hour-of-day.
DAY_OF_MONTH The day-of-month.
DAY_OF_WEEK The day-of-week, such as Tuesday.
DAY_OF_YEAR The day-of-year.
EPOCH_DAY The epoch-day, based on the Java epoch of 1970-01-01 (ISO).
ERA The era.
HOUR_OF_AMPM The hour-of-am-pm.
HOUR_OF_DAY The hour-of-day.
INSTANT_SECONDS The instant epoch-seconds.
MICRO_OF_DAY The micro-of-day.
MICRO_OF_SECOND The micro-of-second.
MILLI_OF_DAY The milli-of-day.
MILLI_OF_SECOND The milli-of-second.
MINUTE_OF_DAY The minute-of-day.
MINUTE_OF_HOUR The minute-of-hour.
MONTH_OF_YEAR The month-of-year, such as March.
NANO_OF_DAY The nano-of-day.
NANO_OF_SECOND The nano-of-second.
OFFSET_SECONDS The offset from UTC/Greenwich.
PROLEPTIC_MONTH The proleptic-month based, counting months sequentially from year 0.
SECOND_OF_DAY The second-of-day.
SECOND_OF_MINUTE The second-of-minute.
YEAR The proleptic year, such as 2012.
YEAR_OF_ERA The year within the era.

ChronoUnit

Enum Constant and Description
CENTURIES Unit that represents the concept of a century.
DAYS Unit that represents the concept of a day.
DECADES Unit that represents the concept of a decade.
ERAS Unit that represents the concept of an era.
FOREVER Artificial unit that represents the concept of forever.
HALF_DAYS Unit that represents the concept of half a day, as used in AM/PM.
HOURS Unit that represents the concept of an hour.
MICROS Unit that represents the concept of a microsecond.
MILLENNIA Unit that represents the concept of a millennium.
MILLIS Unit that represents the concept of a millisecond.
MINUTES Unit that represents the concept of a minute.
MONTHS Unit that represents the concept of a month.
NANOS Unit that represents the concept of a nanosecond, the smallest supported unit of time.
SECONDS Unit that represents the concept of a second.
WEEKS Unit that represents the concept of a week.
YEARS Unit that represents the concept of a year.

java.time.chrono

ChronoLocalDate

继承Temporal、TemporalAdjuster接口，并对其进行扩展，增加了isAfter()、isBefor()等方法

ChronoLocalDateTime

继承Temporal、TemporalAdjuster接口，并对其进行扩展, 增加了isAfter()、isBefor()等方法

Chronology

一种日历系统，用于组织和识别日期。

表示日历系统的概念

ChronoPeriod

继承TemporalAmount接口，

ChronoZoneDateTime

继承Temporal接口

AbstractChronology

实现Chronology接口

HijrachChronology

希吉拉历是支持伊斯兰历法的阴历。

HijrachDate

实现ChronoLocalDate接口

Hijrah日历系统中的日期。

IsoChronology

继承AbstractChronology抽象类。

ISO日历系统。

JapaneseChronology

日本的皇历制度。

JapaneseDate

日本皇历系统中的日期。

JapaneseEra

日本帝国历法体系中的一个时代。

MinguoChronology

民国历法。

MinguoDate

民国历法中的日期。

ThaiBuddhistChronology

泰国佛教日历系统。

ThaiBuddhistDate

泰国佛教日历系统中的日期。

HijrahEra

Hijrah日历系统中的一个时代。

IsoEra

ISO日历系统中的一个时代。

MinguoEra

民国历法体系中的一个时代。

ThaiBuddhistEra

泰国佛教历法体系中的一个时代。

java.time.zone

ZoneOffsetTransition

对两个偏移量之间的过渡进行建模

当存在根本不存在的本地日期时间时，就会出现间隔。例如，偏移从+03:00更改为+04:00。这可能被描述为“时钟将在今晚凌晨1点向前移动一小时”。

如果存在两次本地日期时间，则会发生重叠。例如，偏移从+04:00更改为+03:00。这可以被描述为“今晚凌晨2点钟会向后拨一小时”。

ZoneOffsetTransitionRule

表示如何创建转换的规则。

ZoneRules

定义单个时区的分区偏移量如何变化的规则。

这些规则为时区的所有历史和未来过渡建模。ZoneOffsetTransition用于已知的过渡，通常是历史过渡。ZoneOffsetTransitionRule用于基于算法结果的未来转换。

ZoneRulesProvider

向系统提供时区规则。

java.time.format

DateTimeFormatter

用来打印和格式化日期时间对象，并且提供了一些常见实现类:

1. 使用预定义的常量，如 ISO_LOCAL_DATE

2. 使用字符串样式，如 uuuu-MMM-dd

3. 使用本地化风格，如 long 或者 medium

更复制的格式化样式可以使用DateTimeFormatterBuilder来获取。

创建formatter时可以指定Local、Chronology、ZoneId、DecimalStyle。

Predefined Formatters

Formatter	Description	Example
ofLocalizedDate(dateStyle)	Formatter with date style from the locale	'2011-12-03'
ofLocalizedTime(timeStyle)	Formatter with time style from the locale	'10:15:30'
ofLocalizedDateTime(dateTimeStyle)	Formatter with a style for date and time from the locale	'3 Jun 2008 11:05:30'
ofLocalizedDateTime(dateStyle,timeStyle)	Formatter with date and time styles from the locale	'3 Jun 2008 11:05'
BASIC_ISO_DATE	Basic ISO date	'20111203'
ISO_LOCAL_DATE	ISO Local Date	'2011-12-03'
ISO_OFFSET_DATE	ISO Date with offset	'2011-12-03+01:00'
ISO_DATE	ISO Date with or without offset	'2011-12-03+01:00'; '2011-12-03'
ISO_LOCAL_TIME	Time without offset	'10:15:30'
ISO_OFFSET_TIME	Time with offset	'10:15:30+01:00'
ISO_TIME	Time with or without offset	'10:15:30+01:00'; '10:15:30'
ISO_LOCAL_DATE_TIME	ISO Local Date and Time	'2011-12-03T10:15:30'
ISO_OFFSET_DATE_TIME	Date Time with Offset	2011-12-03T10:15:30+01:00'
ISO_ZONED_DATE_TIME	Zoned Date Time	'2011-12-03T10:15:30+01:00[Europe/Paris]'
ISO_DATE_TIME	Date and time with ZoneId	'2011-12-03T10:15:30+01:00[Europe/Paris]'
ISO_ORDINAL_DATE	Year and day of year	'2012-337'
ISO_WEEK_DATE	Year and Week	2012-W48-6'
ISO_INSTANT	Date and Time of an Instant	'2011-12-03T10:15:30Z'
RFC_1123_DATE_TIME	RFC 1123 / RFC 822	'Tue, 3 Jun 2008 11:05:30 GMT'

All letters 'A' to 'Z' and 'a' to 'z' are reserved as pattern letters. The following pattern letters are defined:

  Symbol  Meaning                     Presentation      Examples
  ------  -------                     ------------      -------
   G       era                         text              AD; Anno Domini; A
   u       year                        year              2004; 04
   y       year-of-era                 year              2004; 04
   D       day-of-year                 number            189
   M/L     month-of-year               number/text       7; 07; Jul; July; J
   d       day-of-month                number            10
​
   Q/q     quarter-of-year             number/text       3; 03; Q3; 3rd quarter
   Y       week-based-year             year              1996; 96
   w       week-of-week-based-year     number            27
   W       week-of-month               number            4
   E       day-of-week                 text              Tue; Tuesday; T
   e/c     localized day-of-week       number/text       2; 02; Tue; Tuesday; T
   F       week-of-month               number            3
​
   a       am-pm-of-day                text              PM
   h       clock-hour-of-am-pm (1-12)  number            12
   K       hour-of-am-pm (0-11)        number            0
   k       clock-hour-of-am-pm (1-24)  number            0
​
   H       hour-of-day (0-23)          number            0
   m       minute-of-hour              number            30
   s       second-of-minute            number            55
   S       fraction-of-second          fraction          978
   A       milli-of-day                number            1234
   n       nano-of-second              number            987654321
   N       nano-of-day                 number            1234000000
​
   V       time-zone ID                zone-id           America/Los_Angeles; Z; -08:30
   z       time-zone name              zone-name         Pacific Standard Time; PST
   O       localized zone-offset       offset-O          GMT+8; GMT+08:00; UTC-08:00;
   X       zone-offset 'Z' for zero    offset-X          Z; -08; -0830; -08:30; -083015; -08:30:15;
   x       zone-offset                 offset-x          +0000; -08; -0830; -08:30; -083015; -08:30:15;
   Z       zone-offset                 offset-Z          +0000; -0800; -08:00;
​
   p       pad next                    pad modifier      1
​
   '       escape for text             delimiter
   ''      single quote                literal           '
   [       optional section start
   ]       optional section end
   #       reserved for future use
   {       reserved for future use
   }       reserved for future use

DateTimeFormatterBuilder

生成器创建日期时间格式化程序。

// 通过chrono和local来查找对应的dateStyle和timeStyle
public static String getLocalizedDateTimePattern(FormatStyle dateStyle,
                                                 FormatStyle timeStyle,
                                                 Chronology chrono,
                                                 Locale locale)
​
// 将格式化程序其余部分的解析样式更改为区分大小写。
// 调用此方法会更改生成器的状态，以便所有后续的生成器方法调用都将以区分大小写的模式解析文本
public DateTimeFormatterBuilder parseCaseSensitive()
​
// 将格式化程序其余部分的解析样式更改为不区分大小写。
public DateTimeFormatterBuilder parseCaseInsensitive()
    
// 将格式化程序其余部分的解析样式更改为严格。
public DateTimeFormatterBuilder parseStrict()
    
// 将格式化程序的其余部分的解析样式更改为宽松。请注意，此方法单独设置了大小写敏感度。
// 调用此方法的应用程序通常也应该调用ParseCaseSensitive（）。
public DateTimeFormatterBuilder parseLenient()
    
// 将字段的默认值附加到格式化程序中，以用于解析
public DateTimeFormatterBuilder parseDefaulting(TemporalField field,
                                                long value)
// 使用常规输出样式将日期时间字段的值附加到格式化程序。
public DateTimeFormatterBuilder appendValue(TemporalField field)
    
// 使用固定宽度的零填充方法将日期时间字段的值附加到格式化程序    
public DateTimeFormatterBuilder appendValue(TemporalField field,
                                            int width)  
    
public DateTimeFormatterBuilder appendValue(TemporalField field,
                                            int minWidth,
                                            int maxWidth,
                                            SignStyle signStyle)
// 将日期时间字段的缩减值附加到格式化程序。
// width、maxWidth用于确定要格式化的字符数.如果它们相等，则格式为固定宽度
// 如果字段的值在使用宽度字符的baseValue范围内,对缩减后的值进行格式化。否则，该值将被截断以适合maxWidth
// 输出最右边的字符以匹配宽度，左边填充为零。
// 例如，基值为1980，宽度为2的有效值为1980到2079。在解析过程中，文本“12”将产生值2012，因为该值在最后两个字符为“12”的范围内。相比之下，解析文本“1915”将得到值1915。
public DateTimeFormatterBuilder appendValueReduced(TemporalField field,
                                                   int width,
                                                   int maxWidth,
                                                   int baseValue)
// 将日期时间字段的缩减值附加到格式化程序。
// 这通常用于格式化和解析两位数年份。
// baseDate用于在解析期间计算完整值.例如，如果基准日期为1950-01-01，则两位数年份解析的解析值将在1950-01-01到2049-12-31之间    
public DateTimeFormatterBuilder appendValueReduced(TemporalField field,
                                                   int width,
                                                   int maxWidth,
                                                   ChronoLocalDate c)
// 将日期时间字段的分数值附加到格式化程序。
// 该字段的小数将被输出，包括前面的小数点。不输出前面的值。例如，the second-of-minute value of 15 would be output as .25.
public DateTimeFormatterBuilder appendFraction(TemporalField field,c
                                               int minWidth,
                                               int maxWidth,
                                               boolean decimalPoint)
// 使用全文样式将日期时间字段的文本追加到格式设置程序。
// 该字段的文本将在格式化过程中输出。该值必须在字段的有效范围内。如果无法获取该值，则将引发异常。如果字段没有文本表示，则将使用数值。
public DateTimeFormatterBuilder appendText(TemporalField field)
    
// 将日期时间字段的文本附加到格式化程序,使用指定的映射来提供文本。
// 提供文本映射在格式化和解析方面提供了相当大的灵活性。例如，遗留应用程序可能需要或提供一年中的月份作为“JNY”、“FBY”、“MCH”等。这些与本地化月份名称的标准文本集不匹配。使用此方法，可以创建一个映射，定义每个值和文本之间的连接：
// Map<Long, String> map = new HashMap<>();
// map.put(1L, "JNY");
// map.put(2L, "FBY");
// map.put(3L, "MCH");
// ...
// builder.appendText(MONTH_OF_YEAR, map);
​
// 其他用途可能是输出带有后缀的值,such as "1st", "2nd", "3rd", or as Roman numerals "I", "II", "III", "IV".
public DateTimeFormatterBuilder appendText(TemporalField field,
                                           Map<Long,String> textLookup)
​
// 这种方法的另一种选择是将瞬间格式化/解析为单个历元秒值。这是通过使用appendValue（瞬间秒）实现的。
public DateTimeFormatterBuilder appendInstant()
    
// 这种方法的另一种选择是将瞬间格式化/解析为单个历元秒值。这是通过使用appendValue（瞬间秒）实现的。
// 允许控制分数秒的输出.指定零将导致不输出小数位数。从1到9将输出越来越多的数字，必要时使用零右填充。特殊值-1用于输出尽可能多的数字，以避免任何尾随零。
public DateTimeFormatterBuilder appendInstant(int c)
​
// 将区域偏移量（例如“+01:00”）附加到格式化程序。
// 这会向生成器附加一条指令，用于格式化/解析偏移量ID。这相当于调用appendOffset（“+HH:MM:ss”，“Z”）。
public DateTimeFormatterBuilder appendOffsetId()
​
// 将区域偏移量（例如“+01:00”）附加到格式化程序。这会向生成器附加一条指令，用于格式化/解析偏移量ID。
// 
public DateTimeFormatterBuilder appendOffset(String pattern,
                                             String noOffsetText)
// 将本地化区域偏移量（例如“GMT+01:00”）附加到格式化程序。
// style取值：full、short
public DateTimeFormatterBuilder appendLocalizedOffset(TextStyle style)
    
// 将时区ID（如“Europe/Paris”或“+02:00”）附加到格式化程序。这将向生成器追加一条指令，用于格式化/解析区域ID
// 区域ID是以适用于ZoneDateTime的严格方式获取的。相比之下，OffsetDateTime没有适合此方法使用的区域ID，请参见AppendZoneRoffsetId（）
// format的时候如果获取不到zone则抛出异常
// parsing的时候文本必须与已知区域或偏移匹配。There are two types of zone ID, offset-based, such as '+01:30' and region-based, such as 'Europe/London'.
    For example, the following will parse:
​
   "Europe/London"           -- ZoneId.of("Europe/London")
   "Z"                       -- ZoneOffset.UTC
   "UT"                      -- ZoneId.of("UT")
   "UTC"                     -- ZoneId.of("UTC")
   "GMT"                     -- ZoneId.of("GMT")
   "+01:30"                  -- ZoneOffset.of("+01:30")
   "UT+01:30"                -- ZoneOffset.of("+01:30")
   "UTC+01:30"               -- ZoneOffset.of("+01:30")
   "GMT+01:30"               -- ZoneOffset.of("+01:30")
public DateTimeFormatterBuilder appendZoneId()   
       
// 将时区区域ID（如“Europe/Paris”）附加到格式化程序，如果是区域偏移，则拒绝该区域ID。       
public DateTimeFormatterBuilder appendZoneRegionId()       
​
// 使用可用的最佳时区ID将时区ID（如“Europe/Paris”或“+02:00”）附加到格式化程序。
public DateTimeFormatterBuilder appendZoneOrOffsetId()
​
// 将时区名称（如“British Summer Time”）附加到格式化程序。
// 在解析过程中，接受文本区域名称、区域ID或偏移量。
// 许多文本区域名称不是唯一的，例如CST可以用于“中央标准时间”和“中国标准时间”.在这种情况下，区域id将由格式化程序的区域设置中的区域信息和该区域的标准区域id确定       
public DateTimeFormatterBuilder appendZoneText(TextStyle textStyle)       
       
// 将时区名称（如“British Summer Time”）附加到格式化程序。       
public DateTimeFormatterBuilder appendZoneText(TextStyle textStyle,
                                               Set<ZoneId> preferredZones)   
// 将年表ID（如“ISO”或“ThaiBuddhist”）附加到格式化程序。       
public DateTimeFormatterBuilder appendChronologyId()       
       
// 将时间顺序名称附加到格式化程序。日历系统名称将在格式化期间输出。如果无法获得时间顺序，则会引发异常。       
public DateTimeFormatterBuilder appendChronologyText(TextStyle textStyle)       
  
// 将本地化的日期时间模式附加到格式化程序。       
public DateTimeFormatterBuilder appendLocalized(FormatStyle dateStyle,
                                                FormatStyle timeStyle)       
// 将字符文字附加到格式化程序。此字符将在格式化期间输出。       
public DateTimeFormatterBuilder appendLiteral(char literal)
​
// 将字符串文字追加到格式化程序。此字符串将在格式化过程中输出。如果文本为空，则不会向格式化程序添加任何内容。       
public DateTimeFormatterBuilder appendLiteral(String literal)       
 
// 将格式化程序的所有元素附加到生成器。此方法的效果与将格式化程序的每个组成部分直接附加到此生成器相同。       
public DateTimeFormatterBuilder append(DateTimeFormatter formatter)  
​
// 将格式化程序附加到生成器，该生成器将可选地进行格式化/分析。
// 如果数据可用于其中包含的所有字段，格式化程序将进行格式化。如果字符串匹配，格式化程序将进行分析，否则不会返回错误。
public DateTimeFormatterBuilder appendOptional(DateTimeFormatter formatter)       
 
// 将指定模式定义的元素附加到生成器。所有字母“A”到“Z”以及“A”到“Z”都保留为图案字母。字符“#”、“{”和“}”保留供将来使用。字符“[”和“]”表示可选模式。定义了以下模式字母：
Symbol  Meaning                     Presentation      Examples
  ------  -------                     ------------      -------
   G       era                         text              AD; Anno Domini; A
   u       year                        year              2004; 04
   y       year-of-era                 year              2004; 04
   D       day-of-year                 number            189
   M/L     month-of-year               number/text       7; 07; Jul; July; J
   d       day-of-month                number            10
​
   Q/q     quarter-of-year             number/text       3; 03; Q3; 3rd quarter
   Y       week-based-year             year              1996; 96
   w       week-of-week-based-year     number            27
   W       week-of-month               number            4
   E       day-of-week                 text              Tue; Tuesday; T
   e/c     localized day-of-week       number/text       2; 02; Tue; Tuesday; T
   F       week-of-month               number            3
​
   a       am-pm-of-day                text              PM
   h       clock-hour-of-am-pm (1-12)  number            12
   K       hour-of-am-pm (0-11)        number            0
   k       clock-hour-of-am-pm (1-24)  number            0
​
   H       hour-of-day (0-23)          number            0
   m       minute-of-hour              number            30
   s       second-of-minute            number            55
   S       fraction-of-second          fraction          978
   A       milli-of-day                number            1234
   n       nano-of-second              number            987654321
   N       nano-of-day                 number            1234000000
​
   V       time-zone ID                zone-id           America/Los_Angeles; Z; -08:30
   z       time-zone name              zone-name         Pacific Standard Time; PST
   O       localized zone-offset       offset-O          GMT+8; GMT+08:00; UTC-08:00;
   X       zone-offset 'Z' for zero    offset-X          Z; -08; -0830; -08:30; -083015; -08:30:15;
   x       zone-offset                 offset-x          +0000; -08; -0830; -08:30; -083015; -08:30:15;
   Z       zone-offset                 offset-Z          +0000; -0800; -08:00;
​
   p       pad next                    pad modifier      1
​
   '       escape for text             delimiter
   ''      single quote                literal           '
   [       optional section start
   ]       optional section end
   #       reserved for future use
   {       reserved for future use
   }       reserved for future use
       
图案字母的计数决定了格式.
Date fields
Pattern  Count  Equivalent builder methods
  -------  -----  --------------------------
    G       1      appendText(ChronoField.ERA, TextStyle.SHORT)
    GG      2      appendText(ChronoField.ERA, TextStyle.SHORT)
    GGG     3      appendText(ChronoField.ERA, TextStyle.SHORT)
    GGGG    4      appendText(ChronoField.ERA, TextStyle.FULL)
    GGGGG   5      appendText(ChronoField.ERA, TextStyle.NARROW)
​
    u       1      appendValue(ChronoField.YEAR, 1, 19, SignStyle.NORMAL);
    uu      2      appendValueReduced(ChronoField.YEAR, 2, 2000);
    uuu     3      appendValue(ChronoField.YEAR, 3, 19, SignStyle.NORMAL);
    u..u    4..n   appendValue(ChronoField.YEAR, n, 19, SignStyle.EXCEEDS_PAD);
    y       1      appendValue(ChronoField.YEAR_OF_ERA, 1, 19, SignStyle.NORMAL);
    yy      2      appendValueReduced(ChronoField.YEAR_OF_ERA, 2, 2000);
    yyy     3      appendValue(ChronoField.YEAR_OF_ERA, 3, 19, SignStyle.NORMAL);
    y..y    4..n   appendValue(ChronoField.YEAR_OF_ERA, n, 19, SignStyle.EXCEEDS_PAD);
    Y       1      append special localized WeekFields element for numeric week-based-year
    YY      2      append special localized WeekFields element for reduced numeric week-based-year 2 digits;
    YYY     3      append special localized WeekFields element for numeric week-based-year (3, 19, SignStyle.NORMAL);
    Y..Y    4..n   append special localized WeekFields element for numeric week-based-year (n, 19, SignStyle.EXCEEDS_PAD);
​
    Q       1      appendValue(IsoFields.QUARTER_OF_YEAR);
    QQ      2      appendValue(IsoFields.QUARTER_OF_YEAR, 2);
    QQQ     3      appendText(IsoFields.QUARTER_OF_YEAR, TextStyle.SHORT)
    QQQQ    4      appendText(IsoFields.QUARTER_OF_YEAR, TextStyle.FULL)
    QQQQQ   5      appendText(IsoFields.QUARTER_OF_YEAR, TextStyle.NARROW)
    q       1      appendValue(IsoFields.QUARTER_OF_YEAR);
    qq      2      appendValue(IsoFields.QUARTER_OF_YEAR, 2);
    qqq     3      appendText(IsoFields.QUARTER_OF_YEAR, TextStyle.SHORT_STANDALONE)
    qqqq    4      appendText(IsoFields.QUARTER_OF_YEAR, TextStyle.FULL_STANDALONE)
    qqqqq   5      appendText(IsoFields.QUARTER_OF_YEAR, TextStyle.NARROW_STANDALONE)
​
    M       1      appendValue(ChronoField.MONTH_OF_YEAR);
    MM      2      appendValue(ChronoField.MONTH_OF_YEAR, 2);
    MMM     3      appendText(ChronoField.MONTH_OF_YEAR, TextStyle.SHORT)
    MMMM    4      appendText(ChronoField.MONTH_OF_YEAR, TextStyle.FULL)
    MMMMM   5      appendText(ChronoField.MONTH_OF_YEAR, TextStyle.NARROW)
    L       1      appendValue(ChronoField.MONTH_OF_YEAR);
    LL      2      appendValue(ChronoField.MONTH_OF_YEAR, 2);
    LLL     3      appendText(ChronoField.MONTH_OF_YEAR, TextStyle.SHORT_STANDALONE)
    LLLL    4      appendText(ChronoField.MONTH_OF_YEAR, TextStyle.FULL_STANDALONE)
    LLLLL   5      appendText(ChronoField.MONTH_OF_YEAR, TextStyle.NARROW_STANDALONE)
​
    w       1      append special localized WeekFields element for numeric week-of-year
    ww      2      append special localized WeekFields element for numeric week-of-year, zero-padded
    W       1      append special localized WeekFields element for numeric week-of-month
    d       1      appendValue(ChronoField.DAY_OF_MONTH)
    dd      2      appendValue(ChronoField.DAY_OF_MONTH, 2)
    D       1      appendValue(ChronoField.DAY_OF_YEAR)
    DD      2      appendValue(ChronoField.DAY_OF_YEAR, 2)
    DDD     3      appendValue(ChronoField.DAY_OF_YEAR, 3)
    F       1      appendValue(ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH)
    E       1      appendText(ChronoField.DAY_OF_WEEK, TextStyle.SHORT)
    EE      2      appendText(ChronoField.DAY_OF_WEEK, TextStyle.SHORT)
    EEE     3      appendText(ChronoField.DAY_OF_WEEK, TextStyle.SHORT)
    EEEE    4      appendText(ChronoField.DAY_OF_WEEK, TextStyle.FULL)
    EEEEE   5      appendText(ChronoField.DAY_OF_WEEK, TextStyle.NARROW)
    e       1      append special localized WeekFields element for numeric day-of-week
    ee      2      append special localized WeekFields element for numeric day-of-week, zero-padded
    eee     3      appendText(ChronoField.DAY_OF_WEEK, TextStyle.SHORT)
    eeee    4      appendText(ChronoField.DAY_OF_WEEK, TextStyle.FULL)
    eeeee   5      appendText(ChronoField.DAY_OF_WEEK, TextStyle.NARROW)
    c       1      append special localized WeekFields element for numeric day-of-week
    ccc     3      appendText(ChronoField.DAY_OF_WEEK, TextStyle.SHORT_STANDALONE)
    cccc    4      appendText(ChronoField.DAY_OF_WEEK, TextStyle.FULL_STANDALONE)
    ccccc   5      appendText(ChronoField.DAY_OF_WEEK, TextStyle.NARROW_STANDALONE)
        
Time fields
Pattern  Count  Equivalent builder methods
  -------  -----  --------------------------
    a       1      appendText(ChronoField.AMPM_OF_DAY, TextStyle.SHORT)
    h       1      appendValue(ChronoField.CLOCK_HOUR_OF_AMPM)
    hh      2      appendValue(ChronoField.CLOCK_HOUR_OF_AMPM, 2)
    H       1      appendValue(ChronoField.HOUR_OF_DAY)
    HH      2      appendValue(ChronoField.HOUR_OF_DAY, 2)
    k       1      appendValue(ChronoField.CLOCK_HOUR_OF_DAY)
    kk      2      appendValue(ChronoField.CLOCK_HOUR_OF_DAY, 2)
    K       1      appendValue(ChronoField.HOUR_OF_AMPM)
    KK      2      appendValue(ChronoField.HOUR_OF_AMPM, 2)
    m       1      appendValue(ChronoField.MINUTE_OF_HOUR)
    mm      2      appendValue(ChronoField.MINUTE_OF_HOUR, 2)
    s       1      appendValue(ChronoField.SECOND_OF_MINUTE)
    ss      2      appendValue(ChronoField.SECOND_OF_MINUTE, 2)
​
    S..S    1..n   appendFraction(ChronoField.NANO_OF_SECOND, n, n, false)
    A       1      appendValue(ChronoField.MILLI_OF_DAY)
    A..A    2..n   appendValue(ChronoField.MILLI_OF_DAY, n)
    n       1      appendValue(ChronoField.NANO_OF_SECOND)
    n..n    2..n   appendValue(ChronoField.NANO_OF_SECOND, n)
    N       1      appendValue(ChronoField.NANO_OF_DAY)
    N..N    2..n   appendValue(ChronoField.NANO_OF_DAY, n)
        
Zone ID
 Pattern  Count  Equivalent builder methods
  -------  -----  --------------------------
    VV      2      appendZoneId()
    z       1      appendZoneText(TextStyle.SHORT)
    zz      2      appendZoneText(TextStyle.SHORT)
    zzz     3      appendZoneText(TextStyle.SHORT)
    zzzz    4      appendZoneText(TextStyle.FULL)
        
Zone offset
Pattern  Count  Equivalent builder methods
  -------  -----  --------------------------
    O       1      appendLocalizedOffsetPrefixed(TextStyle.SHORT);
    OOOO    4      appendLocalizedOffsetPrefixed(TextStyle.FULL);
    X       1      appendOffset("+HHmm","Z")
    XX      2      appendOffset("+HHMM","Z")
    XXX     3      appendOffset("+HH:MM","Z")
    XXXX    4      appendOffset("+HHMMss","Z")
    XXXXX   5      appendOffset("+HH:MM:ss","Z")
    x       1      appendOffset("+HHmm","+00")
    xx      2      appendOffset("+HHMM","+0000")
    xxx     3      appendOffset("+HH:MM","+00:00")
    xxxx    4      appendOffset("+HHMMss","+0000")
    xxxxx   5      appendOffset("+HH:MM:ss","+00:00")
    Z       1      appendOffset("+HHMM","+0000")
    ZZ      2      appendOffset("+HHMM","+0000")
    ZZZ     3      appendOffset("+HHMM","+0000")
    ZZZZ    4      appendLocalizedOffset(TextStyle.FULL);
    ZZZZZ   5      appendOffset("+HH:MM:ss","Z")
 
Modifiers
Pattern  Count  Equivalent builder methods
  -------  -----  --------------------------
    [       1      optionalStart()
    ]       1      optionalEnd()
    p..p    1..n   padNext(n)        
public DateTimeFormatterBuilder appendPattern(String pattern)    
       
// 使下一个添加的打印机/解析器使用空格填充到固定宽度。此填充将使用空格填充到固定宽度
// 在格式化过程中，装饰元素将被输出，然后填充到指定的宽度。如果超出了焊盘宽度，格式化过程中将引发异常
// 在解析过程中，将解析padding和修饰元素。如果解析比较宽松，则焊盘宽度被视为最大值。填充物被贪婪地解析。因此，如果装饰元素以pad字符开头，它将不会被解析。
public DateTimeFormatterBuilder padNext(int padWidth)
        
// 使下一个添加的打印机/分析器填充到固定宽度。
public DateTimeFormatterBuilder padNext(int padWidth,
                                        char padChar)
​
// 标记可选部分的开头。格式化的输出可以包括可选的部分，这些部分可以嵌套。可选部分通过调用此方法开始，并通过调用optionalEnd（）或结束构建过程结束。        
public DateTimeFormatterBuilder optionalStart()
​
// 结束可选部分。格式化的输出可以包括可选的部分，这些部分可以嵌套。可选部分通过调用optionalStart（）开始，并使用此方法结束（或在生成器的末尾）。        
public DateTimeFormatterBuilder optionalEnd() 
​
// 通过使用默认区域设置创建DateTimeFormatter来完成此生成器。        
public DateTimeFormatter toFormatter()
​
// 通过使用指定的区域设置创建DateTimeFormatter来完成此生成器。        
public DateTimeFormatter toFormatter(Locale locale)  

DecimalStyle

日期和时间格式中使用的本地化十进制样式。

FormatStyle

枚举本地化日期、时间或日期时间格式化程序的样式。

Enum Constant and Description
FULLFull 全文样式，最详细。
LONG 长文本样式，包含大量细节。
MEDIUM 中等文本样式，带有一些细节。
SHORT 短文本样式，通常为数字。.

ResolverStyle

枚举解析日期和时间的不同方法。

分析文本字符串分两个阶段进行。阶段1是根据添加到生成器中的字段进行基本文本解析。阶段2将解析的字段值对解析为日期和/或时间对象。此样式用于控制第2阶段（解析）的发生方式。

Enum Constant and Description
LENIENT 宽大地解决日期和时间问题。
SMART 样式以智能的方式解析日期和时间。
STRICT 风格严格地确定日期和时间。

SignStyle

列举处理正负号的方法。

格式化引擎允许使用此枚举控制数字的正负号

Enum Constant and Description
ALWAYS 样式始终输出符号，其中零将输出“+”。
EXCEEDS_PAD 设置样式，以便在值超过焊盘宽度时始终输出符号。
NEVER 样式为从不输出符号，只输出绝对值。
NORMAL 仅当值为负数时才输出符号的样式。
NOT_NEGATIVE 设置样式以阻止负值，在打印时引发异常。

TextStyle

枚举文本格式和解析的样式。

文本样式为格式化文本定义了三种大小——“完整”、“短”和“窄”。这三种尺寸都有“标准”和“独立”两种版本。

Enum Constant and Description
FULL 全文，通常是完整的描述。
FULL_STANDALONE 全文供独立使用，通常为完整描述。
NARROW 窄文本，通常为一个字母
NARROW_STANDALONE 单独使用的窄文本，通常为单个字母。
SHORT 短文本，通常是缩写。
SHORT_STANDALONE 独立使用的短文本，通常是缩写

java.time

Clock

通过Clock我们可以访问Instant，通过Instant可以访问带有时区的Date和Time。因此Clock可以用来代替System.currentTimeMillis() 和 TimeZone.getDefault();

大多数和日期时间相关的类(如：LocalDateTime)都有一个now()方法，使用的是默认时区的系统Clock，所以不一定要显示的使用Clock。

Clock这个抽象类的意义在于，如果你想将Clock注入到你的应用程序，则可以使用它。

// 返回一个Clock使用UTC时区。当您需要没有日期或时间的当前时刻时，应使用此时钟，而不是systemDefaultZone（）。
// 使用UTC时区来将Instant转换成date或者time
public static Clock systemUTC()

// 使用默认时区
public static Clock systemDefaultZone()
    
// 指定zone    
public static Clock system(ZoneId zone)   

// 以整秒为单位来返回Instan的Clock。这个时钟将始终将纳秒场设置为零。
// It is equivalent to tick(system(zone), Duration.ofSeconds(1)).
public static Clock tickSeconds(ZoneId zone)  

// 以分钟为单位来返回Instant的Clock。这个时钟总是将纳秒和分秒字段设置为零
// It is equivalent to tick(system(zone), Duration.ofMinutes(1)).    
public static Clock tickMinutes(ZoneId zone)
    
// 返回tickDuration频率的Clock    
public static Clock tick(Clock baseClock,
                         Duration tickDuration)    
    
// 始终返回相同的Instant的Clock。该方法主要用于testing中
public static Clock fixed(Instant fixedInstant,
                          ZoneId zone)
    
// 返回一个偏移量为offsetDuration的Clock
public static Clock offset(Clock baseClock,
                           Duration offsetDuration)   

// 返回毫秒数
public long millis()
    
public abstract ZoneId getZone()    
public abstract Clock withZone(ZoneId zone)  
public abstract Instant instant()   

Duration

对秒、纳秒为单位的时间数量来建模。

Modifier and Type	Method and Description
Duration	abs() 正长度副本
Temporal	addTo(Temporal temporal) 将duration添加到指定的时间对象 // 两种方法都一样，通常选择第二种 dateTime = thisDuration.addTo(dateTime); dateTime = dateTime.plus(thisDuration);
static Duration	between(Temporal startInclusive, Temporal endExclusive) 计算两个temporal之间的duration。 如果两个temporal类型不一样，则以第一个temporal类型为准。 如第一个temporal是LocalTime，那么第二个temporal会被转换成LocalTime。 temporal参数必须支持SECONDS,NACOS,NANO_OF_SECOND
int	compareTo(Duration otherDuration) 和其他duration进行比较
Duration	dividedBy(long divisor) 返回duration除以divisor的副本. 原本的duration实例值不会受到影响
static Duration	from(TemporalAmount amount) 从时间量中获取Duration的实例
long	get(TemporalUnit unit) 获取请求单位的值。只支持SECONDS和NANOS,其他时间单位将会抛出异常
int	getNano() 返回纳秒
long	getSeconds() 返回秒数
List<TemporalUnit>	getUnits() 获取此duration支持的单位集。
boolean	isNegative() 检查duration是否为负，不包括零
boolean	isZero() 检测duration是否为零长度
Duration	minus(Duration duration) 返回此duration的副本，并减去指定的duration
Duration	`minus(long amountToSubtract, TemporalUnit unit) 返回此duration的副本，并减去指定的duration
Duration	minusDays(long daysToSubtract) 返回此duration的副本，并减去指定的天数
Duration	minusHours(long hoursToSubtract) 返回此duration的副本，并减去指定的小时
Duration	minusMillis(long millisToSubtract) 返回此duration的副本，并减去指定的毫秒
Duration	minusMinutes(long minutesToSubtract) 返回此duration的副本，并减去指定的分钟
Duration	minusNanos(long nanosToSubtract) 返回此duration的副本，并减去指定的纳秒
Duration	minusSeconds(long secondsToSubtract) 返回此duration的副本，并减去指定的秒
Duration	multipliedBy(long multiplicand) 返回此duration乘以multiplicand的副本
Duration	negated() 返回长度为负数的duration的副本
static Duration	of(long amount, TemporalUnit unit) 获取指定单位、指定amount的duration
static Duration	ofDays(long days) 获取days天的duration
static Duration	ofHours(long hours) 获取hours小时的duration
static Duration	ofMillis(long millis) 获取millis毫秒的duration
static Duration	ofMinutes(long minutes) 获取minutes分钟的duration
static Duration	ofNanos(long nanos) 获取nacos纳秒的duration
static Duration	ofSeconds(long seconds) 获取seconds秒的duration
static Duration	ofSeconds(long seconds, long nanoAdjustment) 根据秒数和纳秒数来获取duration
static Duration	parse(CharSequence text) 从text解析并返回duration，例如 PnDTnHnMn.nS.
Duration	plus(Duration duration) 返回此duration的副本，并添加指定的duration
Duration	plus(long amountToAdd, TemporalUnit unit) 返回此duration的副本，并添加指定单位的amountToAdd值
Duration	plusDays(long daysToAdd) 返回此duration的副本，并添加指定的天数
Duration	plusHours(long hoursToAdd) 返回此duration的副本，并添加指定的小时
Duration	plusMillis(long millisToAdd) 返回此duration的副本，并添加指定的毫秒
Duration	plusMinutes(long minutesToAdd) 返回此duration的副本，并添加指定的分钟
Duration	plusNanos(long nanosToAdd) 返回此duration的副本，并添加指定的纳秒
Duration	plusSeconds(long secondsToAdd) 返回此duration的副本，并添加指定的秒
Temporal	subtractFrom(Temporal temporal) 从指定的temporal减去此duration
long	toDays() 获取此duration的天数
long	toHours() 获取此duration的小时数
long	toMillis() 获取此duration的毫秒数
long	toMinutes() 获取此duration的分钟数
long	toNanos() 获取此duration的纳秒数
Duration	withNanos(int nanoOfSecond) 以指定的纳秒返回此duration的副本
Duration	withSeconds(long seconds) 以指定的秒数返回此duration的副本

Instant

模拟时间线上的一个瞬间点。这可能用于在应用程序中记录事件时间戳

Java时间刻度用于所有日期时间类。这包括Instant、LocalDate、LocalTime、OffsetDateTime、ZonedDateTime和Duration。

Modifier and Type	Method and Description
Temporal	adjustInto(Temporal temporal) // these two lines are equivalent, but the second approach is recommended temporal = thisInstant.adjustInto(temporal); temporal = temporal.with(thisInstant);
OffsetDateTime	atOffset(ZoneOffset offset) 将此瞬间与偏移量组合以创建OffsetDateTime。
ZonedDateTime	atZone(ZoneId zone) 将此瞬间与时区组合以创建ZoneDateTime。
int	compareTo(Instant otherInstant) 将此瞬间与指定瞬间进行比较。
static Instant	from(TemporalAccessor temporal) 从时间对象获取Instant的实例。
int	get(TemporalField field) 从这个瞬间获取指定字段的int值。
long	getEpochSecond() 获取Java纪元1970-01-01T00:00:00Z的秒数。
long	getLong(TemporalField field) 从这个瞬间获取指定字段的值作为long。
int	getNano() 获取纳秒数
boolean	isAfter(Instant otherInstant) 检查此瞬间是否在指定瞬间之后。
boolean	isBefore(Instant otherInstant) 检查此时刻是否早于指定时刻。
boolean	isSupported(TemporalField field) 检查是否支持指定的字段。以下是支持的字段： NACOS_OF_SECOND MICRO_OF_SECOND MILLI_OF_SECOND INSTANT_SECONDS
boolean	isSupported(TemporalUnit unit) 检查是否支持指定的单元。以下是支持的单元： NANOS MICROS MILLIS SECONDS MINUTES HOURS HALF_DAYS DAYS
Instant	minus(long amountToSubtract, TemporalUnit unit) 返回减去指定数量后的即时消息副本。
Instant	minus(TemporalAmount amountToSubtract) 返回减去指定数量后的即时消息副本。
Instant	minusMillis(long millisToSubtract) 返回此瞬间的副本，并减去指定的持续时间（毫秒）。
Instant	minusNanos(long nanosToSubtract) 返回此瞬间的副本，并减去指定的持续时间（以纳秒为单位）。
Instant	minusSeconds(long secondsToSubtract) 返回此瞬间的副本，并减去指定的持续时间（以秒为单位）。
static Instant	now() 从系统Clock获取当前时刻
static Instant	now(Clock clock) 从指定的Clock获取当前时刻
static Instant	ofEpochMilli(long epochMilli) 使用从1970-01-01T00:00:00Z的纪元开始的毫秒获取“Instant”的实例。
static Instant	ofEpochSecond(long epochSecond) 使用从1970-01-01T00:00:00Z的纪元开始的秒获取“Instant”的实例。
static Instant	ofEpochSecond(long epochSecond, long nanoAdjustment) 使用1970-01-01T00:00:00Z纪元的秒数和纳秒分数获取“Instant”的实例。
static Instant	parse(CharSequence text) 从字符串文本中获取Instant，例如：2007-12-03T10:15:30.00Z
Instant	plus(long amountToAdd, TemporalUnit unit) 返回此Instant副本，并添加指定unit单位amountToAdd值
Instant	plus(TemporalAmount amountToAdd) 返回此Instant的副本，并添加指定的TemporalAmount
Instant	plusMillis(long millisToAdd) 返回此Instant的副本，并增加指定的毫秒数
Instant	plusNanos(long nanosToAdd) 返回此Instant的副本，并增加指定的纳秒数
Instant	plusSeconds(long secondsToAdd) 返回此Instant的副本，并增加指定的秒数
<R> R	query(TemporalQuery<R> query) 使用指定的查询查询此即时消息。
ValueRange	range(TemporalField field) 获取指定字段的有效值范围。
long	toEpochMilli() 将此瞬间转换为从1970-01-01T00:00:00Z开始的毫秒数。
Instant	truncatedTo(TemporalUnit unit) 返回截断为指定单位的“Instant”的副本。
long	until(Temporal endExclusive, TemporalUnit unit) 以指定的单位计算到另一个瞬间的时间量。 // these two lines are equivalent amount = start.until(end, SECONDS); amount = SECONDS.between(start, end);
Instant	with(TemporalAdjuster adjuster) 返回此即时消息的调整副本。
Instant	with(TemporalField field, long newValue) 返回此即时消息的副本，并将指定字段设置为新值。

LocalDate

在ISO-8601日历系统中没有时区的日期，例如2007-12-03。

不存储时间和时区。

Modifier and Type	Method and Description
Temporal	adjustInto(Temporal temporal) // these two lines are equivalent, but the second approach is recommended temporal = thisLocalDate.adjustInto(temporal); temporal = temporal.with(thisLocalDate);
LocalDateTime	atStartOfDay() 将日期和零点的时间结合，返回LocalDateTime
ZonedDateTime	atStartOfDay(ZoneId zone) 根据时区中的规则，以最早的有效时间从该日期返回分区日期时间。
LocalDateTime	atTime(int hour, int minute) 组合小时、分钟来返回LocalDateTime
LocalDateTime	atTime(int hour, int minute, int second) 组合小时、分钟、秒来返回LocalDateTime
LocalDateTime	atTime(int hour, int minute, int second, int nanoOfSecond) 组合小时、分钟、秒、纳秒来返回LocalDateTime
LocalDateTime	atTime(LocalTime time) 组合LocalTime来返回LocalDateTime
OffsetDateTime	atTime(OffsetTime time) 组合OffSetTime来返回OffsetDateTime
int	compareTo(ChronoLocalDate other) 和其他的LocalDate来比较
String	format(DateTimeFormatter formatter) 使用formatter来格式此LocalDate
static LocalDate	from(TemporalAccessor temporal) 从temporal来获取LocalDate实例
int	get(TemporalField field) 从该日期获取指定字段的值，该值为“int”。
IsoChronology	getChronology() 获取此日期的年表，它是ISO日历系统。
int	getDayOfMonth() 此日期对应的月天数
DayOfWeek	getDayOfWeek() 获取day of week字段，该字段是enumDayOfWeek
int	getDayOfYear() 获取dayOfYear
Era	getEra() 获取此日期适用的era。
long	getLong(TemporalField field) 获取指定字段从此日期起的“long”值。
Month	getMonth() 使用'month'枚举获取月份字段。
int	getMonthValue() 获取从1到12的月份字段。
int	getYear() 获取年份字段。
boolean	isAfter(ChronoLocalDate other) 检查此日期是否在指定日期之后。
boolean	isBefore(ChronoLocalDate other) 检查此日期是否早于指定日期。
boolean	isEqual(ChronoLocalDate other) 检查此日期是否等于指定的日期。
boolean	isLeapYear() 根据ISO proleptic日历系统规则检查年份是否为闰年。
boolean	isSupported(TemporalField field) 检查是否支持指定的字段。
boolean	isSupported(TemporalUnit unit) 检查是否支持指定的单元。
int	lengthOfMonth() 返回此日期表示的月份长度。
int	lengthOfYear() 返回此日期表示的年份长度。
LocalDate	minus(long amountToSubtract, TemporalUnit unit) 返回此日期减去指定金额后的副本。
LocalDate	minus(TemporalAmount amountToSubtract) 返回此日期减去指定金额后的副本。
LocalDate	minusDays(long daysToSubtract) 返回此“LocalDate”的副本，并减去指定的天数。
LocalDate	minusMonths(long monthsToSubtract) 返回此“LocalDate”的副本，并减去指定的月数。
LocalDate	minusWeeks(long weeksToSubtract) 返回此“LocalDate”的副本，并减去指定的周数。
LocalDate	minusYears(long yearsToSubtract) 返回此“LocalDate”的副本，并减去指定的年数。
static LocalDate	now() 从默认时区的系统时钟获取当前日期。
static LocalDate	now(Clock clock) 从指定的时钟获取当前日期。
static LocalDate	now(ZoneId zone) 从指定时区的系统时钟获取当前日期。
static LocalDate	of(int year, int month, int dayOfMonth) 从年、月和日中获取“LocalDate”的实例。
static LocalDate	of(int year, Month month, int dayOfMonth) 从年、月和日中获取“LocalDate”的实例。
static LocalDate	ofEpochDay(long epochDay) .从历元日计数中获取“LocalDate”的实例
static LocalDate	ofYearDay(int year, int dayOfYear) .从一年中的某一天获取“LocalDate”的实例
static LocalDate	parse(CharSequence text) 从“2007-12-03”等文本字符串中获取“LocalDate”的实例`
static LocalDate	parse(CharSequence text, DateTimeFormatter formatter) 使用特定的格式化程序从文本字符串中获取“LocalDate”的实例。
LocalDate	plus(long amountToAdd, TemporalUnit unit) 返回添加了指定金额的此日期的副本。
LocalDate	plus(TemporalAmount amountToAdd) 返回添加了指定金额的此日期的副本。
LocalDate	plusDays(long daysToAdd) 返回添加了指定天数的“LocalDate”的副本。
LocalDate	plusMonths(long monthsToAdd) 返回此“LocalDate”的副本，并添加指定的月数。
LocalDate	plusWeeks(long weeksToAdd) 返回此“LocalDate”的副本，并添加指定的周数。
LocalDate	plusYears(long yearsToAdd) 返回此“LocalDate”的副本，并添加指定的年数。
<R> R	query(TemporalQuery<R> query) 使用指定的查询查询此日期。
ValueRange	range(TemporalField field) 获取指定字段的有效值范围。
long	toEpochDay() 将此日期转换为大纪元日。
Period	until(ChronoLocalDate endDateExclusive) 将此日期与另一日期之间的期间计算为“期间”。 // these two lines are equivalent period = start.until(end); period = Period.between(start, end);
long	until(Temporal endExclusive, TemporalUnit unit) 以指定的单位计算到另一个日期的时间量。 // these two lines are equivalent amount = start.until(end, MONTHS); amount = MONTHS.between(start, end);
LocalDate	with(TemporalAdjuster adjuster) 返回此日期的调整副本。 result = localDate.with(JULY).with(lastDayOfMonth());
LocalDate	with(TemporalField field, long newValue) 返回此日期的副本，并将指定字段设置为新值。
LocalDate	withDayOfMonth(int dayOfMonth) 返回更改了月份中的天数的“LocalDate”副本。
LocalDate	withDayOfYear(int dayOfYear) 返回更改了日期的“LocalDate”的副本。
LocalDate	withMonth(int month) 返回更改了月份的“LocalDate”副本。
LocalDate	withYear(int year) 返回更改了年份的“LocalDate”副本。

LocalDateTime

ISO-8601日历系统中没有时区的日期时间，例如2007-12-03T10:15:30。

LocalDateTime是一个不可变的日期时间对象，表示日期时间，通常被视为年-月-日-小时-分-秒。

Modifier and Type	Method and Description
Temporal	adjustInto(Temporal temporal) 调整指定的时间对象，使其与此对象具有相同的日期和时间。 // these two lines are equivalent, but the second approach is recommended temporal = thisLocalDateTime.adjustInto(temporal); temporal = temporal.with(thisLocalDateTime);
OffsetDateTime	atOffset(ZoneOffset offset) 将此日期时间与偏移量组合以创建OffsetDateTime。
ZonedDateTime	atZone(ZoneId zone) 将此日期时间与时区组合以创建ZonedDateTime。
int	compareTo(ChronoLocalDateTime<?> other) 将此日期时间与另一个日期时间进行比较。
String	format(DateTimeFormatter formatter) 使用指定的格式化程序格式化此日期时间。
static LocalDateTime	from(TemporalAccessor temporal) 从temporal对象获取LocalDateTime的实例。
int	get(TemporalField field) 从该日期时间获取指定字段的int值。
int	getDayOfMonth()Gets the day-of-month field.
DayOfWeek	getDayOfWeek()Gets the day-of-week field, which is an enum DayOfWeek.
int	getDayOfYear()Gets the day-of-year field.
int	getHour()Gets the hour-of-day field.
long	getLong(TemporalField field) 从该日期时间获取指定字段的“long”值。
int	getMinute()Gets the minute-of-hour field.
Month	getMonth()Gets the month-of-year field using the Month enum.
int	getMonthValue()Gets the month-of-year field from 1 to 12.
int	getNano()Gets the nano-of-second field.
int	getSecond()Gets the second-of-minute field.
int	getYear()Gets the year field.
boolean	isAfter(ChronoLocalDateTime<?> other) 检查此日期时间是否在指定的日期时间之后。
boolean	isBefore(ChronoLocalDateTime<?> other) 检查此日期时间是否早于指定的日期时间。
boolean	isEqual(ChronoLocalDateTime<?> other) 检查此日期时间是否等于指定的日期时间。
boolean	isSupported(TemporalField field) 检查是否支持指定的字段。
boolean	isSupported(TemporalUnit unit) 检查是否支持指定的单元。
LocalDateTime	minus(long amountToSubtract, TemporalUnit unit) 返回此日期时间的副本，并减去指定的金额。
LocalDateTime	minus(TemporalAmount amountToSubtract) 返回此日期时间的副本，并减去指定的金额。
LocalDateTime	minusDays(long days) 返回此“LocalDateTime”的副本，并减去指定的天数。
LocalDateTime	minusHours(long hours) 返回此“LocalDateTime”的副本，并减去指定的小时数。
LocalDateTime	minusMinutes(long minutes) 返回此“LocalDateTime”的副本，并减去指定的分钟数。
LocalDateTime	minusMonths(long months) 返回此“LocalDateTime”的副本，并减去指定的月数。
LocalDateTime	minusNanos(long nanos) 返回此“LocalDateTime”的副本，并减去指定的纳秒数。
LocalDateTime	minusSeconds(long seconds) 返回此“LocalDateTime”的副本，并减去指定的秒数。
LocalDateTime	minusWeeks(long weeks) 返回此“LocalDateTime”的副本，并减去指定的周数。
LocalDateTime	minusYears(long years) 返回此“LocalDateTime”的副本，并减去指定的年数。
static LocalDateTime	now() 从默认时区的系统时钟获取当前日期时间。
static LocalDateTime	now(Clock clock) 从指定的时钟获取当前日期时间。
static LocalDateTime	now(ZoneId zone) 从指定时区的系统时钟获取当前日期时间。
static LocalDateTime	of(int year, int month, int dayOfMonth, int hour, int minute) 从年、月、日、小时和分钟获取“LocalDateTime”的实例，将秒和纳秒设置为零。
static LocalDateTime	of(int year, int month, int dayOfMonth, int hour, int minute, int second) 从年、月、日、时、分和秒获取“LocalDateTime”的实例，将纳秒设置为零。
static LocalDateTime	of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond) 从年、月、日、时、分、秒和纳秒获取“LocalDateTime”的实例。
static LocalDateTime	of(int year, Month month, int dayOfMonth, int hour, int minute) 从年、月、日、小时和分钟获取“LocalDateTime”的实例，将秒和纳秒设置为零。
static LocalDateTime	of(int year, Month month, int dayOfMonth, int hour, int minute, int second) 从年、月、日、时、分和秒获取“LocalDateTime”的实例，将纳秒设置为零。
static LocalDateTime	of(int year, Month month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond) 从年、月、日、时、分、秒和纳秒获取“LocalDateTime”的实例。
static LocalDateTime	of(LocalDate date, LocalTime time) 从日期和时间获取“LocalDateTime”的实例。
static LocalDateTime	ofEpochSecond(long epochSecond, int nanoOfSecond, ZoneOffset offset) 使用1970-01-01T00:00:00Z纪元的秒数获取“LocalDateTime”的实例。
static LocalDateTime	ofInstant(Instant instant, ZoneId zone) 从'Instant'和区域ID获取'LocalDateTime'的实例。
static LocalDateTime	parse(CharSequence text) 从诸如“2007-12-03T10:15:30”之类的文本字符串中获取“LocalDateTime”的实例。
static LocalDateTime	parse(CharSequence text, DateTimeFormatter formatter) 使用特定的格式化程序从文本字符串中获取“LocalDateTime”的实例。
LocalDateTime	plus(long amountToAdd, TemporalUnit unit) 返回添加了指定金额的此日期时间的副本。
LocalDateTime	plus(TemporalAmount amountToAdd) 返回添加了指定金额的此日期时间的副本。
LocalDateTime	plusDays(long days) 返回添加了指定天数的“LocalDateTime”的副本。
LocalDateTime	plusHours(long hours) 返回此“LocalDateTime”的副本，并添加指定的小时数。
LocalDateTime	plusMinutes(long minutes) 返回此“LocalDateTime”的副本，并添加指定的分钟数。
LocalDateTime	plusMonths(long months) 返回此“LocalDateTime”的副本，并添加指定的月数。
LocalDateTime	plusNanos(long nanos) 返回添加了指定纳秒数的“LocalDateTime”的副本。
LocalDateTime	plusSeconds(long seconds) 返回添加了指定秒数的“LocalDateTime”的副本。
LocalDateTime	plusWeeks(long weeks) 返回添加了指定周数的“LocalDateTime”的副本。
LocalDateTime	plusYears(long years) 返回此“LocalDateTime”的副本，并添加指定的年数。
<R> R	query(TemporalQuery<R> query) 使用指定的查询查询此日期时间。
ValueRange	range(TemporalField field) 获取指定字段的有效值范围。
LocalDate	toLocalDate() 获取此日期时间的'LocalDate'部分。
LocalTime	toLocalTime() 获取此日期时间的“LocalTime”部分。
String	toString()Outputs this date-time as a String, such as 2007-12-03T10:15:30.
LocalDateTime	truncatedTo(TemporalUnit unit) 返回此“LocalDateTime”的副本，时间被截断。
long	until(Temporal endExclusive, TemporalUnit unit) 根据指定的单位计算到另一个日期时间的时间量。 // these two lines are equivalent amount = start.until(end, MONTHS); amount = MONTHS.between(start, end);
LocalDateTime	with(TemporalAdjuster adjuster) 返回此日期时间的调整副本。
LocalDateTime	with(TemporalField field, long newValue) 返回此日期时间的副本，并将指定字段设置为新值。
LocalDateTime	withDayOfMonth(int dayOfMonth) 返回更改了月份日期的“LocalDateTime”副本。
LocalDateTime	withDayOfYear(int dayOfYear) 返回更改了日期的“LocalDateTime”副本。
LocalDateTime	withHour(int hour) 返回此“LocalDateTime”的副本，并更改一天中的小时数。
LocalDateTime	withMinute(int minute) 返回更改了小时分钟数的“LocalDateTime”副本。
LocalDateTime	withMonth(int month) 返回更改了月份的“LocalDateTime”副本。
LocalDateTime	withNano(int nanoOfSecond) 返回此“LocalDateTime”的一个副本，更改了nano的秒数。
LocalDateTime	withSecond(int second) 返回此“LocalDateTime”的副本，并更改秒数。
LocalDateTime	withYear(int year) 返回更改了年份的“LocalDateTime”副本。

LocalTime

ISO-8601日历系统中没有时区的时间，如10:15:30。

Modifier and Type	Field and Description
static LocalTime	MAXThe maximum supported LocalTime, '23:59:59.999999999'.
static LocalTime	MIDNIGHTThe time of midnight at the start of the day, '00:00'.
static LocalTime	MINThe minimum supported LocalTime, '00:00'.
static LocalTime	NOONThe time of noon in the middle of the day, '12:00'.

MonthDay

ISO-8601日历系统中的一个月，例如--12-03。

MonthDay是一个不可变的日期-时间对象，表示一个月和一个月中的某一天的组合

Modifier and Type	Method and Description
Temporal	adjustInto(Temporal temporal) 调整指定的时间对象，使其具有本月的日期。 // these two lines are equivalent, but the second approach is recommended temporal = thisMonthDay.adjustInto(temporal); temporal = temporal.with(thisMonthDay);
LocalDate	atYear(int year) 将这个月的一天与一年结合起来创建一个“LocalDate”。
int	compareTo(MonthDay other) 将这个月的一天与另一个月的一天进行比较。
String	format(DateTimeFormatter formatter) 使用指定的格式化程序格式化此月日。
static MonthDay	from(TemporalAccessor temporal) 从时间对象中获取“MonthDay”的实例。
int	get(TemporalField field) 从本月日开始获取指定字段的值，该值为“int”。
int	getDayOfMonth() 获取月日字段。
long	getLong(TemporalField field) 从本月日开始获取指定字段的“long”值。
Month	getMonth() 使用'month'枚举获取月份字段。
int	getMonthValue() 获取从1到12的月份字段。
boolean	isAfter(MonthDay other) 检查此月日是否在指定的月日之后。
boolean	isBefore(MonthDay other) 检查此月日是否早于指定的月日。
boolean	isSupported(TemporalField field) 检查是否支持指定的字段。
boolean	isValidYear(int year) 检查年份是否在此月日有效。
static MonthDay	now() 从默认时区的系统时钟获取当前月份。
static MonthDay	now(Clock clock) 从指定的时钟获取当前月份。
static MonthDay	now(ZoneId zone) 从指定时区的系统时钟获取当前月份。
static MonthDay	of(int month, int dayOfMonth) 获取“MonthDay”的实例。
static MonthDay	of(Month month, int dayOfMonth) 获取“MonthDay”的实例。
static MonthDay	parse(CharSequence text) 从诸如“--12-03”之类的文本字符串中获取“MonthDay”的实例。
static MonthDay	parse(CharSequence text, DateTimeFormatter formatter) 使用特定的格式化程序从文本字符串中获取“MonthDay”的实例。
<R> R	query(TemporalQuery<R> query) 使用指定的查询在此月日进行查询。
ValueRange	range(TemporalField field) 获取指定字段的有效值范围。
String	toString()Outputs this month-day as a String, such as --12-03.
MonthDay	with(Month month) 返回更改了月份的“MonthDay”副本。
MonthDay	withDayOfMonth(int dayOfMonth) 返回此“MonthDay”的副本，更改了月份的日期
MonthDay	withMonth(int month) 返回更改了月份的“MonthDay”副本。

OffsetDateTime

在ISO-8601日历系统中，带有UTC/Greenwich偏移的日期时间，例如2007-12-03T10:15:30+01:00。

Modifier and Type	Method and Description
Temporal	adjustInto(Temporal temporal) 调整指定的时间对象，使其具有与此对象相同的偏移、日期和时间。 // these two lines are equivalent, but the second approach is recommended temporal = thisOffsetDateTime.adjustInto(temporal); temporal = temporal.with(thisOffsetDateTime);
ZonedDateTime	atZoneSameInstant(ZoneId zone) 将此日期时间与时区组合，以创建“ZonedDateTime”，确保结果具有相同的瞬间。 时区变了，日期和时间也会变。
ZonedDateTime	atZoneSimilarLocal(ZoneId zone) 将此日期时间与时区组合，创建一个“ZonedDateTime”，试图保持相同的本地日期和时间。 时区变了，日期和时间不会变
int	compareTo(OffsetDateTime other) 将此日期时间与另一个日期时间进行比较。
String	format(DateTimeFormatter formatter) 使用指定的格式化程序格式化此日期时间。
static OffsetDateTime	from(TemporalAccessor temporal) 从时态对象获取“OffsetDateTime”的实例。
int	get(TemporalField field) 从该日期时间获取指定字段的值，该值为“int”。
int	getDayOfMonth() 获取月日字段。
DayOfWeek	getDayOfWeek() 获取星期天字段，该字段是枚举“DayOfWeek”。
int	getDayOfYear() 获取“年度日期”字段。
int	getHour() 获取小时
long	getLong(TemporalField field) 从该日期时间获取指定字段的“long”值。
int	getMinute() 获取小时分钟字段。
Month	getMonth() 使用'month'枚举获取月份字段。
int	getMonthValue() 获取从1到12的月份字段。
int	getNano() 获取第二个字段的nano。
ZoneOffset	getOffset() 获取区域偏移量，例如“+01:00”。
int	getSecond() 获取秒
int	getYear() 获取年份字段。
boolean	isAfter(OffsetDateTime other) 检查此日期时间的瞬间是否在指定日期时间的瞬间之后。
boolean	isBefore(OffsetDateTime other) 检查此日期时间的瞬间是否早于指定日期时间。
boolean	isEqual(OffsetDateTime other) 检查此日期时间的瞬间是否等于指定日期时间的瞬间。
boolean	isSupported(TemporalField field) 检查是否支持指定的字段。
boolean	isSupported(TemporalUnit unit) 检查是否支持指定的单元。
OffsetDateTime	minus(long amountToSubtract, TemporalUnit unit) 返回此日期时间的副本，并减去指定的金额。
OffsetDateTime	minus(TemporalAmount amountToSubtract) 返回此日期时间的副本，并减去指定的金额。
OffsetDateTime	minusDays(long days) 返回此“OffsetDateTime”的副本，并减去指定的天数。
OffsetDateTime	minusHours(long hours) 返回此“OffsetDateTime”的副本，并减去指定的小时数。
OffsetDateTime	minusMinutes(long minutes) 返回此“OffsetDateTime”的副本，并减去指定的分钟数。
OffsetDateTime	minusMonths(long months) 返回此“OffsetDateTime”的副本，并减去指定的月数。
OffsetDateTime	minusNanos(long nanos) 返回此“OffsetDateTime”的副本，并减去指定的纳秒数。
OffsetDateTime	minusSeconds(long seconds) 返回此“OffsetDateTime”的副本，并减去指定的秒数。
OffsetDateTime	minusWeeks(long weeks) 返回此“OffsetDateTime”的副本，并减去指定的周数。
OffsetDateTime	minusYears(long years) 返回此“OffsetDateTime”的副本，并减去指定的年数。
static OffsetDateTime	now() 从默认时区的系统时钟获取当前日期时间。
static OffsetDateTime	now(Clock clock) 从指定的时钟获取当前日期时间。
static OffsetDateTime	now(ZoneId zone) 从指定时区的系统时钟获取当前日期时间。
static OffsetDateTime	of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset) 从年、月、日、小时、分钟、秒、纳秒和偏移量中获取“OffsetDateTime”的实例。
static OffsetDateTime	of(LocalDate date, LocalTime time, ZoneOffset offset) 从日期、时间和偏移量中获取“OffsetDateTime”的实例。
static OffsetDateTime	of(LocalDateTime dateTime, ZoneOffset offset) 从日期时间和偏移量中获取“OffsetDateTime”的实例。
static OffsetDateTime	ofInstant(Instant instant, ZoneId zone) 从'Instant'和区域ID获取'OffsetDateTime'的实例。
static OffsetDateTime	parse(CharSequence text) 从诸如“2007-12-03T10:15:30+01:00”之类的文本字符串中获取“OffsetDateTime”的实例。
static OffsetDateTime	parse(CharSequence text, DateTimeFormatter formatter) 使用特定的格式化程序从文本字符串中获取“OffsetDateTime”的实例。
OffsetDateTime	plus(long amountToAdd, TemporalUnit unit) 返回添加了指定金额的此日期时间的副本。
OffsetDateTime	plus(TemporalAmount amountToAdd) 返回添加了指定金额的此日期时间的副本。
OffsetDateTime	plusDays(long days) 返回此OffsetDateTime的副本，并添加指定的天数。
OffsetDateTime	plusHours(long hours) 返回此“OffsetDateTime”的副本，并添加指定的小时数。
OffsetDateTime	plusMinutes(long minutes) 返回此“OffsetDateTime”的副本，并添加指定的分钟数。
OffsetDateTime	plusMonths(long months) 返回此“OffsetDateTime”的副本，并添加指定的月数。
OffsetDateTime	plusNanos(long nanos)Returns a copy of this OffsetDateTime with the specified number of nanoseconds added.
OffsetDateTime	plusSeconds(long seconds)Returns a copy of this OffsetDateTime with the specified number of seconds added.
OffsetDateTime	plusWeeks(long weeks)Returns a copy of this OffsetDateTime with the specified number of weeks added.
OffsetDateTime	plusYears(long years)Returns a copy of this OffsetDateTime with the specified number of years added.
<R> R	query(TemporalQuery<R> query)Queries this date-time using the specified query.
ValueRange	range(TemporalField field)Gets the range of valid values for the specified field.
static Comparator<OffsetDateTime>	timeLineOrder() 获取一个比较器，该比较器仅基于瞬间比较两个“OffsetDateTime”实例。
long	toEpochSecond() 将此日期时间转换为从1970-01-01T00:00:00Z开始的秒数。
Instant	toInstant()Converts this date-time to an Instant.
LocalDate	toLocalDate()Gets the LocalDate part of this date-time.
LocalDateTime	toLocalDateTime()Gets the LocalDateTime part of this date-time.
LocalTime	toLocalTime()Gets the LocalTime part of this date-time.
OffsetTime	toOffsetTime()Converts this date-time to an OffsetTime.
String	toString()Outputs this date-time as a String, such as 2007-12-03T10:15:30+01:00.
ZonedDateTime	toZonedDateTime() 使用偏移量作为分区ID，将此日期时间转换为“ZonedDateTime”。
OffsetDateTime	truncatedTo(TemporalUnit unit)Returns a copy of this OffsetDateTime with the time truncated.
long	until(Temporal endExclusive, TemporalUnit unit)Calculates the amount of time until another date-time in terms of the specified unit. // these two lines are equivalent amount = start.until(end, MONTHS); amount = MONTHS.between(start, end);
OffsetDateTime	with(TemporalAdjuster adjuster) 返回此日期时间的调整副本。
OffsetDateTime	with(TemporalField field, long newValue) 返回此日期时间的副本，并将指定字段设置为新值。
OffsetDateTime	withDayOfMonth(int dayOfMonth) 返回此“OffsetDateTime”的副本，更改了月份的日期。
OffsetDateTime	withDayOfYear(int dayOfYear) 返回此“OffsetDateTime”的副本，并更改日期。
OffsetDateTime	withHour(int hour) 返回此“OffsetDateTime”的副本，并更改一天中的小时数。
OffsetDateTime	withMinute(int minute) 返回此“OffsetDateTime”的副本，并更改小时分钟数。
OffsetDateTime	withMonth(int month) 返回更改了月份的“OffsetDateTime”副本。
OffsetDateTime	withNano(int nanoOfSecond) 返回此“OffsetDateTime”的副本，其中更改了秒数。
OffsetDateTime	withOffsetSameInstant(ZoneOffset offset) 返回带有指定偏移量的“OffsetDateTime”的副本，确保结果在同一时刻。
OffsetDateTime	withOffsetSameLocal(ZoneOffset offset) 返回具有指定偏移量的“OffsetDateTime”副本，确保结果具有相同的本地日期时间。
OffsetDateTime	withSecond(int second) 返回此“OffsetDateTime”的副本，更改秒数。
OffsetDateTime	withYear(int year) 返回此“OffsetDateTime”的副本，并更改年份。

OffsetTime

在ISO-8601日历系统中，与UTC/Greenwich有偏移的时间，例如10:15:30+01:00。

Period

ISO-8601日历系统中基于日期的时间量，例如“2年、3个月和4天”。

以年、月和日为单位对时间的数量或数量进行建模、

Modifier and Type	Method and Description
Temporal	addTo(Temporal temporal) 将此句点添加到指定的时间对象。 // these two lines are equivalent, but the second approach is recommended dateTime = thisPeriod.addTo(dateTime); dateTime = dateTime.plus(thisPeriod);
static Period	between(LocalDate startDateInclusive, LocalDate endDateExclusive) 获取由两个日期之间的年、月和日数组成的“期间”。
static Period	from(TemporalAmount amount) 从时间量中获取“Period”的实例。
long	get(TemporalUnit unit) 获取请求的单位的值。
IsoChronology	getChronology() 获取此期间的年表，它是ISO日历系统。
int	getDays() 获取此期间的天数。
int	getMonths() 获取此期间的月数
List<TemporalUnit>	getUnits() 获取此时段支持的单位集。
int	getYears() 获取此期间的年数。
boolean	isNegative() 检查这段时间的三个单位中是否有一个是负数。
boolean	isZero() 检查这段时间的三个单位是否都为零。
Period	minus(TemporalAmount amountToSubtract) 返回此期间的副本，并减去指定的期间。
Period	minusDays(long daysToSubtract) 返回减去指定天数后的该时段的副本。
Period	minusMonths(long monthsToSubtract) 返回减去指定月份后的该期间的副本。
Period	minusYears(long yearsToSubtract) 返回减去指定年份后的该期间的副本。
Period	multipliedBy(int scalar) 返回一个新实例，其中该期间的每个元素都乘以指定的标量。
Period	negated() 返回一个新实例，该期间的每个金额都为负数。
Period	normalized() 回此期间的一份副本，其中包含正常化的年份和月份。
static Period	of(int years, int months, int days) 获取表示年、月和日数的“Period”。
static Period	ofDays(int days) 获取表示天数的“Period”。
static Period	ofMonths(int months) 获取表示月份数的“Period”。
static Period	ofWeeks(int weeks) 获取表示周数的“Period”。
static Period	ofYears(int years) 获取表示年数的“Period”。
static Period	parse(CharSequence text) 从“PnYnMnD”等文本字符串中获取“句点”。
Period	plus(TemporalAmount amountToAdd) 返回添加了指定期间的此期间的副本。
Period	plusDays(long daysToAdd) 返回添加了指定天数的此期间的副本。
Period	plusMonths(long monthsToAdd) 返回添加了指定月份的此期间的副本。
Period	plusYears(long yearsToAdd) 返回添加了指定年份的此期间的副本。
Temporal	subtractFrom(Temporal temporal) 从指定的时间对象中减去该周期。
String	toString()Outputs this period as a String, such as P6Y3M1D.
long	toTotalMonths() 获取此期间的总月数。
Period	withDays(int days) 返回指定天数的此期间的副本。
Period	withMonths(int months) 返回指定月份数的此期间的副本。
Period	withYears(int years) 返回指定年数的此期间的副本。

Year

ISO-8601日历系统中的年份，例如2007年。

YearMonth

ISO-8601日历系统中的一年一月，如2007-12。

ZonedDateTime

在ISO-8601日历系统中带有时区的日期时间，例如2007-12-03T10:15:30+01:00 Europe/Paris。

此类存储所有日期和时间字段（精度为纳秒）以及时区，时区偏移用于处理不明确的本地日期时间

ZoneId

时区ID，例如欧洲/巴黎。

ZoneId用于标识用于在Instant和LocalDateTime之间转换的规则。有两种不同类型的ID：

固定偏移量，Geographical regions

Modifier and Type	Field and Description
static Map<String,String>	SHORT_IDSA map of zone overrides to enable the short time-zone names to be used.

This maps as follows:

• EST - -05:00

• HST - -10:00

• MST - -07:00

• ACT - Australia/Darwin

• AET - Australia/Sydney

• AGT - America/Argentina/Buenos_Aires

• ART - Africa/Cairo

• AST - America/Anchorage

• BET - America/Sao_Paulo

• BST - Asia/Dhaka

• CAT - Africa/Harare

• CNT - America/St_Johns

• CST - America/Chicago

• CTT - Asia/Shanghai

• EAT - Africa/Addis_Ababa

• ECT - Europe/Paris

• IET - America/Indiana/Indianapolis

• IST - Asia/Kolkata

• JST - Asia/Tokyo

• MIT - Pacific/Apia

• NET - Asia/Yerevan

• NST - Pacific/Auckland

• PLT - Asia/Karachi

• PNT - America/Phoenix

• PRT - America/Puerto_Rico

• PST - America/Los_Angeles

• SST - Pacific/Guadalcanal

• VST - Asia/Ho_Chi_Minh

Modifier and Type	Method and Description
boolean	equals(Object obj)Checks if this time-zone ID is equal to another time-zone ID.
static ZoneId	from(TemporalAccessor temporal) 从时态对象获取“ZoneId”的实例。
static Set<String>	getAvailableZoneIds() 获取可用区域ID的集合。
String	getDisplayName(TextStyle style, Locale locale) 获取区域的文本表示形式，例如“British Time”或“+02:00”。
abstract String	getId() 获取唯一的时区ID。
abstract ZoneRules	getRules() 获取允许执行计算的此ID的时区规则。
int	hashCode()A hash code for this time-zone ID.
ZoneId	normalized() 标准化时区ID，尽可能返回“ZoneOffset”。
static ZoneId	of(String zoneId) 从ID获取“ZoneId”的实例，确保该ID有效且可供使用。
static ZoneId	of(String zoneId, Map<String,String> aliasMap) 使用“ZoneId”的ID获取“ZoneId”的实例，并使用别名映射来补充标准的区域ID。
static ZoneId	ofOffset(String prefix, ZoneOffset offset) 获取包装偏移量的'ZoneId'实例。
static ZoneId	systemDefault() 获取系统默认时区。
String	toString()Outputs this zone as a String, using the ID.

ZoneOffset

与Greenwich/UTC的时区偏移，例如+02:00。

Modifier and Type	Field and Description
static ZoneOffset	MAXConstant for the maximum supported offset.
static ZoneOffset	MINConstant for the maximum supported offset.
static ZoneOffset	UTCThe time-zone offset for UTC, with an ID of 'Z'.

Modifier and Type	Method and Description
Temporal	adjustInto(Temporal temporal) 调整指定的时间对象，使其具有与此对象相同的偏移。
int	compareTo(ZoneOffset other) 按降序将此偏移量与另一个偏移量进行比较。
boolean	equals(Object obj)Checks if this offset is equal to another offset.
static ZoneOffset	from(TemporalAccessor temporal) 从时间对象获取“ZoneOffset”的实例。
int	get(TemporalField field) 从该偏移量获取指定字段的值，该值为“int”。
String	getId() 获取规范化区域偏移ID。
long	getLong(TemporalField field) 从该偏移量中获取指定字段的“long”值。
ZoneRules	getRules() 获取关联的时区规则。
int	getTotalSeconds() 获取以秒为单位的总区域偏移量。
int	hashCode()A hash code for this offset.
boolean	isSupported(TemporalField field) 检查是否支持指定的字段。
static ZoneOffset	of(String offsetId) 使用ID获取“ZoneOffset”的实例。
static ZoneOffset	ofHours(int hours) 使用小时偏移量获取“ZoneOffset”的实例。
static ZoneOffset	ofHoursMinutes(int hours, int minutes) 使用小时和分钟的偏移量获取“ZoneOffset”的实例。
static ZoneOffset	ofHoursMinutesSeconds(int hours, int minutes, int seconds) 使用小时、分钟和秒的偏移量获取“ZoneOffset”的实例。
static ZoneOffset	ofTotalSeconds(int totalSeconds) 获取“ZoneOffset”的实例，指定以秒为单位的总偏移量
<R> R	query(TemporalQuery<R> query) 使用指定的查询查询此偏移量。
ValueRange	range(TemporalField field) 获取指定字段的有效值范围。
String	toString()Outputs this offset as a String, using the normalized ID.

DayOfWeek

一周中的一天，如“星期二”。

Enum Constant and Description
FRIDAY 星期五这一天的单身例子。
MONDAY 星期一的星期一的单身实例。
SATURDAY 星期六这一天的单身例子。
SUNDAY 星期天一周中的某一天的单身实例。
THURSDAY 星期四这一天的单身实例。
TUESDAY 星期二这一天的单身实例。
WEDNESDAY 星期三这一天的单身实例。

Month

一年中的一个月，如“七月”

Enum Constant and Description
APRIL 四月30天的单身实例。
AUGUST 8月份31天的单身实例。
DECEMBER 12月31天的单例实例。
FEBRUARY 例如，2月份的单身汉有28天，闰年为29天。
JANUARY 1月31天的单身实例。
JULY 7月31天的单身实例。
JUNE 6月30天的单身实例。
MARCH 3月31天的单身实例。
MAY 5月的单身实例为31天。
NOVEMBER 11月30天的单身实例。
OCTOBER 10月份的单身实例，有31天。
SEPTEMBER 9月份的单身实例，有30天。

练习

代码围绕LocalDateTime来扩展的，包括LocalDateTime的获取、格式化、日期时间计算三个方面。涉及的知识点包括java.time.chrono、java.time.temporal、java.time.format和java.time包下的类的使用，主要是认识并掌握一些类的使用，没有涉及太多的日期时间计算的相关操作。

package time;

import java.time.*;
import java.time.chrono.Chronology;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.FormatStyle;
import java.time.format.TextStyle;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalField;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

public class Java8DateTimeApi {
    public static void main(String[] args) {
        LocalDateTime start = now();
        LocalDateTime end = start.plusDays(1);
        long daysBetween = getDaysBetween(start, end);
        long monthsBetween = getMonthsBetween(start, end);
        System.out.println("相差的天数:" + daysBetween);
        System.out.println("相差的月分:" + monthsBetween);

        String s = formatSpecifiedField(start, ChronoField.MONTH_OF_YEAR, 1);
        System.out.println("月份：" + s);

        String s1 = chinaMonth(start);
        System.out.println("中文月份:" + s1);

        OffsetDateTime offsetDateTime = OffsetDateTime.now();
        String s2 = offsetFormat(offsetDateTime);
        System.out.println("偏移量:" + s2);

        String s3 = yyyyMMddHHmmSsFormat(offsetDateTime);
        System.out.println("年-月-日 时:分:秒 星期 第几周 偏移量");
        System.out.println(s3);

        getBaseInfo(LocalDateTime.from(offsetDateTime));
    }

    /**
     * 第一部分：获取LocalDateTime对象
     */

    public static LocalDateTime now() {
        return LocalDateTime.now();
    }

    public static LocalDateTime nowWithDefaultClock() {
        Clock clock = Clock.systemDefaultZone();
        return LocalDateTime.now(clock);
    }

    public static LocalDateTime nowWithUTCClock() {
        Clock clock = Clock.systemUTC();
        return LocalDateTime.now(clock);
    }

    public static LocalDateTime nowWithSpecifiedClock(ZoneIdEnum zoneIdEnum) {
        Clock clock = Clock.system(ZoneId.of(zoneIdEnum.zoneId));
        return LocalDateTime.now(clock);
    }

    public static LocalDateTime nowWithDefaultZoneId() {
        ZoneId zoneId = ZoneId.systemDefault();
        return LocalDateTime.now(zoneId);
    }

    public static LocalDateTime nowWithSpecifiedZoneId(ZoneIdEnum zoneIdEnum) {
        ZoneId zoneId = ZoneId.of(zoneIdEnum.zoneId);
        return LocalDateTime.now(zoneId);
    }

    public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute) {
        return LocalDateTime.of(year, month, dayOfMonth, hour, minute);
    }


    /**
     * 第二部分：格式化LocalDateTime
     */

    public static String toString(LocalDateTime localDateTime) {
        // toString方法使用的是ISO-8601格式样式
        return localDateTime.toString();
    }

    public static String ofLocalizedDateTime(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL, FormatStyle.FULL);
        return formatter.format(localDateTime);
    }

    public static String basicIsoDate(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.BASIC_ISO_DATE;
        return formatter.format(localDateTime);
    }

    public static String isoLocalDateTime(LocalDateTime localDateTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        return formatter.format(localDateTime);
    }


    /**
     * 格式化指定的字段，并指定输出位数
     * @param localDateTime
     * @param temporalField
     * @param width
     * @return
     */
    public static String formatSpecifiedField(LocalDateTime localDateTime, TemporalField temporalField, int width) {
        DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
        builder.appendValue(temporalField, width);
        return builder.toFormatter().format(localDateTime);
    }

    /**
     * 输出两位数年
     * @param localDateTime
     * @return
     */
    public static String twoDigitYear(LocalDateTime localDateTime) {
        DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
        builder.appendValueReduced(ChronoField.YEAR, 2, 4, LocalDate.now());
        return builder.toFormatter().format(localDateTime);
    }

    /**
     * 月份输出为中文
     * @param localDateTime
     * @return
     */
    public static String chinaMonth(LocalDateTime localDateTime) {
        DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
        Map<Long, String> map = new HashMap();
        map.put(1l, "一月");
        map.put(2l, "二月");
        map.put(3l, "三月");
        map.put(4l, "四月");
        map.put(5l, "五月");
        map.put(6l, "六月");
        map.put(7l, "七月");
        map.put(8l, "八月");
        map.put(9l, "九月");
        map.put(10l, "十月");
        map.put(11l, "十一月");
        map.put(12l, "十二月");

        builder.appendText(ChronoField.MONTH_OF_YEAR, map);
        return builder.toFormatter().format(localDateTime);
    }

    /**
     * 限制纳秒位数
     * @param localDateTime
     * @return
     */
    public static String nanoOfSecondDigitsFormat(LocalDateTime localDateTime){
        DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
        // 返回纳秒位数为3
        builder.appendInstant(3);
        return builder.toFormatter().format(localDateTime);
    }

    /**
     * 格式化日期返回zoneId信息
     * @param localDateTime
     * @return
     */
    public static String zonedIdFormat(LocalDateTime localDateTime){
        return new DateTimeFormatterBuilder().appendZoneId().toFormatter().format(localDateTime);
    }

    /**
     * 格式化日期返回offset信息
     * @param localDateTime
     * @return
     */
    public static String offsetFormat(Temporal localDateTime){
        return new DateTimeFormatterBuilder().appendLocalizedOffset(TextStyle.FULL).toFormatter().format(localDateTime);
    }

    /**
     * yyyy-MM-dd HH:mm:ss E W O
     * @param localDateTime
     * @return
     */
    public static String yyyyMMddHHmmSsFormat(Temporal localDateTime){
        DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
        // E 星期 W 第几周 O 偏移量
        builder.appendPattern("yyyy-MM-dd HH:mm:ss E W O");
        return builder.toFormatter().format(localDateTime);
    }

    /**
     * 返回指定日历系统的格式化样式
     *
     * @param chronologyEnum
     * @return
     */
    public static String getLocalizedDateTimePattern(ChronologyEnum chronologyEnum) {
        return DateTimeFormatterBuilder.getLocalizedDateTimePattern(
                FormatStyle.FULL,
                FormatStyle.FULL,
                Chronology.of(chronologyEnum.chronology),
                Locale.CHINA);
    }


    /**
     * 第三部分：LocalDateTime日期、时间操作
     */

    public static void getBaseInfo(LocalDateTime localDateTime){
        int dayOfMonth = localDateTime.getDayOfMonth();
        DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
        int monthValue = localDateTime.getMonthValue();
        int year = localDateTime.getYear();
        Chronology chronology = localDateTime.getChronology();
        System.out.println(String.format("年分:%d, 月份:%d, 星期:%s, 这个月第几天:%d, 日历系统:%s",
                year, monthValue, dayOfWeek.getDisplayName(TextStyle.FULL, Locale.CHINA),dayOfMonth, chronology.getDisplayName(TextStyle.FULL, Locale.CHINA)));
    }

    /**
     * 返回两个日期相差的月份
     * @param start
     * @param end
     * @return
     */
    public static long getMonthsBetween(LocalDateTime start, LocalDateTime end){
        return ChronoUnit.MONTHS.between(start, end);
    }

    /**
     * 返回两个日期相差的天数
     * @param start
     * @param end
     * @return
     */
    public static long getDaysBetween(LocalDateTime start, LocalDateTime end){
        return ChronoUnit.DAYS.between(start, end);
    }

    public enum ChronologyEnum {
        Hijrah_umalqura("Hijrah-umalqura"),
        ThaiBuddhist("ThaiBuddhist"),
        Japanese("Japanese"),
        Minguo("Minguo"),
        ISO("ISO");

        private String chronology;

        ChronologyEnum(String chronology) {
            this.chronology = chronology;
        }
    }

    public enum ZoneIdEnum {
        ASIA_ADEN("Asia/Aden"),
        AMERICA_CUIABA("America/Cuiaba"),
        ETC_GMT_9("Etc/GMT+9"),
        ETC_GMT_8("Etc/GMT+8"),
        AFRICA_NAIROBI("Africa/Nairobi"),
        AMERICA_MARIGOT("America/Marigot"),
        ASIA_AQTAU("Asia/Aqtau"),
        PACIFIC_KWAJALEIN("Pacific/Kwajalein"),
        AMERICA_EL_SALVADOR("America/El_Salvador"),
        ASIA_PONTIANAK("Asia/Pontianak"),
        AFRICA_CAIRO("Africa/Cairo"),
        PACIFIC_PAGO_PAGO("Pacific/Pago_Pago"),
        AFRICA_MBABANE("Africa/Mbabane"),
        ASIA_KUCHING("Asia/Kuching"),
        PACIFIC_HONOLULU("Pacific/Honolulu"),
        PACIFIC_RAROTONGA("Pacific/Rarotonga"),
        AMERICA_GUATEMALA("America/Guatemala"),
        AUSTRALIA_HOBART("Australia/Hobart"),
        EUROPE_LONDON("Europe/London"),
        AMERICA_BELIZE("America/Belize"),
        AMERICA_PANAMA("America/Panama"),
        ASIA_CHUNGKING("Asia/Chungking"),
        AMERICA_MANAGUA("America/Managua"),
        AMERICA_INDIANA_PETERSBURG("America/Indiana/Petersburg"),
        ASIA_YEREVAN("Asia/Yerevan"),
        EUROPE_BRUSSELS("Europe/Brussels"),
        GMT("GMT"),
        EUROPE_WARSAW("Europe/Warsaw"),
        AMERICA_CHICAGO("America/Chicago"),
        ASIA_KASHGAR("Asia/Kashgar"),
        CHILE_CONTINENTAL("Chile/Continental"),
        PACIFIC_YAP("Pacific/Yap"),
        CET("CET"),
        ETC_GMT_1("Etc/GMT-1"),
        ETC_GMT_0("Etc/GMT-0"),
        EUROPE_JERSEY("Europe/Jersey"),
        AMERICA_TEGUCIGALPA("America/Tegucigalpa"),
        ETC_GMT_5("Etc/GMT-5"),
        EUROPE_ISTANBUL("Europe/Istanbul"),
        AMERICA_EIRUNEPE("America/Eirunepe"),
        ETC_GMT_4("Etc/GMT-4"),
        AMERICA_MIQUELON("America/Miquelon"),
        ETC_GMT_3("Etc/GMT-3"),
        EUROPE_LUXEMBOURG("Europe/Luxembourg"),
        ETC_GMT_2("Etc/GMT-2"),
        ETC_GMT_9_M("Etc/GMT-9"),
        AMERICA_ARGENTINA_CATAMARCA("America/Argentina/Catamarca"),
        ETC_GMT_8_M("Etc/GMT-8"),
        ETC_GMT_7("Etc/GMT-7"),
        ETC_GMT_6("Etc/GMT-6"),
        EUROPE_ZAPOROZHYE("Europe/Zaporozhye"),
        CANADA_YUKON("Canada/Yukon"),
        CANADA_ATLANTIC("Canada/Atlantic"),
        ATLANTIC_ST_HELENA("Atlantic/St_Helena"),
        AUSTRALIA_TASMANIA("Australia/Tasmania"),
        LIBYA("Libya"),
        EUROPE_GUERNSEY("Europe/Guernsey"),
        AMERICA_GRAND_TURK("America/Grand_Turk"),
        US_PACIFIC_NEW("US/Pacific-New"),
        ASIA_SAMARKAND("Asia/Samarkand"),
        AMERICA_ARGENTINA_CORDOBA("America/Argentina/Cordoba"),
        ASIA_PHNOM_PENH("Asia/Phnom_Penh"),
        AFRICA_KIGALI("Africa/Kigali"),
        ASIA_ALMATY("Asia/Almaty"),
        US_ALASKA("US/Alaska"),
        ASIA_DUBAI("Asia/Dubai"),
        EUROPE_ISLE_OF_MAN("Europe/Isle_of_Man"),
        AMERICA_ARAGUAINA("America/Araguaina"),
        CUBA("Cuba"),
        ASIA_NOVOSIBIRSK("Asia/Novosibirsk"),
        AMERICA_ARGENTINA_SALTA("America/Argentina/Salta"),
        ETC_GMT_3_P("Etc/GMT+3"),
        AFRICA_TUNIS("Africa/Tunis"),
        ETC_GMT_2_P("Etc/GMT+2"),
        ETC_GMT_1_P("Etc/GMT+1"),
        PACIFIC_FAKAOFO("Pacific/Fakaofo"),
        AFRICA_TRIPOLI("Africa/Tripoli"),
        ETC_GMT_0_P("Etc/GMT+0"),
        ISRAEL("Israel"),
        AFRICA_BANJUL("Africa/Banjul"),
        ETC_GMT_7_P("Etc/GMT+7"),
        INDIAN_COMORO("Indian/Comoro"),
        ETC_GMT_6_P("Etc/GMT+6"),
        ETC_GMT_5_P("Etc/GMT+5"),
        ETC_GMT_4_P("Etc/GMT+4"),
        PACIFIC_PORT_MORESBY("Pacific/Port_Moresby"),
        US_ARIZONA("US/Arizona"),
        ANTARCTICA_SYOWA("Antarctica/Syowa"),
        INDIAN_REUNION("Indian/Reunion"),
        PACIFIC_PALAU("Pacific/Palau"),
        EUROPE_KALININGRAD("Europe/Kaliningrad"),
        AMERICA_MONTEVIDEO("America/Montevideo"),
        AFRICA_WINDHOEK("Africa/Windhoek"),
        ASIA_KARACHI("Asia/Karachi"),
        AFRICA_MOGADISHU("Africa/Mogadishu"),
        AUSTRALIA_PERTH("Australia/Perth"),
        BRAZIL_EAST("Brazil/East"),
        ETC_GMT("Etc/GMT"),
        ASIA_CHITA("Asia/Chita"),
        PACIFIC_EASTER("Pacific/Easter"),
        ANTARCTICA_DAVIS("Antarctica/Davis"),
        ANTARCTICA_MCMURDO("Antarctica/McMurdo"),
        ASIA_MACAO("Asia/Macao"),
        AMERICA_MANAUS("America/Manaus"),
        AFRICA_FREETOWN("Africa/Freetown"),
        EUROPE_BUCHAREST("Europe/Bucharest"),
        ASIA_TOMSK("Asia/Tomsk"),
        AMERICA_ARGENTINA_MENDOZA("America/Argentina/Mendoza"),
        ASIA_MACAU("Asia/Macau"),
        EUROPE_MALTA("Europe/Malta"),
        MEXICO_BAJASUR("Mexico/BajaSur"),
        PACIFIC_TAHITI("Pacific/Tahiti"),
        AFRICA_ASMERA("Africa/Asmera"),
        EUROPE_BUSINGEN("Europe/Busingen"),
        AMERICA_ARGENTINA_RIO_GALLEGOS("America/Argentina/Rio_Gallegos"),
        AFRICA_MALABO("Africa/Malabo"),
        EUROPE_SKOPJE("Europe/Skopje"),
        AMERICA_CATAMARCA("America/Catamarca"),
        AMERICA_GODTHAB("America/Godthab"),
        EUROPE_SARAJEVO("Europe/Sarajevo"),
        AUSTRALIA_ACT("Australia/ACT"),
        GB_EIRE("GB-Eire"),
        AFRICA_LAGOS("Africa/Lagos"),
        AMERICA_CORDOBA("America/Cordoba"),
        EUROPE_ROME("Europe/Rome"),
        ASIA_DACCA("Asia/Dacca"),
        INDIAN_MAURITIUS("Indian/Mauritius"),
        PACIFIC_SAMOA("Pacific/Samoa"),
        AMERICA_REGINA("America/Regina"),
        AMERICA_FORT_WAYNE("America/Fort_Wayne"),
        AMERICA_DAWSON_CREEK("America/Dawson_Creek"),
        AFRICA_ALGIERS("Africa/Algiers"),
        EUROPE_MARIEHAMN("Europe/Mariehamn"),
        AMERICA_ST_JOHNS("America/St_Johns"),
        AMERICA_ST_THOMAS("America/St_Thomas"),
        EUROPE_ZURICH("Europe/Zurich"),
        AMERICA_ANGUILLA("America/Anguilla"),
        ASIA_DILI("Asia/Dili"),
        AMERICA_DENVER("America/Denver"),
        AFRICA_BAMAKO("Africa/Bamako"),
        GB("GB"),
        MEXICO_GENERAL("Mexico/General"),
        PACIFIC_WALLIS("Pacific/Wallis"),
        EUROPE_GIBRALTAR("Europe/Gibraltar"),
        AFRICA_CONAKRY("Africa/Conakry"),
        AFRICA_LUBUMBASHI("Africa/Lubumbashi"),
        ASIA_ISTANBUL("Asia/Istanbul"),
        AMERICA_HAVANA("America/Havana"),
        NZ_CHAT("NZ-CHAT"),
        ASIA_CHOIBALSAN("Asia/Choibalsan"),
        AMERICA_PORTO_ACRE("America/Porto_Acre"),
        ASIA_OMSK("Asia/Omsk"),
        EUROPE_VADUZ("Europe/Vaduz"),
        US_MICHIGAN("US/Michigan"),
        ASIA_DHAKA("Asia/Dhaka"),
        AMERICA_BARBADOS("America/Barbados"),
        EUROPE_TIRASPOL("Europe/Tiraspol"),
        ATLANTIC_CAPE_VERDE("Atlantic/Cape_Verde"),
        ASIA_YEKATERINBURG("Asia/Yekaterinburg"),
        AMERICA_LOUISVILLE("America/Louisville"),
        PACIFIC_JOHNSTON("Pacific/Johnston"),
        PACIFIC_CHATHAM("Pacific/Chatham"),
        EUROPE_LJUBLJANA("Europe/Ljubljana"),
        AMERICA_SAO_PAULO("America/Sao_Paulo"),
        ASIA_JAYAPURA("Asia/Jayapura"),
        AMERICA_CURACAO("America/Curacao"),
        ASIA_DUSHANBE("Asia/Dushanbe"),
        AMERICA_GUYANA("America/Guyana"),
        AMERICA_GUAYAQUIL("America/Guayaquil"),
        AMERICA_MARTINIQUE("America/Martinique"),
        PORTUGAL("Portugal"),
        EUROPE_BERLIN("Europe/Berlin"),
        EUROPE_MOSCOW("Europe/Moscow"),
        EUROPE_CHISINAU("Europe/Chisinau"),
        AMERICA_PUERTO_RICO("America/Puerto_Rico"),
        AMERICA_RANKIN_INLET("America/Rankin_Inlet"),
        PACIFIC_PONAPE("Pacific/Ponape"),
        EUROPE_STOCKHOLM("Europe/Stockholm"),
        EUROPE_BUDAPEST("Europe/Budapest"),
        AMERICA_ARGENTINA_JUJUY("America/Argentina/Jujuy"),
        AUSTRALIA_EUCLA("Australia/Eucla"),
        ASIA_SHANGHAI("Asia/Shanghai"),
        UNIVERSAL("Universal"),
        EUROPE_ZAGREB("Europe/Zagreb"),
        AMERICA_PORT_OF_SPAIN("America/Port_of_Spain"),
        EUROPE_HELSINKI("Europe/Helsinki"),
        ASIA_BEIRUT("Asia/Beirut"),
        ASIA_TEL_AVIV("Asia/Tel_Aviv"),
        PACIFIC_BOUGAINVILLE("Pacific/Bougainville"),
        US_CENTRAL("US/Central"),
        AFRICA_SAO_TOME("Africa/Sao_Tome"),
        INDIAN_CHAGOS("Indian/Chagos"),
        AMERICA_CAYENNE("America/Cayenne"),
        ASIA_YAKUTSK("Asia/Yakutsk"),
        PACIFIC_GALAPAGOS("Pacific/Galapagos"),
        AUSTRALIA_NORTH("Australia/North"),
        EUROPE_PARIS("Europe/Paris"),
        AFRICA_NDJAMENA("Africa/Ndjamena"),
        PACIFIC_FIJI("Pacific/Fiji"),
        AMERICA_RAINY_RIVER("America/Rainy_River"),
        INDIAN_MALDIVES("Indian/Maldives"),
        AUSTRALIA_YANCOWINNA("Australia/Yancowinna"),
        SYSTEMV_AST4("SystemV/AST4"),
        ASIA_ORAL("Asia/Oral"),
        AMERICA_YELLOWKNIFE("America/Yellowknife"),
        PACIFIC_ENDERBURY("Pacific/Enderbury"),
        AMERICA_JUNEAU("America/Juneau"),
        AUSTRALIA_VICTORIA("Australia/Victoria"),
        AMERICA_INDIANA_VEVAY("America/Indiana/Vevay"),
        ASIA_TASHKENT("Asia/Tashkent"),
        ASIA_JAKARTA("Asia/Jakarta"),
        AFRICA_CEUTA("Africa/Ceuta"),
        ASIA_BARNAUL("Asia/Barnaul"),
        AMERICA_RECIFE("America/Recife"),
        AMERICA_BUENOS_AIRES("America/Buenos_Aires"),
        AMERICA_NORONHA("America/Noronha"),
        AMERICA_SWIFT_CURRENT("America/Swift_Current"),
        AUSTRALIA_ADELAIDE("Australia/Adelaide"),
        AMERICA_METLAKATLA("America/Metlakatla"),
        AFRICA_DJIBOUTI("Africa/Djibouti"),
        AMERICA_PARAMARIBO("America/Paramaribo"),
        EUROPE_SIMFEROPOL("Europe/Simferopol"),
        EUROPE_SOFIA("Europe/Sofia"),
        AFRICA_NOUAKCHOTT("Africa/Nouakchott"),
        EUROPE_PRAGUE("Europe/Prague"),
        AMERICA_INDIANA_VINCENNES("America/Indiana/Vincennes"),
        ANTARCTICA_MAWSON("Antarctica/Mawson"),
        AMERICA_KRALENDIJK("America/Kralendijk"),
        ANTARCTICA_TROLL("Antarctica/Troll"),
        EUROPE_SAMARA("Europe/Samara"),
        INDIAN_CHRISTMAS("Indian/Christmas"),
        AMERICA_ANTIGUA("America/Antigua"),
        PACIFIC_GAMBIER("Pacific/Gambier"),
        AMERICA_INDIANAPOLIS("America/Indianapolis"),
        AMERICA_INUVIK("America/Inuvik"),
        AMERICA_IQALUIT("America/Iqaluit"),
        PACIFIC_FUNAFUTI("Pacific/Funafuti"),
        UTC("UTC"),
        ANTARCTICA_MACQUARIE("Antarctica/Macquarie"),
        CANADA_PACIFIC("Canada/Pacific"),
        AMERICA_MONCTON("America/Moncton"),
        AFRICA_GABORONE("Africa/Gaborone"),
        PACIFIC_CHUUK("Pacific/Chuuk"),
        ASIA_PYONGYANG("Asia/Pyongyang"),
        AMERICA_ST_VINCENT("America/St_Vincent"),
        ASIA_GAZA("Asia/Gaza"),
        ETC_UNIVERSAL("Etc/Universal"),
        PST8PDT("PST8PDT"),
        ATLANTIC_FAEROE("Atlantic/Faeroe"),
        ASIA_QYZYLORDA("Asia/Qyzylorda"),
        CANADA_NEWFOUNDLAND("Canada/Newfoundland"),
        AMERICA_KENTUCKY_LOUISVILLE("America/Kentucky/Louisville"),
        AMERICA_YAKUTAT("America/Yakutat"),
        ASIA_HO_CHI_MINH("Asia/Ho_Chi_Minh"),
        ANTARCTICA_CASEY("Antarctica/Casey"),
        EUROPE_COPENHAGEN("Europe/Copenhagen"),
        AFRICA_ASMARA("Africa/Asmara"),
        ATLANTIC_AZORES("Atlantic/Azores"),
        EUROPE_VIENNA("Europe/Vienna"),
        ROK("ROK"),
        PACIFIC_PITCAIRN("Pacific/Pitcairn"),
        AMERICA_MAZATLAN("America/Mazatlan"),
        AUSTRALIA_QUEENSLAND("Australia/Queensland"),
        PACIFIC_NAURU("Pacific/Nauru"),
        EUROPE_TIRANE("Europe/Tirane"),
        ASIA_KOLKATA("Asia/Kolkata"),
        SYSTEMV_MST7("SystemV/MST7"),
        AUSTRALIA_CANBERRA("Australia/Canberra"),
        MET("MET"),
        AUSTRALIA_BROKEN_HILL("Australia/Broken_Hill"),
        EUROPE_RIGA("Europe/Riga"),
        AMERICA_DOMINICA("America/Dominica"),
        AFRICA_ABIDJAN("Africa/Abidjan"),
        AMERICA_MENDOZA("America/Mendoza"),
        AMERICA_SANTAREM("America/Santarem"),
        KWAJALEIN("Kwajalein"),
        AMERICA_ASUNCION("America/Asuncion"),
        ASIA_ULAN_BATOR("Asia/Ulan_Bator"),
        NZ("NZ"),
        AMERICA_BOISE("America/Boise"),
        AUSTRALIA_CURRIE("Australia/Currie"),
        EST5EDT("EST5EDT"),
        PACIFIC_GUAM("Pacific/Guam"),
        PACIFIC_WAKE("Pacific/Wake"),
        ATLANTIC_BERMUDA("Atlantic/Bermuda"),
        AMERICA_COSTA_RICA("America/Costa_Rica"),
        AMERICA_DAWSON("America/Dawson"),
        ASIA_CHONGQING("Asia/Chongqing"),
        EIRE("Eire"),
        EUROPE_AMSTERDAM("Europe/Amsterdam"),
        AMERICA_INDIANA_KNOX("America/Indiana/Knox"),
        AMERICA_NORTH_DAKOTA_BEULAH("America/North_Dakota/Beulah"),
        AFRICA_ACCRA("Africa/Accra"),
        ATLANTIC_FAROE("Atlantic/Faroe"),
        MEXICO_BAJANORTE("Mexico/BajaNorte"),
        AMERICA_MACEIO("America/Maceio"),
        ETC_UCT("Etc/UCT"),
        PACIFIC_APIA("Pacific/Apia"),
        GMT0("GMT0"),
        AMERICA_ATKA("America/Atka"),
        PACIFIC_NIUE("Pacific/Niue"),
        CANADA_EAST_SASKATCHEWAN("Canada/East-Saskatchewan"),
        AUSTRALIA_LORD_HOWE("Australia/Lord_Howe"),
        EUROPE_DUBLIN("Europe/Dublin"),
        PACIFIC_TRUK("Pacific/Truk"),
        MST7MDT("MST7MDT"),
        AMERICA_MONTERREY("America/Monterrey"),
        AMERICA_NASSAU("America/Nassau"),
        AMERICA_JAMAICA("America/Jamaica"),
        ASIA_BISHKEK("Asia/Bishkek"),
        AMERICA_ATIKOKAN("America/Atikokan"),
        ATLANTIC_STANLEY("Atlantic/Stanley"),
        AUSTRALIA_NSW("Australia/NSW"),
        US_HAWAII("US/Hawaii"),
        SYSTEMV_CST6("SystemV/CST6"),
        INDIAN_MAHE("Indian/Mahe"),
        ASIA_AQTOBE("Asia/Aqtobe"),
        AMERICA_SITKA("America/Sitka"),
        ASIA_VLADIVOSTOK("Asia/Vladivostok"),
        AFRICA_LIBREVILLE("Africa/Libreville"),
        AFRICA_MAPUTO("Africa/Maputo"),
        ZULU("Zulu"),
        AMERICA_KENTUCKY_MONTICELLO("America/Kentucky/Monticello"),
        AFRICA_EL_AAIUN("Africa/El_Aaiun"),
        AFRICA_OUAGADOUGOU("Africa/Ouagadougou"),
        AMERICA_CORAL_HARBOUR("America/Coral_Harbour"),
        PACIFIC_MARQUESAS("Pacific/Marquesas"),
        BRAZIL_WEST("Brazil/West"),
        AMERICA_ARUBA("America/Aruba"),
        AMERICA_NORTH_DAKOTA_CENTER("America/North_Dakota/Center"),
        AMERICA_CAYMAN("America/Cayman"),
        ASIA_ULAANBAATAR("Asia/Ulaanbaatar"),
        ASIA_BAGHDAD("Asia/Baghdad"),
        EUROPE_SAN_MARINO("Europe/San_Marino"),
        AMERICA_INDIANA_TELL_CITY("America/Indiana/Tell_City"),
        AMERICA_TIJUANA("America/Tijuana"),
        PACIFIC_SAIPAN("Pacific/Saipan"),
        SYSTEMV_YST9("SystemV/YST9"),
        AFRICA_DOUALA("Africa/Douala"),
        AMERICA_CHIHUAHUA("America/Chihuahua"),
        AMERICA_OJINAGA("America/Ojinaga"),
        ASIA_HOVD("Asia/Hovd"),
        AMERICA_ANCHORAGE("America/Anchorage"),
        CHILE_EASTERISLAND("Chile/EasterIsland"),
        AMERICA_HALIFAX("America/Halifax"),
        ANTARCTICA_ROTHERA("Antarctica/Rothera"),
        AMERICA_INDIANA_INDIANAPOLIS("America/Indiana/Indianapolis"),
        US_MOUNTAIN("US/Mountain"),
        ASIA_DAMASCUS("Asia/Damascus"),
        AMERICA_ARGENTINA_SAN_LUIS("America/Argentina/San_Luis"),
        AMERICA_SANTIAGO("America/Santiago"),
        ASIA_BAKU("Asia/Baku"),
        AMERICA_ARGENTINA_USHUAIA("America/Argentina/Ushuaia"),
        ATLANTIC_REYKJAVIK("Atlantic/Reykjavik"),
        AFRICA_BRAZZAVILLE("Africa/Brazzaville"),
        AFRICA_PORTO_NOVO("Africa/Porto-Novo"),
        AMERICA_LA_PAZ("America/La_Paz"),
        ANTARCTICA_DUMONTDURVILLE("Antarctica/DumontDUrville"),
        ASIA_TAIPEI("Asia/Taipei"),
        ANTARCTICA_SOUTH_POLE("Antarctica/South_Pole"),
        ASIA_MANILA("Asia/Manila"),
        ASIA_BANGKOK("Asia/Bangkok"),
        AFRICA_DAR_ES_SALAAM("Africa/Dar_es_Salaam"),
        POLAND("Poland"),
        ATLANTIC_MADEIRA("Atlantic/Madeira"),
        ANTARCTICA_PALMER("Antarctica/Palmer"),
        AMERICA_THUNDER_BAY("America/Thunder_Bay"),
        AFRICA_ADDIS_ABABA("Africa/Addis_Ababa"),
        EUROPE_UZHGOROD("Europe/Uzhgorod"),
        BRAZIL_DENORONHA("Brazil/DeNoronha"),
        ASIA_ASHKHABAD("Asia/Ashkhabad"),
        ETC_ZULU("Etc/Zulu"),
        AMERICA_INDIANA_MARENGO("America/Indiana/Marengo"),
        AMERICA_CRESTON("America/Creston"),
        AMERICA_MEXICO_CITY("America/Mexico_City"),
        ANTARCTICA_VOSTOK("Antarctica/Vostok"),
        ASIA_JERUSALEM("Asia/Jerusalem"),
        EUROPE_ANDORRA("Europe/Andorra"),
        US_SAMOA("US/Samoa"),
        PRC("PRC"),
        ASIA_VIENTIANE("Asia/Vientiane"),
        PACIFIC_KIRITIMATI("Pacific/Kiritimati"),
        AMERICA_MATAMOROS("America/Matamoros"),
        AMERICA_BLANC_SABLON("America/Blanc-Sablon"),
        ASIA_RIYADH("Asia/Riyadh"),
        ICELAND("Iceland"),
        PACIFIC_POHNPEI("Pacific/Pohnpei"),
        ASIA_UJUNG_PANDANG("Asia/Ujung_Pandang"),
        ATLANTIC_SOUTH_GEORGIA("Atlantic/South_Georgia"),
        EUROPE_LISBON("Europe/Lisbon"),
        ASIA_HARBIN("Asia/Harbin"),
        EUROPE_OSLO("Europe/Oslo"),
        ASIA_NOVOKUZNETSK("Asia/Novokuznetsk"),
        CST6CDT("CST6CDT"),
        ATLANTIC_CANARY("Atlantic/Canary"),
        AMERICA_KNOX_IN("America/Knox_IN"),
        ASIA_KUWAIT("Asia/Kuwait"),
        SYSTEMV_HST10("SystemV/HST10"),
        PACIFIC_EFATE("Pacific/Efate"),
        AFRICA_LOME("Africa/Lome"),
        AMERICA_BOGOTA("America/Bogota"),
        AMERICA_MENOMINEE("America/Menominee"),
        AMERICA_ADAK("America/Adak"),
        PACIFIC_NORFOLK("Pacific/Norfolk"),
        EUROPE_KIROV("Europe/Kirov"),
        AMERICA_RESOLUTE("America/Resolute"),
        PACIFIC_TARAWA("Pacific/Tarawa"),
        AFRICA_KAMPALA("Africa/Kampala"),
        ASIA_KRASNOYARSK("Asia/Krasnoyarsk"),
        GREENWICH("Greenwich"),
        SYSTEMV_EST5("SystemV/EST5"),
        AMERICA_EDMONTON("America/Edmonton"),
        EUROPE_PODGORICA("Europe/Podgorica"),
        AUSTRALIA_SOUTH("Australia/South"),
        CANADA_CENTRAL("Canada/Central"),
        AFRICA_BUJUMBURA("Africa/Bujumbura"),
        AMERICA_SANTO_DOMINGO("America/Santo_Domingo"),
        US_EASTERN("US/Eastern"),
        EUROPE_MINSK("Europe/Minsk"),
        PACIFIC_AUCKLAND("Pacific/Auckland"),
        AFRICA_CASABLANCA("Africa/Casablanca"),
        AMERICA_GLACE_BAY("America/Glace_Bay"),
        CANADA_EASTERN("Canada/Eastern"),
        ASIA_QATAR("Asia/Qatar"),
        EUROPE_KIEV("Europe/Kiev"),
        SINGAPORE("Singapore"),
        ASIA_MAGADAN("Asia/Magadan"),
        SYSTEMV_PST8("SystemV/PST8"),
        AMERICA_PORT_AU_PRINCE("America/Port-au-Prince"),
        EUROPE_BELFAST("Europe/Belfast"),
        AMERICA_ST_BARTHELEMY("America/St_Barthelemy"),
        ASIA_ASHGABAT("Asia/Ashgabat"),
        AFRICA_LUANDA("Africa/Luanda"),
        AMERICA_NIPIGON("America/Nipigon"),
        ATLANTIC_JAN_MAYEN("Atlantic/Jan_Mayen"),
        BRAZIL_ACRE("Brazil/Acre"),
        ASIA_MUSCAT("Asia/Muscat"),
        ASIA_BAHRAIN("Asia/Bahrain"),
        EUROPE_VILNIUS("Europe/Vilnius"),
        AMERICA_FORTALEZA("America/Fortaleza"),
        ETC_GMT0("Etc/GMT0"),
        US_EAST_INDIANA("US/East-Indiana"),
        AMERICA_HERMOSILLO("America/Hermosillo"),
        AMERICA_CANCUN("America/Cancun"),
        AFRICA_MASERU("Africa/Maseru"),
        PACIFIC_KOSRAE("Pacific/Kosrae"),
        AFRICA_KINSHASA("Africa/Kinshasa"),
        ASIA_KATHMANDU("Asia/Kathmandu"),
        ASIA_SEOUL("Asia/Seoul"),
        AUSTRALIA_SYDNEY("Australia/Sydney"),
        AMERICA_LIMA("America/Lima"),
        AUSTRALIA_LHI("Australia/LHI"),
        AMERICA_ST_LUCIA("America/St_Lucia"),
        EUROPE_MADRID("Europe/Madrid"),
        AMERICA_BAHIA_BANDERAS("America/Bahia_Banderas"),
        AMERICA_MONTSERRAT("America/Montserrat"),
        ASIA_BRUNEI("Asia/Brunei"),
        AMERICA_SANTA_ISABEL("America/Santa_Isabel"),
        CANADA_MOUNTAIN("Canada/Mountain"),
        AMERICA_CAMBRIDGE_BAY("America/Cambridge_Bay"),
        ASIA_COLOMBO("Asia/Colombo"),
        AUSTRALIA_WEST("Australia/West"),
        INDIAN_ANTANANARIVO("Indian/Antananarivo"),
        AUSTRALIA_BRISBANE("Australia/Brisbane"),
        INDIAN_MAYOTTE("Indian/Mayotte"),
        US_INDIANA_STARKE("US/Indiana-Starke"),
        ASIA_URUMQI("Asia/Urumqi"),
        US_ALEUTIAN("US/Aleutian"),
        EUROPE_VOLGOGRAD("Europe/Volgograd"),
        AMERICA_LOWER_PRINCES("America/Lower_Princes"),
        AMERICA_VANCOUVER("America/Vancouver"),
        AFRICA_BLANTYRE("Africa/Blantyre"),
        AMERICA_RIO_BRANCO("America/Rio_Branco"),
        AMERICA_DANMARKSHAVN("America/Danmarkshavn"),
        AMERICA_DETROIT("America/Detroit"),
        AMERICA_THULE("America/Thule"),
        AFRICA_LUSAKA("Africa/Lusaka"),
        ASIA_HONG_KONG("Asia/Hong_Kong"),
        IRAN("Iran"),
        AMERICA_ARGENTINA_LA_RIOJA("America/Argentina/La_Rioja"),
        AFRICA_DAKAR("Africa/Dakar"),
        SYSTEMV_CST6CDT("SystemV/CST6CDT"),
        AMERICA_TORTOLA("America/Tortola"),
        AMERICA_PORTO_VELHO("America/Porto_Velho"),
        ASIA_SAKHALIN("Asia/Sakhalin"),
        ETC_GMT_10("Etc/GMT+10"),
        AMERICA_SCORESBYSUND("America/Scoresbysund"),
        ASIA_KAMCHATKA("Asia/Kamchatka"),
        ASIA_THIMBU("Asia/Thimbu"),
        AFRICA_HARARE("Africa/Harare"),
        ETC_GMT_12("Etc/GMT+12"),
        ETC_GMT_11("Etc/GMT+11"),
        NAVAJO("Navajo"),
        AMERICA_NOME("America/Nome"),
        EUROPE_TALLINN("Europe/Tallinn"),
        TURKEY("Turkey"),
        AFRICA_KHARTOUM("Africa/Khartoum"),
        AFRICA_JOHANNESBURG("Africa/Johannesburg"),
        AFRICA_BANGUI("Africa/Bangui"),
        EUROPE_BELGRADE("Europe/Belgrade"),
        JAMAICA("Jamaica"),
        AFRICA_BISSAU("Africa/Bissau"),
        ASIA_TEHRAN("Asia/Tehran"),
        WET("WET"),
        EUROPE_ASTRAKHAN("Europe/Astrakhan"),
        AFRICA_JUBA("Africa/Juba"),
        AMERICA_CAMPO_GRANDE("America/Campo_Grande"),
        AMERICA_BELEM("America/Belem"),
        ETC_GREENWICH("Etc/Greenwich"),
        ASIA_SAIGON("Asia/Saigon"),
        AMERICA_ENSENADA("America/Ensenada"),
        PACIFIC_MIDWAY("Pacific/Midway"),
        AMERICA_JUJUY("America/Jujuy"),
        AFRICA_TIMBUKTU("Africa/Timbuktu"),
        AMERICA_BAHIA("America/Bahia"),
        AMERICA_GOOSE_BAY("America/Goose_Bay"),
        AMERICA_VIRGIN("America/Virgin"),
        AMERICA_PANGNIRTUNG("America/Pangnirtung"),
        ASIA_KATMANDU("Asia/Katmandu"),
        AMERICA_PHOENIX("America/Phoenix"),
        AFRICA_NIAMEY("Africa/Niamey"),
        AMERICA_WHITEHORSE("America/Whitehorse"),
        PACIFIC_NOUMEA("Pacific/Noumea"),
        ASIA_TBILISI("Asia/Tbilisi"),
        AMERICA_MONTREAL("America/Montreal"),
        ASIA_MAKASSAR("Asia/Makassar"),
        AMERICA_ARGENTINA_SAN_JUAN("America/Argentina/San_Juan"),
        HONGKONG("Hongkong"),
        UCT("UCT"),
        ASIA_NICOSIA("Asia/Nicosia"),
        AMERICA_INDIANA_WINAMAC("America/Indiana/Winamac"),
        SYSTEMV_MST7MDT("SystemV/MST7MDT"),
        AMERICA_ARGENTINA_COMODRIVADAVIA("America/Argentina/ComodRivadavia"),
        AMERICA_BOA_VISTA("America/Boa_Vista"),
        AMERICA_GRENADA("America/Grenada"),
        AUSTRALIA_DARWIN("Australia/Darwin"),
        ASIA_KHANDYGA("Asia/Khandyga"),
        ASIA_KUALA_LUMPUR("Asia/Kuala_Lumpur"),
        ASIA_THIMPHU("Asia/Thimphu"),
        ASIA_RANGOON("Asia/Rangoon"),
        EUROPE_BRATISLAVA("Europe/Bratislava"),
        ASIA_CALCUTTA("Asia/Calcutta"),
        AMERICA_ARGENTINA_TUCUMAN("America/Argentina/Tucuman"),
        ASIA_KABUL("Asia/Kabul"),
        INDIAN_COCOS("Indian/Cocos"),
        JAPAN("Japan"),
        PACIFIC_TONGATAPU("Pacific/Tongatapu"),
        AMERICA_NEW_YORK("America/New_York"),
        ETC_GMT_12_M("Etc/GMT-12"),
        ETC_GMT_11_M("Etc/GMT-11"),
        ETC_GMT_10_M("Etc/GMT-10"),
        SYSTEMV_YST9YDT("SystemV/YST9YDT"),
        EUROPE_ULYANOVSK("Europe/Ulyanovsk"),
        ETC_GMT_14("Etc/GMT-14"),
        ETC_GMT_13("Etc/GMT-13"),
        W_SU("W-SU"),
        AMERICA_MERIDA("America/Merida"),
        EET("EET"),
        AMERICA_ROSARIO("America/Rosario"),
        CANADA_SASKATCHEWAN("Canada/Saskatchewan"),
        AMERICA_ST_KITTS("America/St_Kitts"),
        ARCTIC_LONGYEARBYEN("Arctic/Longyearbyen"),
        AMERICA_FORT_NELSON("America/Fort_Nelson"),
        AMERICA_CARACAS("America/Caracas"),
        AMERICA_GUADELOUPE("America/Guadeloupe"),
        ASIA_HEBRON("Asia/Hebron"),
        INDIAN_KERGUELEN("Indian/Kerguelen"),
        SYSTEMV_PST8PDT("SystemV/PST8PDT"),
        AFRICA_MONROVIA("Africa/Monrovia"),
        ASIA_UST_NERA("Asia/Ust-Nera"),
        EGYPT("Egypt"),
        ASIA_SREDNEKOLYMSK("Asia/Srednekolymsk"),
        AMERICA_NORTH_DAKOTA_NEW_SALEM("America/North_Dakota/New_Salem"),
        ASIA_ANADYR("Asia/Anadyr"),
        AUSTRALIA_MELBOURNE("Australia/Melbourne"),
        ASIA_IRKUTSK("Asia/Irkutsk"),
        AMERICA_SHIPROCK("America/Shiprock"),
        AMERICA_WINNIPEG("America/Winnipeg"),
        EUROPE_VATICAN("Europe/Vatican"),
        ASIA_AMMAN("Asia/Amman"),
        ETC_UTC("Etc/UTC"),
        SYSTEMV_AST4ADT("SystemV/AST4ADT"),
        ASIA_TOKYO("Asia/Tokyo"),
        AMERICA_TORONTO("America/Toronto"),
        ASIA_SINGAPORE("Asia/Singapore"),
        AUSTRALIA_LINDEMAN("Australia/Lindeman"),
        AMERICA_LOS_ANGELES("America/Los_Angeles"),
        SYSTEMV_EST5EDT("SystemV/EST5EDT"),
        PACIFIC_MAJURO("Pacific/Majuro"),
        AMERICA_ARGENTINA_BUENOS_AIRES("America/Argentina/Buenos_Aires"),
        EUROPE_NICOSIA("Europe/Nicosia"),
        PACIFIC_GUADALCANAL("Pacific/Guadalcanal"),
        EUROPE_ATHENS("Europe/Athens"),
        US_PACIFIC("US/Pacific"),
        EUROPE_MONACO("Europe/Monaco");

        ZoneIdEnum(String zoneId) {
            this.zoneId = zoneId;
        }

        String zoneId;

    }
}