java8新增的日期，时间包以及格式器

java8新增的日期，时间包

java8专门新增了一个java.time包，该包中包含了以下常见的类。

Clock

该类用于获取指定时区的当前日期，时间。该类可取代System类的currentTimeMills()方法，而且提供了更多的方法来获取当前时间，日期。

Clock类的方法

boolean equals(Object obj)
检查这个时钟是否等于另一个时钟。
int hashCode()
这个时钟的哈希码。
abstract Instant instant()
获取当前的时钟瞬间。
long millis()
获取时钟的当前毫秒时间。
static Clock offset(Clock baseClock, Duration offsetDuration)
获取一个时钟，从指定的时钟周期返回时钟，并添加指定的时间
static Clock system(ZoneId zone)
获取使用最佳可用系统时钟返回当前时刻的时钟。
static Clock systemDefaultZone()
获取使用最佳可用系统时钟返回当前即时的时钟，使用默认时区转换为日期和时间。
static Clock systemUTC()
获取使用最佳可用系统时钟返回当前即时的时钟，使用UTC时区转换为日期和时间。
static Clock tick(Clock baseClock, Duration tickDuration)
获取时钟，将时钟从指定的时钟截断返回到指定持续时间的最近出现。
static Clock tickMinutes(ZoneId zone)
获取时钟，使用最佳可用系统时钟在一分钟内返回当前瞬间滴答作响。
static Clock tickSeconds(ZoneId zone)
获取时钟，使用最佳可用系统时钟在一秒钟内返回当前瞬间滴答。

Duration

该类代表持续时间。

Duration类的方法

int compareTo(Duration otherDuration)
将此持续时间与指定的Duration进行 Duration 。
boolean equals(Object otherDuration)
检查此持续时间是否等于指定的 Duration 。
int getNano()
在此持续时间内获得第二秒内的纳秒数。
long getSeconds()
获取此持续时间内的秒数。
这个持续时间的哈希码。
boolean isNegative()
检查此持续时间是否为负，不包括零。
boolean isZero()
检查此持续时间是否为零长度。
Duration minusMillis(long millisToSubtract)
以指定的持续时间返回此持续时间的副本，以毫秒为单位。
Duration minusMinutes(long minutesToSubtract)
以指定的持续时间返回此持续时间的副本，以分钟为单位。
Duration minusNanos(long nanosToSubtract)
以指定的持续时间返回此持续时间的副本，减去纳秒。
Duration minusSeconds(long secondsToSubtract)
以指定的持续时间返回此持续时间的副本，以秒为单位。
static Duration ofDays(long days)
获得一个 Duration代表一些标准的24小时的日子。
static Duration ofHours(long hours)
获得 Duration多个标准时数的Duration。
static Duration ofMillis(long millis)
获得代表一个 Duration数的Duration。
static Duration ofMinutes(long minutes)
获得 Duration多个标准分钟的Duration。
static Duration ofNanos(long nanos)
获得 Duration数纳秒的Duration。
static Duration ofSeconds(long seconds)
获得代表 Duration Duration。
static Duration ofSeconds(long seconds, long nanoAdjustment)
获得一个 Duration代表秒数和一个纳秒的调整。
static Duration parse(CharSequence text)
从一个文本字符串获得一个 Duration ，如 PnDTnHnMn.nS 。
Duration plus(Duration duration)
返回此持续时间的副本，并添加指定的持续时间。
Duration plus(long amountToAdd, TemporalUnit unit)
返回此持续时间的副本，并添加指定的持续时间。
Duration plusDays(long daysToAdd)
在标准的24小时内添加指定的持续时间返回此持续时间的副本。
Duration plusHours(long hoursToAdd)
以指定的持续时间返回此持续时间的副本，小时数。
Duration plusMillis(long millisToAdd)
以指定的持续时间（以毫秒为单位）返回此持续时间的副本。
Duration plusMinutes(long minutesToAdd)
以指定的持续时间（以分钟为单位）返回此持续时间的副本。
Duration plusNanos(long nanosToAdd)
以指定的持续时间返回此持续时间的副本，以纳秒为单位。
Duration plusSeconds(long secondsToAdd)
以指定的持续时间（以秒为单位）返回此持续时间的副本。
long toDays()
获取此持续时间的天数。
long toHours()
获取此持续时间内的小时数。
long toMillis()
将此持续时间转换为总长度（以毫秒为单位）。
long toMinutes()
获取此持续时间的分钟数。
long toNanos()
将此持续时间转换为总长度，单位为纳秒，表示为 long 。
String toString()
使用ISO-8601秒表示形式的字符串表示形式，如 PT8H6M12.345S 。
Duration withNanos(int nanoOfSecond)
以指定的纳秒为单位返回此持续时间的副本。
Duration withSeconds(long seconds)
以指定的秒数返回此持续时间的副本

Instant

代表一个具体的时刻，可以精确到纳秒。该类提供了一个静态的now()来获取当前的时刻，也提供了静态的now(Clock clock)来获取clock对应的时刻。

Instant类的方法

OffsetDateTime atOffset(ZoneOffset offset)
将此瞬间与偏移组合起来创建一个 OffsetDateTime 。
int compareTo(Instant otherInstant)
将此瞬间与指定的时刻进行比较。
boolean equals(Object otherInstant)
检查这个瞬间是否等于指定的时刻。
long getLong(TemporalField field)
从该时刻获取指定字段的值为 long 。
int getNano()
从第二个开始就从时间线获得纳秒的数量。
int hashCode()
返回此时刻的哈希码。
boolean isAfter(Instant otherInstant)
检查这个瞬间是否在指定的时刻之后。
boolean isBefore(Instant otherInstant)
检查这个时刻是否在指定的时刻之前。
boolean isSupported(TemporalField field)
检查指定的字段是否受支持。
boolean isSupported(TemporalUnit unit)
检查指定的单位是否受支持。
static Instant now()
从系统时钟获取当前瞬间。
static Instant now(Clock clock)
从指定的时钟获取当前时刻。
static Instant parse(CharSequence text)
从一个文本字符串（如 2007-12-03T10:15:30.00Z获取一个 Instant的实例。
Instant plus(long amountToAdd, TemporalUnit unit)
返回添加指定数量的此瞬间的副本。
Instant plus(TemporalAmount amountToAdd)
返回添加指定数量的此瞬间的副本。
Instant plusMillis(long millisToAdd)
以毫秒为单位的指定持续时间返回此瞬间的副本。
Instant plusNanos(long nanosToAdd)
以指定的持续时间返回此瞬间的副本，以纳秒为单位。
Instant plusSeconds(long secondsToAdd)
以指定的持续时间返回此瞬间的副本，以秒为单位。
Instant with(TemporalAdjuster adjuster)
返回此瞬间的调整副本。
Instant with(TemporalField field, long newValue)
将指定的字段设置为新值返回此瞬间的副本。

LocalDate

LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日。 也可以访问其他日期字段，例如日期，星期几和星期。 例如，值“2007年10月2日”可存储在LocalDate 。

该类不存储或表示时间或时区。 相反，它是日期的描述，用于生日。 它不能代表时间线上的即时信息，而没有附加信息，如偏移或时区。

LocalDate类的方法

int compareTo(ChronoLocalDate other)
将此日期与另一个日期进行比较。
boolean equals(Object obj)
检查这个日期是否等于另一个日期。
String format(DateTimeFormatter formatter)
使用指定的格式化程序格式化此日期。
int get(TemporalField field)
从此日期获取指定字段的 int 。
int getDayOfMonth()
获取月份字段。
DayOfWeek getDayOfWeek()
获取星期几字段，这是一个枚举 DayOfWeek 。
int getDayOfYear()
获得日期字段。
Era getEra()
获得这个时代适用的时代。
long getLong(TemporalField field)
从此日期获取指定字段的值为 long 。
Month getMonth()
使用 Month枚举获取月份字段。
int getMonthValue()
将月份字段从1到12。
int getYear()
获取年份字段。
int hashCode()
这个日期的哈希码。
boolean isAfter(ChronoLocalDate other)
检查此日期是否在指定日期之后。
boolean isBefore(ChronoLocalDate other)
检查此日期是否在指定日期之前。
boolean isEqual(ChronoLocalDate other)
检查此日期是否等于指定的日期。
boolean isLeapYear()
根据ISO培训日历系统规则，检查年份是否是闰年。
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 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的实例。
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的副本，其中指定的时间段以添加的年数表示。
String toString()
将此日期输出为 String ，如 2007-12-03 。
LocalDate with(TemporalAdjuster adjuster)
返回此日期的调整副本。
LocalDate with(TemporalField field, long newValue)
返回此日期的副本，并将指定的字段设置为新值。
LocalDate withDayOfMonth(int dayOfMonth)
返回此日期的副本，并更改日期。
LocalDate withDayOfYear(int dayOfYear)
返回此日期的副本，并更改日期。
LocalDate withMonth(int month)
返回这个日期的副本，并更改年月日。
LocalDate withYear(int year)
返回此日期的副本，并更改年份。

LocalTime

LocalTime是一个不可变的日期时间对象，代表一个时间，通常被看作是小时 - 秒。 时间表示为纳秒精度。 例如，值“13：45.30.123456789”可以存储在LocalTime 。

它不存储或表示日期或时区。 相反，它是在挂钟上看到的当地时间的描述。 它不能代表时间线上的即时信息，而没有附加信息，如偏移或时区。

LocalTime类的方法

int compareTo(LocalTime other)
比较这个 LocalTime到另一个时间。
boolean equals(Object obj)
检查这次是否等于另一次。
String format(DateTimeFormatter formatter)
此时使用指定的格式化程序格式化。
int getHour()
获取时间字段。
long getLong(TemporalField field)
从此时间获取指定字段的值为 long 。
int getMinute()
获取小时字段。
boolean isAfter(LocalTime other)
检查 LocalTime是否在指定的时间之后。
boolean isBefore(LocalTime other)
检查这个 LocalTime是否在指定的时间之前。
boolean isSupported(TemporalField field)
检查指定的字段是否受支持。
boolean isSupported(TemporalUnit unit)
检查指定的单位是否受支持。
LocalTime minusHours(long hoursToSubtract)
以指定的时间段返回此 LocalTime的副本， LocalTime数字。
LocalTime minusMinutes(long minutesToSubtract)
返回此 LocalTime的副本，其中指定的时间间隔以分钟为单位。
LocalTime minusNanos(long nanosToSubtract)
以指定的时间段返回此 LocalTime的副本，以纳秒为单位。
LocalTime minusSeconds(long secondsToSubtract)
返回此 LocalTime的副本，其中指定的时间间隔以秒为单位。
static LocalTime now()
从默认时区的系统时钟获取当前时间。
static LocalTime now(Clock clock)
从指定的时钟获取当前时间。
static LocalTime of(int hour, int minute)
从一小时分钟获取一个 LocalTime的实例。
static LocalTime of(int hour, int minute, int second)
从一小时，一分钟和秒钟获得一个 LocalTime的实例。
static LocalTime of(int hour, int minute, int second, int nanoOfSecond)
从一小时，分钟，秒和纳秒获取 LocalTime一个实例。
static LocalTime ofNanoOfDay(long nanoOfDay)
从 LocalTime值获取 LocalTime的实例。
static LocalTime ofSecondOfDay(long secondOfDay)
从第二天的值获取一个 LocalTime的实例。
static LocalTime parse(CharSequence text)
从一个文本字符串（如 10:15获取一个 LocalTime的实例。
static LocalTime parse(CharSequence text, DateTimeFormatter formatter)
使用特定的格式化 LocalTime从文本字符串获取 LocalTime的实例。
LocalTime plusHours(long hoursToAdd)
以指定的时间（以小时为单位）返回此 LocalTime的副本。
LocalTime plusMinutes(long minutesToAdd)
以指定的时间（以分钟为单位）返回此 LocalTime的副本。
LocalTime plusNanos(long nanosToAdd)
返回这个 LocalTime的副本，指定的时间段以纳秒为单位。
LocalTime plusSeconds(long secondstoAdd)
以指定的时间段（以秒为单位）返回此 LocalTime的副本。
long toNanoOfDay()
提取时间为天数，从 0到 24 * 60 * 60 * 1,000,000,000 - 1 。
int toSecondOfDay()
提取时间为一天的时间，从 0到 24 * 60 * 60 - 1 。
String toString()
此时输出为 String ，如 10:15 。
LocalTime withHour(int hour)
返回此日期值更改的 LocalTime的副本。
LocalTime withMinute(int minute)
返回这个 LocalTime的副本，小时值更改。
LocalTime withNano(int nanoOfSecond)
返回这个 LocalTime的副本，纳秒变化值。
LocalTime withSecond(int second)
返回这个 LocalTime的副本，其中二分之一值更改

LocalDateTime

LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒。 也可以访问其他日期和时间字段，例如日期，星期几和星期。 时间表示为纳秒精度。 例如，值“2007年10月2日在13：45.30.123456789”可以存储在LocalDateTime 。
该类不存储或表示时区。 相反，它是对日子的描述，如用于生日，结合当地时间在挂钟上看到的。 它不能代表时间线上的即时信息，而没有附加信息，如偏移或时区。

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的实例。
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 query(TemporalQuery query)
使用指定的查询查询此日期时间。
ValueRange range(TemporalField field)
获取指定字段的有效值的范围。
LocalDate toLocalDate()
获得这个日期时间的 LocalDate一部分。
LocalTime toLocalTime()
获得这个日期时间的 LocalTime一部分。
String toString()
将此日期时间输出为 String ，例如 2007-12-03T10:15:30 。
LocalDateTime truncatedTo(TemporalUnit unit)
返回此 LocalDateTime的副本， LocalDateTime时间。
long until(Temporal endExclusive, TemporalUnit unit)
根据指定的单位计算到另一个日期时间的时间量。
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的副本，纳秒变化值。
LocalDateTime withSecond(int second)
返回这个 LocalDateTime的副本，其中 LocalDateTime了第二分钟的值。
LocalDateTime withYear(int year)
返回这个 LocalDateTime的副本，年份被更改。

MonthDay，Year，YearMonth

MonthDay类仅代表月日，Year仅代表年，YearMonth类仅代表年月。

ZonedDateTime

该类代表一个时区化的日期，时间。

ZoneId

该类代表一个时区

DayOfWeek

这是一个枚举类，定义了周日到周六的枚举值

Month

这也是一个枚举类，定义了一月到十二月的枚举值。
下面通过一个简单的程序来示范这些类的用法

package Base4;

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.MonthDay;
import java.time.Year;
import java.time.YearMonth;

public class NewDatePackageTest {
    public static void main(String[] args){
        //获取当前Clock
        Clock clock = Clock.systemUTC();
        //通过Clock获取当前时间
        System.out.println("当前时刻为："+clock.instant());
        //获取clock对应毫秒数，与System.currentTimeMills()输出相同
        System.out.println(clock.millis());
        System.out.println(System.currentTimeMillis());
        /*
         * Duration的用法
         */
        Duration d = Duration.ofSeconds(6000);
        System.out.println("6000秒相当于"+d.toMinutes()+"分");
        System.out.println("600秒相当于"+d.toHours()+"小时");
        System.out.println("6000秒相当于"+d.toDays()+"天");
        //在clock基础上增加6000秒。返回新得Clock
        Clock clock2 = Clock.offset(clock,d);
        //可以看到clock2与Clock相差1小时40分
        System.out.println("当前时间加6000秒为："+clock2.instant());
        /*
         * Instant的用法
         */
        //获取当前时间
        Instant instant = Instant.now();
        System.out.println(instant);
        //instant添加6000秒（即100分钟），返回新的Instant
        Instant instant2 = instant.plusSeconds(6000);
        System.out.println(instant2);
        //根据字符串解析Instant对象
        Instant instant3 = Instant.parse("2014-02-23T10:12:35.342Z");
                System.out.println(instant3);
        //在instant3的基础上添加5小时4分钟
        Instant instant4 = instant3.plus(Duration.ofHours(5).plusMinutes(4));
        System.out.println(instant4);
        //获取instant4的5天以前的时刻
        Instant instant5 = instant4.minus(Duration.ofDays(5));
        System.out.println(instant5);
        /*
         * LocalDate的用法
         */
        LocalDate localdate = LocalDate.now();
        System.out.println(localdate);
        //获取2014年的第146天
        localdate = LocalDate.ofYearDay(2017, 146);
        System.out.println(localdate);
        //设置2017年5月21日
        localdate = LocalDate.of(2017, 05, 21);
        System.out.println(localdate);
        /*
         * LocalTime的用法
         */
        //获取当前时间
        LocalTime localtime = LocalTime.now();
        //设置为22点33分
        localtime = LocalTime.of(22, 33);
        System.out.println(localtime);
        //返回一天中的第5503秒
        localtime = LocalTime.ofSecondOfDay(5503);
        System.out.println(localtime);
        /*
         * localDateTime的用法
         */
        //获取当前时间，日期
        LocalDateTime localdatetime = LocalDateTime.now();
        //当前日期时间加上25小时3分钟
        LocalDateTime future = localdatetime.plusHours(25).plusMinutes(3);
        System.out.println("当前日期，时间的25小时3分钟后："+future);
        /*
         * Year,YearMonth,MonthDay的用法
         */
        //获取当前年份
        Year year = Year.now();
        //输出当前年份
        System.out.println("当前年份："+year);
        //当前年份在加5年
        year = year.plusYears(5);
        System.out.println("当前年份在加5年："+year);
        //根据指定月份获取YearMonth
        YearMonth ym = year.atMonth(10);
        System.out.println(year+"年10月"+ym);
        //当前年月再加5年，减3个月
        ym = ym.plusYears(5).minusMonths(3);
        System.out.println(year+"年再加5年，减3个月:"+ym);
        //获取当前月日
        MonthDay md = MonthDay.now();
        System.out.println("当前月日"+md);
        //设置为5月23日
        MonthDay md2 = md.with(Month.MAY).withDayOfMonth(23);
        System.out.println("5月23日为："+md2);

;   }
}