JAVA8时间处理

Java 8 推出了全新的日期时间API，在教程中我们将通过一些简单的实例来学习如何使用新API。

Java处理日期、日历和时间的方式一直为社区所诟病，将 java.util.Date设定为可变类型，以及SimpleDateFormat的非线程安全使其应用非常受限。

新API基于ISO标准日历系统，java.time包下的所有类都是不可变类型而且线程安全。

编号	类的名称	描述
1	Instant	时间戳
2	Duration	计算两个“时间”的间隔
3	LocalDate	只包含日期 比如：2020-04-05
4	LocalTime	只包含时间 比如：12:34:21
5	LoacalDateTime	包含日期和时间 比如：2021-04-05 12:34:34
6	Period	用于计算两个“日期”的间隔
7	ZonrOffset	时区偏移量
8	ZonedDateTime	带时区的时间
9	Clock	时钟比如获取美国纽约的时间
10	java.time.format.DateTimeFormatter	时间格式化

方法前缀的含义,统一了api:

of：静态工厂方法(用类名去调用)。
parse：静态工厂方法，关注于解析(用类名去调用)。
now： 静态工厂方法，用当前时间创建实例(用类名去调用)
get：获取某些东西的值。
is：检查某些东西的是否是true。
with：返回一个部分状态改变了的时间日期对象拷贝(单独一个with方法,参数为TemporalAdjusters类型)。
plus：返回一个时间增加了的、时间日期对象拷贝(如果参数是负数也能够有minus方法的效果)。
minus：返回一个时间减少了的、时间日期对象拷贝。
to：把当前时间日期对象转换成另外一个，可能会损失部分状态。
at：把这个对象与另一个对象组合起来，例如： date.atTime(time)。
format :根据某一个DateTimeFormatter格式化为字符串。

Instant :时间戳，相当于java.util的Date

Instant用于表示一个时间戳，它与我们常使用的System.currentTimeMillis()有些类似，不过Instant可以精确到纳秒（Nano-Second），System.currentTimeMillis()方法只精确到毫秒（Milli-Second）。如果查看Instant源码，发现它的内部使用了两个常量，seconds表示从1970-01-01 00:00:00开始到现在的秒数，nanos表示纳秒部分（nanos的值不会超过999,999,999）。Instant除了使用now()方法创建外，还可以通过ofEpochSecond方法创建：

Instant instant = Instant.ofEpochSecond(120, 100000);

ofEpochSecond()方法的第一个参数为秒，第二个参数为纳秒，上面的代码表示从1970-01-01 00:00:00开始后两分钟的10万纳秒的时刻，控制台上的输出为：

1970-01-01T00:02:00.000100Z

Duration : 计算两个“时间”的间隔

LocalDateTime from = LocalDateTime.of(2019, Month.JANUARY, 21, 15, 56, 0);    // 2019-01-21 15:56:00
LocalDateTime to = LocalDateTime.of(2019, Month.FEBRUARY, 21, 15, 56, 0);     // 2019-02-21 15:56:00
Duration duration = Duration.between(from, to);     // 表示从 2019-01-21 15:56:00 到 2019-02-21 15:56:00

long days = duration.toDays();              // 这段时间的总天数
long hours = duration.toHours();            // 这段时间的小时数
long minutes = duration.toMinutes();        // 这段时间的分钟数
long seconds = duration.getSeconds();       // 这段时间的秒数
long milliSeconds = duration.toMillis();    // 这段时间的毫秒数
long nanoSeconds = duration.toNanos();      // 这段时间的纳秒数

Duration对象还可以通过of()方法创建，该方法接受一个时间段长度，和一个时间单位作为参数

Duration duration1 = Duration.of(5, ChronoUnit.DAYS);       // 5天
Duration duration2 = Duration.of(1000, ChronoUnit.MILLIS);  // 1000毫秒

Period : 用于计算两个“日期”的间隔

Period在概念上和Duration类似，区别在于Period是以年月日来衡量一个时间段，比如2年3个月6天

Period period = Period.of(2, 3, 6);

由于Period是以年月日衡量时间段，所以between()方法只能接收LocalDate类型的参数：

// 2019-01-21 到 2019-02-21 这段时间
Period period = Period.between(
                LocalDate.of(2019, 1, 21),
                LocalDate.of(2019, 2, 21));

ZoneId : 时区

获取所有合法的“区域/城市”字符串 :

Set<String> zoneIds = ZoneId.getAvailableZoneIds();
获取系统默认时区 :

ZoneId systemZoneId = ZoneId.systemDefault();
创建时区 ：

ZoneId shanghaiZoneId = ZoneId.of("Africa/Bangui");

1:Java 8中获取今天的日期

Java 8 中的 LocalDate 用于表示当天日期。和java.util.Date不同，它只有日期，不包含时间。当你仅需要表示日期时就用这个类。

public class Demo01 {
    public static void main(String[] args) {
    LocalDate today = LocalDate.now();
    System.out.println("今天的日期:"+today);
    }
}

2:Java 8中获取年、月、日信息

public class Demo02 {
public static void main(String[] args) {
    LocalDate today = LocalDate.now();
    intyear = today.getYear();
    intmonth = today.getMonthValue();
    intday = today.getDayOfMonth();
    System.out.println("year:"+year);
    System.out.println("month:"+month);
    System.out.println("day:"+day);
    }
}

3:Java 8中处理特定日期

我们通过静态工厂方法now()非常容易地创建了当天日期，你还可以调用另一个有用的工厂方法LocalDate.of()创建任意日期，
该方法需要传入年、月、日做参数，返回对应的LocalDate实例。
这个方法的好处是没再犯老API的设计错误，比如年度起始于1900，月份是从0开 始等等。

import java.time.LocalDate;
public class Demo03 {
public static void main(String[] args) {
    LocalDate date = LocalDate.of(2018,2,6);
    System.out.println("自定义日期:"+date);
    }
}

4:Java 8中判断两个日期是否相等

public class Demo04 {
public static void main(String[] args) {
    LocalDate date1 = LocalDate.now();
    LocalDate date2 = LocalDate.of(2018,2,5);
    if(date1.equals(date2)){
    System.out.println("时间相等");
    }else{
    System.out.println("时间不等");
    }
  }
}

5:Java 8中检查像生日这种周期性事件

public class Demo05 {
public static void main(String[] args) {
        LocalDate date1 = LocalDate.now();
        LocalDate date2 = LocalDate.of(2018,2,6);
        MonthDay birthday = MonthDay.of(date2.getMonth(),date2.getDayOfMonth());
        MonthDay currentMonthDay = MonthDay.from(date1);
        if(currentMonthDay.equals(birthday)){
        System.out.println("是你的生日");
        }else{
        System.out.println("你的生日还没有到");
        }
    }
}

只要当天的日期和生日匹配，无论是哪一年都会打印出祝贺信息。你可以把程序整合进系统时钟，看看生日时是否会受到提醒，
或者写一个单元测试来检测代码是否运行正确。

6:Java 8中获取当前时间

public class Demo06 {
public static void main(String[] args) {
    LocalTime time = LocalTime.now();
    System.out.println("获取当前的时间,不含有日期:"+time);
    }
}

7:Java 8中获取几小时后的时间

通过增加小时、分、秒来计算将来的时间很常见。Java 8除了不变类型和线程安全的好处之外，
还提供了更好的plusHours()方法替换add()，并且是兼容的。注意，这些方法返回一个全新的LocalTime实例，
由于其不可变性，返回后一定要用变量赋值。

public class Demo07 {
public static void main(String[] args) {
LocalTime time = LocalTime.now();
LocalTime newTime = time.plusHours(3);
System.out.println("三个小时后的时间为:"+newTime);
}
}

Java 8如何计算一周后的日期

和上个例子计算3小时以后的时间类似，这个例子会计算一周后的日期。LocalDate日期不包含时间信息它的plus()方法用来增加天、周、月，
ChronoUnit类声明了这些时间单位。由于LocalDate也是不变类型，返回后一定要用变量赋值。

public class Demo08 {
public static void main(String[] args) {
    LocalDatetoday = LocalDate.now();
    System.out.println("今天的日期为:"+today);
    LocalDatenextWeek = today.plus(1, ChronoUnit.WEEKS);
    System.out.println("一周后的日期为:"+nextWeek);
    }
}

可以看到新日期离当天日期是7天，也就是一周。你可以用同样的方法增加1个月、1年、1小时、1分钟甚至一个世纪，
更多选项可以查看Java 8 API中的ChronoUnit类

Java 8计算一年前或一年后的日期

利用minus()方法计算一年前的日期

public class Demo09 {
public static void main(String[] args) {
    LocalDatetoday = LocalDate.now();
    LocalDatepreviousYear = today.minus(1, ChronoUnit.YEARS);
    System.out.println("一年前的日期 : " + previousYear);
    LocalDatenextYear = today.plus(1, ChronoUnit.YEARS);
    System.out.println("一年后的日期:"+nextYear);
    }
}

10:Java 8的Clock时钟类

Java 8增加了一个Clock时钟类用于获取当时的时间戳，或当前时区下的日期时间信息。
以前用到System.currentTimeInMillis()和TimeZone.getDefault()的地方都可用Clock替换。

public class Demo10 {
public static void main(String[] args) {
  // Returns the current time based on your system clock and set to UTC.
  Clockclock = Clock.systemUTC();
  System.out.println("Clock : " + clock.millis());
  // Returns time based on system clock zone
  ClockdefaultClock = Clock.systemDefaultZone();
  System.out.println("Clock : " + defaultClock.millis());
  }
}

11:如何用Java判断日期是早于还是晚于另一个日期

另一个工作中常见的操作就是如何判断给定的一个日期是大于某天还是小于某天？在Java 8中，
LocalDate类有两类方法isBefore()和isAfter()用于比较日期。调用isBefore()方法时，如果给定日期小于当前日期则返回true。

public class Demo11 {
public static void main(String[] args) {
    LocalDatetoday = LocalDate.now();
    LocalDatetomorrow = LocalDate.of(2018,2,6);
    if(tomorrow.isAfter(today)){
    System.out.println("之后的日期:"+tomorrow);
    }
    LocalDateyesterday = today.minus(1, ChronoUnit.DAYS);
    if(yesterday.isBefore(today)){
    System.out.println("之前的日期:"+yesterday);
    }
    }
}

12:Java 8中处理时区

Java 8不仅分离了日期和时间，也把时区分离出来了。现在有一系列单独的类如ZoneId来处理特定时区，ZoneDateTime类来表示某时区下的时间。
这在Java 8以前都是 GregorianCalendar类来做的。下面这个例子展示了如何把本时区的时间转换成另一个时区的时间。

public class Demo12 {
public static void main(String[] args) {
// Date and time with timezone in Java 8
    ZoneId america = ZoneId.of("Asia/Shanghai");
    LocalDateTime localtDateAndTime = LocalDateTime.now();
    ZonedDateTime dateAndTimeInNewYork = ZonedDateTime.of(localtDateAndTime, america );
    System.out.println("Current date and time in a particular timezone : " + dateAndTimeInNewYork);
    }
}

13:如何表示信用卡到期这类固定日期，答案就在YearMonth

与 MonthDay检查重复事件的例子相似，YearMonth是另一个组合类，用于表示信用卡到期日、FD到期日、期货期权到期日等。
还可以用这个类得到 当月共有多少天，YearMonth实例的lengthOfMonth()方法可以返回当月的天数，在判断2月有28天还是29天时非常有用。

public class Demo13 {
public static void main(String[] args) {
    YearMonth currentYearMonth = YearMonth.now();
    System.out.printf("Days in month year %s: %d%n", currentYearMonth, currentYearMonth.lengthOfMonth());
    YearMonth creditCardExpiry = YearMonth.of(2019, Month.FEBRUARY);
    System.out.printf("Your credit card expires on %s %n", creditCardExpiry);
    }
}

14:如何在Java 8中检查闰年

public class Demo14 {
public static void main(String[] args) {
    LocalDate today = LocalDate.now();
    if(today.isLeapYear()){
        System.out.println("This year is Leap year");
    }else {
     System.out.println("This year is not a Leap year");
        }
    }
}

15:计算两个日期之间的天数和月数

public class Demo15 {
public static void main(String[] args) {
           LocalDate today = LocalDate.of(2021, 4, 20);
           LocalDate java8Release = LocalDate.of(2020, 2, 19);
           Period between = Period.between(java8Release,today);
           System.out.println("两个日期之间的月数 : "+ between.getMonths() );
           System.out.println("两个日期之间的天数 : "+ between.getDays() );
           System.out.println("两个日期之间的年数 : "+ between.getYears() );
    }
}

16:在Java 8中获取当前的时间戳

public class Demo16 {
public static void main(String[] args) {
    Instant timestamp = Instant.now();
    System.out.println("What is value of this instant " + timestamp.toEpochMilli());
    }
}

时间戳信息里同时包含了日期和时间，这和java.util.Date很像。实际上Instant类确实等同于 Java 8之前的Date类，你可以使用Date类和Instant类各自的转换方法互相转换，
例如：Date.from(Instant) 将Instant转换成java.util.Date，Date.toInstant()则是将Date类转换成Instant类。

17:Java 8中如何使用预定义的格式化工具去解析或格式化日期

public class Demo17 {
public static void main(String[] args) {
    String dayAfterTommorrow = "20180205";
    LocalDate formatted = LocalDate.parse(dayAfterTommorrow,DateTimeFormatter.BASIC_ISO_DATE);
    System.out.println(dayAfterTommorrow+" 格式化后的日期为: "+formatted);
    }
}

18:字符串互转日期类型

public class Demo18 {
public static void main(String[] args) {
    LocalDate Timedate = LocalDateTime.now();
    DateTimeFormatter format1 = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    //日期转字符串
    String str = date.format(format1);
    System.out.println("日期转换为字符串:"+str);
    DateTimeFormatter format2 = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    //字符串转日期
    LocalDate date2 = LocalDate.parse(str,format2);
    System.out.println("日期类型:"+date2);
    }
}

19 Date 与 LocalDate LocalDateTime 互转

• Date转LocalDate LocalDateTime

1 将java.util.Date转化为ZonedDateTime.

2 使用它的toLocalDate()方法从ZonedDateTime获取LocalDate和LocalDateTime

public class Demo19 {
    public static void main(String[] args) {
        Date date = new Date();
        Instant instant = date.toInstant();
        LocalDate localDate = instant.atZone(ZoneId.systemDefault()).toLocalDate();
        LocalDateTime localDateTime = instant.atZone(ZoneId.systemDefault()).toLocalDateTime();
        System.out.println(localDate);
        System.out.println(date);
        System.out.println(localDateTime);

    }
}

• LocalDate LocalDateTime 转 Date

1使用 ZonedDateTime将LocalDate和 LocalDateTime 转化为 Instant

2 使用from() 方法从Instant 获取Date

public class Demo20 {
   public static void main(String[] args) {
        LocalDate localDate = LocalDate.now();
        LocalDateTime localDateTime = LocalDateTime.now();
        Instant instant = localDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
        Instant instant1 = localDateTime.atZone(ZoneOffset.systemDefault()).toInstant();
        Date from = Date.from(instant);
        Date from1 = Date.from(instant1);

        System.out.println(from);
        System.out.println(from1);

    }
}