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
用来打印和格式化日期时间对象,并且提供了一些常见实现类:
-
使用预定义的常量,如 ISO_LOCAL_DATE
-
使用字符串样式,如 uuuu-MMM-dd
-
使用本地化风格,如 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 |
---|
FULL Full 全文样式,最详细。 |
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 | MAX The maximum supported LocalTime , '23:59:59.999999999'. |
static LocalTime | MIDNIGHT The time of midnight at the start of the day, '00:00'. |
static LocalTime | MIN The minimum supported LocalTime , '00:00'. |
static LocalTime | NOON The 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_IDS A 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 | MAX Constant for the maximum supported offset. |
static ZoneOffset | MIN Constant for the maximum supported offset. |
static ZoneOffset | UTC The 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;
}
}