新的时间及日期API位于 java.time 包中，下面是一些关键类。

Instant：代表的是时间戳。

LocalDate：不包含具体时间的日期。

LocalTime：不含日期的时间。

LocalDateTime：包含了日期及时间。

一、获取时间

（1）Instant（时间戳类）

JDK8获取时间戳特别简单。Instant类由一个静态的工厂方法now()可以返回当前时间戳。
Instant instant = Instant.now();
System.out.println("当前时间戳是：" + instant);//当前时间戳是：2018-09-06T10:14:29.460Z
Date date = Date.from(instant);
System.out.println("当前时间戳是：" + date);//当前时间戳是：Thu Sep 06 18:14:29 CST 2018
instant = date.toInstant();

可以看到，当前时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是JDK8以前的Date，可以使用这两个类中的方法在这两个类型之间进行转换。

（2）LocalDate

LocalDate类获取日期信息。格式为 2018-09-06
LocalDate nowDate = LocalDate.now();
System.out.println("今天的日期：" + nowDate);//今天的日期：2018-09-06
int year = nowDate.getYear();//年：一般用这个方法获取年
System.out.println("year：" + year);//year：2018
int month = nowDate.getMonthValue();//月：一般用这个方法获取月
System.out.println("month：" + month);//month：9
int day = nowDate.getDayOfMonth();//日：当月的第几天，一般用这个方法获取日
System.out.println("day：" + day);//day：6        
int dayOfYear = nowDate.getDayOfYear();//日：当年的第几天 System.out.println("dayOfYear：" + dayOfYear);//dayOfYear：249
     //星期
System.out.println(nowDate.getDayOfWeek());//THURSDAY
System.out.println(nowDate.getDayOfWeek().getValue());//4
    //月份
System.out.println(nowDate.getMonth());//SEPTEMBER
System.out.println(nowDate.getMonth().getValue());//9

（3）LocalTime

LocalTime类获取时间信息。格式为 15:33:56.749
LocalTime nowTime = LocalTime.now();
System.out.println("今天的时间：" + nowTime);//今天的时间：15:33:56.749
int hour = nowTime.getHour();//时
System.out.println("hour：" + hour);//hour：15
int minute = nowTime.getMinute();//分
System.out.println("minute：" + minute);//minute：33
int second = nowTime.getSecond();//秒
System.out.println("second：" + second);//second：56
int nano = nowTime.getNano();//纳秒
System.out.println("nano：" + nano);//nano：749000000

（4）LocalDateTime

LocalDateTime类获取日期时间信息。格式为 2018-09-06T15:33:56.750
LocalDateTime nowDateTime = LocalDateTime.now();
System.out.println("今天是：" + nowDateTime);//今天是：2018-09-06T15:33:56.750
System.out.println(nowDateTime.getYear());//年
System.out.println(nowDateTime.getMonthValue());//月
System.out.println(nowDateTime.getDayOfMonth());//日
System.out.println(nowDateTime.getHour());//时
System.out.println(nowDateTime.getMinute());//分
System.out.println(nowDateTime.getSecond());//秒
System.out.println(nowDateTime.getNano());//纳秒		       		    //日：当年的第几天
System.out.println("dayOfYear："nowDateTime.getDayOfYear());//dayOfYear：249
     //星期
System.out.println(nowDateTime.getDayOfWeek());//THURSDAY
System.out.println(nowDateTime.getDayOfWeek().getValue());//4
	//月份
System.out.println(nowDateTime.getMonth());//SEPTEMBER
System.out.println(nowDateTime.getMonth().getValue());//9

二、获取指定时间

（1）LocalDate
System.out.println(LocalDate.of(1991, 11, 11));//直接传入对应的年月日
System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11));//相对上面只是把月换成了枚举
LocalDate birDay = LocalDate.of(1991, 11, 11);
System.out.println(LocalDate.ofYearDay(1991, birDay.getDayOfYear()));//第一个参数为年，第二个参数为当年的第多少天
System.out.println(LocalDate.ofEpochDay(birDay.toEpochDay()));//参数为距离1970-01-01的天数
System.out.println(LocalDate.parse("1991-11-11"));
System.out.println(LocalDate.parse("19911111",DateTimeFormatter.ofPattern("yyyyMMdd")));

（2）LocalTime
System.out.println(LocalTime.of(8, 20));//时分
System.out.println(LocalTime.of(8, 20, 30));//时分秒
System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒
LocalTime mTime = LocalTime.of(8, 20, 30, 150);
System.out.println(LocalTime.ofSecondOfDay(mTime.toSecondOfDay()));//参数为距离当天零时的秒数
System.out.println(LocalTime.ofNanoOfDay(mTime.toNanoOfDay()));//参数为距离当天零时的纳秒数
System.out.println(LocalTime.parse("08:20:30"));
System.out.println(LocalTime.parse("082030", DateTimeFormatter.ofPattern("HHmmss")));

（3）LocalDateTime

这里的 birDay 和 mTime 复用上面的变量。
System.out.println(LocalDateTime.of(birDay, mTime));//参数为LocalDate和LocalTime
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20));
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30));
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150));
System.out.println(LocalDateTime.parse("1991-11-11T08:20:30"));
System.out.println(LocalDateTime.parse("1991-11-11 08:20:30", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

Instant——它代表的是时间戳
LocalDate——不包含具体时间的日期，比如 2020-01-14。它可以用来存储生日，周年纪念日，入职日期等。
LocalTime——它代表的是不含日期的时间
LocalDateTime——它包含了日期及时间，不过还是没有偏移信息或者说时区。
ZonedDateTime——这是一个包含时区的完整的日期时间，偏移量是以 UTC / 格林威治时间为基准的。

Java 8 是如何处理时间及日期的
示例 1 如何 在 Java 8 中获取当天的日期
LocalDate today = LocalDate.now(); 
System.out.println("Today's Local date : " + today); 

Output 
Today's Local date : 2020-01-14


示例 2 如何在 Java 8 中获取当前的年月日
LocalDate today = LocalDate.now(); 
int year = today.getYear(); 
int month = today.getMonthValue(); 
int day = today.getDayOfMonth(); 
System.out.printf("Year : %d Month : %d day : %d \t %n", year, month, day); 

Output 
Today's Local date : 2020-01-14 
Year : 2020 Month : 1 day : 14



示例 3 在 Java 8 中如何获取某个特定的日期
LocalDate dateOfBirth = LocalDate.of(2010, 01, 14); 
System.out.println("Your Date of birth is : " + dateOfBirth); 

Output : Your Date of birth is : 2010-01-14



示例 4 在 Java 8 中如何检查两个日期是否相等
LocalDate date1 = LocalDate.of(2020, 01, 14); if(date1.equals(today)){ 
    System.out.printf("Today %s and date1 %s are same date %n", today, date1); 
} 

Output 
today 2020-01-14 and date1 2020-01-14 are same date



示例 5 在 Java 8 中如何检查重复事件，比如说生日
LocalDate dateOfBirth = LocalDate.of(2010, 01, 14); 
MonthDay birthday = MonthDay.of(dateOfBirth.getMonth(), dateOfBirth.getDayOfMonth()); 
MonthDay currentMonthDay = MonthDay.from(today); 
if(currentMonthDay.equals(birthday)){ 
    System.out.println("Many Many happy returns of the day !!"); 
}else{ 
    System.out.println("Sorry, today is not your birthday"); 
} 

Output: Many Many happy returns of the day !!



示例 6 如何在 Java 8 中获取当前时间
LocalTime time = LocalTime.now(); 
System.out.println("local time now : " + time);

Output 
local time now : 16:33:33.369 // in hour, minutes, seconds, nano seconds



示例 7 如何增加时间里面的小时数
LocalTime time = LocalTime.now(); 
LocalTime newTime = time.plusHours(2); // adding two hours 
System.out.println("Time after 2 hours : " + newTime); 

Output : 
Time after 2 hours : 18:33:33.369



示例 8 如何获取 1 周后的日期
LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS); 
System.out.println("Today is : " + today); 
System.out.println("Date after 1 week : " + nextWeek); 

Output: 
Today is : 2020-01-14 
Date after 1 week : 2020-01-21



示例 9 一年前后的日期
LocalDate previousYear = today.minus(1, ChronoUnit.YEARS); 
System.out.println("Date before 1 year : " + previousYear); 
LocalDate nextYear = today.plus(1, YEARS); 
System.out.println("Date after 1 year : " + nextYear); 

Output: 
Date before 1 year : 2019-01-14 
Date after 1 year : 2021-01-14



示例 10 在 Java 8 中使用时钟
// Returns the current time based on your system clock and set to UTC. 
Clock clock = Clock.systemUTC(); 
System.out.println("Clock : " + clock); 

// Returns time based on system clock zone Clock defaultClock = 
Clock.systemDefaultZone(); 
System.out.println("Clock : " + clock); 

Output: 
Clock : SystemClock[Z] 
Clock : SystemClock[Z]



public class MyClass { 
    private Clock clock; // dependency inject ... 

    public void process(LocalDate eventDate) { 

        if(eventDate.isBefore(LocalDate.now(clock)) { 
            ... 
        } 
    } 
}



示例 11 在 Java 中如何判断某个日期是在另一个日期的前面还是后面
LocalDate tomorrow = LocalDate.of(2020, 1, 15);
if(tommorow.isAfter(today)){ 
    System.out.println("Tomorrow comes after today"); 
} 
LocalDate yesterday = today.minus(1, DAYS); 
if(yesterday.isBefore(today)){ 
    System.out.println("Yesterday is day before today"); 
} 

Output: 
Tomorrow comes after today 
Yesterday is day before today



示例 12 在 Java 8 中处理不同的时区
// Date and time with timezone in Java 8 ZoneId america = ZoneId.of("America/New_York"); 
LocalDateTime localtDateAndTime = LocalDateTime.now(); 
ZonedDateTime dateAndTimeInNewYork = ZonedDateTime.of(localtDateAndTime, america ); 
System.out.println("Current date and time in a particular timezone : " + dateAndTimeInNewYork); 

Output : 
Current date and time in a particular timezone : 2020-01-14T16:33:33.373-05:00[America/New_York]



Exception in thread "main" java.time.zone.ZoneRulesException: Unknown time-zone ID: ASIA/Tokyo
        at java.time.zone.ZoneRulesProvider.getProvider(ZoneRulesProvider.java:272)
        at java.time.zone.ZoneRulesProvider.getRules(ZoneRulesProvider.java:227)
        at java.time.ZoneRegion.ofId(ZoneRegion.java:120)
        at java.time.ZoneId.of(ZoneId.java:403)
        at java.time.ZoneId.of(ZoneId.java:351)

示例 13 如何表示固定的日期，比如信用卡过期时间
YearMonth currentYearMonth = YearMonth.now(); 
System.out.printf("Days in month year %s: %d%n", currentYearMonth, currentYearMonth.lengthOfMonth()); 
YearMonth creditCardExpiry = YearMonth.of(2018, Month.FEBRUARY); 
System.out.printf("Your credit card expires on %s %n", creditCardExpiry); 

Output: 
Days in month year 2020-01: 31 
Your credit card expires on 2018-02

示例 14 如何在 Java 8 中检查闰年
if(today.isLeapYear()){ 
    System.out.println("This year is Leap year"); 
}else { 
    System.out.println("2020 is not a Leap year"); 
} 

Output: 2020 is not a Leap year

示例 15 两个日期之间包含多少天，多少个月
LocalDate java8Release = LocalDate.of(2020, Month.MARCH, 14); 
Period periodToNextJavaRelease = Period.between(today, java8Release); 
System.out.println("Months left between today and Java 8 release : " + periodToNextJavaRelease.getMonths() ); 

Output: 
Months left between today and Java 8 release : 2

示例 16 带时区偏移量的日期与时间
LocalDateTime datetime = LocalDateTime.of(2020, Month.JANUARY, 14, 19, 30); 
ZoneOffset offset = ZoneOffset.of("+05:30"); 
OffsetDateTime date = OffsetDateTime.of(datetime, offset); 
System.out.println("Date and Time with timezone offset in Java : " + date); 

Output : 
Date and Time with timezone offset in Java : 2020-01-14T19:30+05:30

示例 17 在 Java 8 中如何获取当前时间戳
Instant timestamp = Instant.now(); 
System.out.println("What is value of this instant " + timestamp); 

Output : 
What is value of this instant 2020-01-14T08:33:33.379Z

示例 18 如何在 Java 8 中使用预定义的格式器来对日期进行解析 / 格式化
String dayAfterTommorrow = "20200116"; 
LocalDate formatted = LocalDate.parse(dayAfterTommorrow, 
DateTimeFormatter.BASIC_ISO_DATE); 
System.out.printf("Date generated from String %s is %s %n", dayAfterTommorrow, formatted); 

Output : 
Date generated from String 20200116 is 2020-01-16

示例 19 如何在 Java 中使用自定义的格式器来解析日期
String goodFriday = "Apr 18 2020"; 
try { 
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMM dd yyyy");     
    LocalDate holiday = LocalDate.parse(goodFriday, formatter); 
    System.out.printf("Successfully parsed String %s, date is %s%n", goodFriday, holiday); 
} catch (DateTimeParseException ex) { 
    System.out.printf("%s is not parsable!%n", goodFriday); 
    ex.printStackTrace(); 
} 

Output : 
Successfully parsed String Apr 18 2020, date is 2020-04-18

示例 20 如何在 Java 8 中对日期进行格式化，转换成字符串
LocalDateTime arrivalDate = LocalDateTime.now(); 
try { 
    DateTimeFormatter format = DateTimeFormatter.ofPattern("MMM dd yyyy hh:mm a"); 
    String landing = arrivalDate.format(format); 
    System.out.printf("Arriving at : %s %n", landing); 
    } catch (DateTimeException ex) { 
    System.out.printf("%s can't be formatted!%n", arrivalDate); 
    ex.printStackTrace(); 
} 

Output : Arriving at : Jan 14 2020 04:33 PM

示例 21获取时间戳秒和毫秒
Instant ins= Instant.now();
System.out.println("10位 秒"+ins.getEpochSecond());
System.out.println("13位 毫秒"+ins.toEpochMilli());

Java 8 中日期与时间 API 的几个关键点

它提供了 javax.time.ZoneId 用来处理时区。
它提供了 LocalDate 与 LocalTime 类
Java 8 中新的时间与日期 API 中的所有类都是不可变且线程安全的，这与之前的 Date 与 Calendar API 中的恰好相反，那里面像 java.util.Date 以及 SimpleDateFormat 这些关键的类都不是线程安全的。
新的时间与日期 API 中很重要的一点是它定义清楚了基本的时间与日期的概念，比方说，瞬时时间，持续时间，日期，时间，时区以及时间段。它们都是基于 ISO 日历体系的。
每个 Java 开发人员都应该至少了解这套新的 API 中的这五个类：

Instant 它代表的是时间戳，比如 2020-01-14T02:20:13.592Z，这可以从 java.time.Clock 类中获取，像这样： Instant current = Clock.system(ZoneId.of(“Asia/Tokyo”)).instant();
LocalDate 它表示的是不带时间的日期，比如 2020-01-14。它可以用来存储生日，周年纪念日，入职日期等。
LocalTime – 它表示的是不带日期的时间
LocalDateTime – 它包含了时间与日期，不过没有带时区的偏移量
ZonedDateTime – 这是一个带时区的完整时间，它根据 UTC / 格林威治时间来进行时区调整


这个库的主包是 java.time，里面包含了代表日期，时间，瞬时以及持续时间的类。它有两个子 package，一个是 java.time.foramt，这个是什么用途就很明显了，还有一个是 java.time.temporal，它能从更低层面对各个字段进行访问。
时区指的是地球上共享同一标准时间的地区。每个时区都有一个唯一标识符，同时还有一个地区 / 城市 (Asia/Tokyo) 的格式以及从格林威治时间开始的一个偏移时间。比如说，东京的偏移时间就是 + 09:00。
OffsetDateTime 类实际上包含了 LocalDateTime 与 ZoneOffset。它用来表示一个包含格林威治时间偏移量（+/- 小时：分，比如 + 06:00 或者 -08：00）的完整的日期（年月日）及时间（时分秒，纳秒）。
DateTimeFormatter 类用于在 Java 中进行日期的格式化与解析。与 SimpleDateFormat 不同，它是不可变且线程安全的，如果需要的话，可以赋值给一个静态变量。DateTimeFormatter 类提供了许多预定义的格式器，你也可以自定义自己想要的格式。当然了，根据约定，它还有一个 parse() 方法是用于将字符串转换成日期的，如果转换期间出现任何错误，它会抛出 DateTimeParseException 异常。类似的，DateFormatter 类也有一个用于格式化日期的 format() 方法，它出错的话则会抛出 DateTimeException 异常。
再说一句，“MMM d yyyy”与 “MMm dd yyyy” 这两个日期格式也略有不同，前者能识别出”Jan 2 2020″与”Jan 14 2020″这两个串，而后者如果传进来的是”Jan 2 2020″则会报错，因为它期望月份处传进来的是两个字符。为了解决这个问题，在天为个位数的情况下，你得在前面补 0，比如”Jan 2 2020″应该改为”Jan 02 2020″。



原文: https://rumenz.com/rumenbiji/java8-java-time.html

简介

java中引用的包  import java.time.LocalDate





属性
功能




Instant
代表的是时间戳


LocalDate
不包含具体时间的日期


LocalTime
不含日期的时间


LocalDateTime
包含了日期及时间


1.获取日期时间

1.LocalDate 获取日期

		LocalDate nowDate = LocalDate.now();  //今天的日期

        int year = nowDate.getYear();  //年：一般用这个方法获取年

        int month = nowDate.getMonthValue();  //月：一般用这个方法获取月

        int day = nowDate.getDayOfMonth();  //日：当月的第几天，一般用这个方法获取日

        int dayOfYear = nowDate.getDayOfYear();  //日：当年的第几天
        //星期
        System.out.println(nowDate.getDayOfWeek());  //默认是日期英文表示
        System.out.println(nowDate.getDayOfWeek().getValue());  //日期阿拉伯数字表示
        //月份
        System.out.println(nowDate.getMonth());  //默认是日期英文表示
        System.out.println(nowDate.getMonth().getValue());  //日期阿拉伯数字表示


2.LocalTime 获取时间

		LocalTime nowTime = LocalTime.now();  //当前时间

        int hour = nowTime.getHour();  //时

        int minute = nowTime.getMinute();  //分

        int second = nowTime.getSecond();  //秒

        int nano = nowTime.getNano();  //纳秒



3.LocalDateTime 获取日期时间

		LocalDateTime nowDateTime = LocalDateTime.now();  //当前日期时间：2021-01-25T16:11:34.741

        System.out.println(nowDateTime.getYear());//年
        System.out.println(nowDateTime.getMonthValue());//月
        System.out.println(nowDateTime.getDayOfMonth());//日
        System.out.println(nowDateTime.getHour());//时
        System.out.println(nowDateTime.getMinute());//分
        System.out.println(nowDateTime.getSecond());//秒
        System.out.println(nowDateTime.getNano());//纳秒

        System.out.println(nowDateTime.getDayOfYear());//日：当年的第几天
        //星期
        System.out.println(nowDateTime.getDayOfWeek());
        System.out.println(nowDateTime.getDayOfWeek().getValue());
        //月份
        System.out.println(nowDateTime.getMonth());
        System.out.println(nowDateTime.getMonth().getValue());


2.获取指定日期时间

1.LocalDate

		LocalDate.of(1991, 11, 11);//直接传入对应的年月日
        LocalDate.of(1991, Month.NOVEMBER, 11);//相对上面只是把月换成了枚举
        
        LocalDate birDay = LocalDate.of(1991, 11, 11);
        LocalDate.ofYearDay(1991, birDay.getDayOfYear());//第一个参数为年，第二个参数为当年的第多少天
        LocalDate.ofEpochDay(birDay.toEpochDay());//参数为距离1970-01-01的天数
        LocalDate.parse("1991-11-11");
        LocalDate.parse("19911111",DateTimeFormatter.ofPattern("yyyyMMdd"));



2.LocalTime

		LocalTime.of(8, 20);//时分
        LocalTime.of(8, 20, 30);//时分秒
        LocalTime.of(8, 20, 30, 150);//时分秒纳秒
        LocalTime mTime = LocalTime.of(8, 20, 30, 150);
        LocalTime.ofSecondOfDay(mTime.toSecondOfDay());//参数为距离当天零时的秒数
        LocalTime.ofNanoOfDay(mTime.toNanoOfDay());//参数为距离当天零时的纳秒数
        LocalTime.parse("08:20:30");
        LocalTime.parse("082030", DateTimeFormatter.ofPattern("HHmmss"));



3.LocalDateTime

		LocalDateTime.of(birDay, mTime);//参数为LocalDate和LocalTime
       	LocalDateTime.of(1991, 11, 11, 8, 20);  //1991-11-11T08:20
        LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20);
        LocalDateTime.of(1991, 11, 11, 8, 20, 30);  //1991-11-11T08:20:30
        LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30);
        LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150);  //1991-11-11T08:20:30.000000150
        LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150);
        LocalDateTime.parse("1991-11-11T08:20:30");
        LocalDateTime.parse("1991-11-11 08:20:30", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));


3.日期时间的比较
		LocalDate of = LocalDate.of(1994, Month.OCTOBER, 21);
        System.out.println(of.equals(LocalDate.now()));  //false
        System.out.println(of + "指定日期是否在当前日期之前？ " + of.isBefore(LocalDate.now())); //true
        System.out.println(of+ "指定日期是否在当前日期之后？ " + of.isAfter(LocalDate.now())); //false


4.对日期时间的修改
		LocalDate nowDate = LocalDate.now();  //当前日期
        System.out.println(nowDate.minusYears(1));//一年前
        System.out.println(nowDate.minusMonths(1));//一月前
        System.out.println(nowDate.minusWeeks(1));//一周前
        System.out.println(nowDate.minusDays(1));//一天前
        System.out.println(nowDate.plusYears(1));//一年后
        System.out.println(nowDate.plusMonths(1));//一月后
        System.out.println(nowDate.plusWeeks(1));//一周后
        System.out.println(nowDate.plusDays(1));//一天后


		LocalTime nowTime = LocalTime.now();  //当前时间
        System.out.println(nowTime.minusHours(1));//一小时前
        System.out.println(nowTime.minusMinutes(1));//一分钟前
        System.out.println(nowTime.minusSeconds(1));//一秒前
        System.out.println(nowTime.minusNanos(1));//一纳秒前
        System.out.println(nowTime.plusHours(1));//一小时后
        System.out.println(nowTime.plusMinutes(1));//一分钟后
        System.out.println(nowTime.plusSeconds(1));//一秒后
        System.out.println(nowTime.plusNanos(1));//一纳秒后


还可以直接使用 minus 和 plus 方法来增加和减少日期时间。LocalDateTime 、LocalDate 、LocalTime 都是类似的

ChronoUnit 用来表示时间单位， ChronoUnit 后面只需要替换成相应的年、月、周、日、时、分、秒、纳秒，就能减少或增加相应的单位。

例如：System.out.println(nowDate.minus(1, ChronoUnit.YEARS));  //减
System.out.println(nowDate.plus(1, ChronoUnit.YEARS));  //加

4.时间戳
		Instant instant = Instant.now();
		System.out.println("当前时间戳是：" + instant);//当前时间戳是：2018-09-06T10:14:29.460Z
		Date date = Date.from(instant);
		System.out.println("当前时间戳是：" + date);//当前时间戳是：Thu Sep 06 18:14:29 CST 2018
		instant = date.toInstant();

5.日期时间格式化

在JDK8之前，时间日期的格式化非常麻烦，经常使用SimpleDateFormat来进行格式化，但是SimpleDateFormat并不是线程安全的。在JDK8中，引入了一个全新的线程安全的日期与时间格式器DateTimeFormatter

		System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));  //将当前日期时间格式化 ，DateTimeFormatter.ofPattern("自定义格式")

6.计算日期时间差

主要是 Period 类方法 getYears()，getMonths() 和 getDays() 来计算。只能精确到年月日。

		LocalDate today = LocalDate.now();
        System.out.println(today);//2018-09-06
        LocalDate birthDate = LocalDate.of(1992, 1, 11);
        System.out.println(birthDate);//1990-10-01
        Period period = Period.between(birthDate, today);//第二个参数减第一个参数
        System.out.printf("年龄 : %d 年 %d 月 %d 日", period.getYears(), period.getMonths(), period.getDays());//年龄 : 27 年 11 月 5 日


java.time.Duration

提供了使用基于时间的值测量时间量的方法。

用于 LocalDateTime 之间的比较。也可用于 Instant 之间的比较。

		LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30);
        System.out.println(birthDate);

        Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
        System.out.println(duration.toDays());//两个时间差的天数
        System.out.println(duration.toHours());//两个时间差的小时数
        System.out.println(duration.toMinutes());//两个时间差的分钟数
        System.out.println(duration.toMillis());//两个时间差的毫秒数
        System.out.println(duration.toNanos());//两个时间差的纳秒数


java.time.temporal.ChronoUnit

ChronoUnit类可用于在单个时间单位内测量一段时间，这个工具类是最全的了，可以用于比较所有的时间单位。

		LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30);
        System.out.println(birthDate);

        System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today));
        System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today));
        System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today));
        System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today));
        System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today));

        System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today));
        System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today));

◆ 当前时间：
下面三个函数能够获取不同格式的当前时间：
ngx.today()：本地时间，格式是yyyy-mm-dd，不含时分秒
ngx.localtime()：本地时间，格式是yyyy-mm-dd hh:mm:ss
ngx.utctime()：UTC 时间，格式是yyyy-mm-dd hh:mm:ss

◆ 时间戳：
获取当前的时间戳可以使用两个函数：
ngx.time()：当前的时间戳，即epoch以来的秒数
ngx.now()：类似ngx.time，但返回的是浮点数，精确到毫秒

在实践中我们通常使用ngx.now获取更精确的时间用来计时，但要注意它只能精确到毫秒级别，想要获取更高的精确度需要通过ffi库调用系统函数gettimeofday()。
◆ 格式化时间戳：
时间戳和字符串格式的时间可以互相转换， OpenResty 提供三个函数：
ngx.http_time()：把时间戳转换为http时间格式
ngx.cookie_time()：把时间戳转换为cookie时间格式
ngx.parse_http_time()：解析http 时间格式，转换为时间戳

示例：
local secs = 1514880339  -- 一个时间戳
ngx.say(ngx.http_time (secs))
ngx.say(ngx.cookie_time(secs))

local str = ” Tue, 02 Jan 2018 08 : 05 : 39 GMT ”  -- 一个http 格式的时间
ngx.say(ngx.parse_http_time(str))  -- 转换为时间戳

◆ 更新时间：
ngx.localtime/ngx.time/ngx.now等函数获取的时间基于OpenResty内部缓存的时

间，与实际时间相比可能存在微小的误差，如果想要随时获得准确的时间可以先调用函数ngx.update_time，然后再调用时间函数。
ngx.update_time会使用系统函数gettimeofday()强制更新时间，成本较高，除非

必要应当尽量少用。
ngx.update_time()    -- 强制更新内部缓存的时间
ngx.now()    -- 之后就可以获得更准确的时间

◆ ngx.sleep：
ngx.sleep是Openresty提供的同步非阻塞的睡眠函数，可以“睡眠”任意的时间长度

但不会阻塞整个服务，这时OpenResty会基于协程机制转而处理其他的请求，等睡眠时间到再“回头”继续执行ngx.sleep后续的代码。
ngx.sleep的时间单位是秒，可以用小数指定更小的时间（最小是0.001秒，即1毫

秒）
ngx.sleep(1.0)
ngx.sleep(0.001)

注：ngx.sleep不能在init_by_lua/init_worker_by_lua/set_by_lua/header|body_ filter_by_lua/log_by_lua等执行阶段里调用。