Java8日期/时间API是JSR-310(Java Specification Requests)的实现，它的实现目标是克服旧的日期时间实现中所有的缺陷，利用它可以更加方便我们去处理时间和日期的计算等问题。

设计原则

新的日期/时间API它遵循以下的设计原则：

• 不变性：在新的日期/时间API中，所有的类都被设计成不可变的，这在多线程环境下也是没有问题的。
• 关注点分离：在Java8中，相比于之前旧的时间和日历类，较大的改变是将人可读的日期时间和机器时间(unix timestamp)明确分离，为日期(Date)、时间(Time)、日期时间(DateTime)、时间戳(unix timestamp)以及时区定义了不同的类。
• 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。举个例子，要拿到当前实例我们可以使用now()方法，在所有的类中都定义了format()和parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。
• 实用操作：所有新的日期/时间API类都实现了一系列方法用以完成通用的任务，如：加、减、 格式化、解析、从日期/时间中提取单独部分，等等。
• 可扩展性： 新的日期/时间API是工作在ISO-8601日历系统上的，但我们也可以将其应用在非ISO的日历上。

time 包

java.time包中的是类是不可变且线程安全的，下面是一些比较常用的类：

• Instant：表示时间戳。
• LocalDate：不包含具体时间点的日期。
• LocalTime：不包含日期的时间点。
• LocalDateTime：具体的日期时间点，不带时区。
• ZonedDateTime：包含时区的完整的日期时间点，偏移量是以UTC/格林威治时间为基准的。

常见用法

对于这些类，它们都有以下一些方法：

• of：静态工厂方法。
• parse：静态工厂方法，关注于解析。
• get：获取某些东西的值。
• is：检查某些东西的是否是true。
• with：不可变的setter等价物。
• plus：加一些量到某个对象。
• minus：从某个对象减去一些量。
• to：转换到另一个类型。
• at：把这个对象与另一个对象组合起来。

下面我们就来看看他们具体都是怎么用的。

计算日期/时间

获取当前时间/日期

以前有Date类可以获取当前时间，有Calendar类来做日历相关操作。而在Java8中，提供了多个类来获取当前的日期、时间、时间戳等信息。

public class Test {
    public static void main(String[] args) {
        // 获取当前日期
        System.out.println(LocalDate.now());
        // 获取当前时间点
        System.out.println(LocalTime.now());
        // 获取当前时间点去掉纳秒
        System.out.println(LocalTime.now().withNano(0));
        // 获取当前的日期时间
        System.out.println(LocalDateTime.now());
        // 获取当前年
        System.out.println(LocalDate.now().getYear());
    }
}

输出：

2017-09-04
22:03:49.502
22:03:49
2017-09-04T22:03:49.502
2017

不要在意这个鸡毛年份，文章写于N久前，最近改改重新发出来的。

判断两个日期是否相等

在Java8的众多类中，它们都重写了toString()方法。所以对于日期是否相同的判断，我们可以直接使用它的equals()方法。

public class Test {
    public static void main(String[] args) {
        // 获取当前日期
        LocalDate today = LocalDate.now();
        // 构建2017-09-03
        LocalDate date = LocalDate.of(2017, 9, 3);
        // 判断是否相等
        System.out.println(today.equals(date));
    }
}

输出：

false

判断一个日期是否在另一个日期之前

有时候可能会有这样的需求，需要判断一个日期在另一个日期的前面还是后面，这时候就会用到isBefore()和isAfter()方法，这样就可以方便的作出判断。

public class Test {
    public static void main(String[] args) {
        // 构建2017-09-04
        LocalDate d1 = LocalDate.of(2017, 9, 4);
        // 构建2017-09-03
        LocalDate d2 = LocalDate.of(2017, 9, 3);
        // 判断d1是否在d2后面
        System.out.println(d1.isAfter(d2));
        // 判断d1是否在d2前面
        System.out.println(d1.isBefore(d2));
    }
}

输出：

true
false

可以看到我们直接可以使用isBefore()和isAfter()来判断两个日期谁前谁后了，而不需要向之前使用Calendar来进行麻烦的操作了。

检查重复日期

对于一些特定的日期，比如生日、纪念日等，我们可以轻易来判断某一日期是不是我们需要的特定日期。

public class Test {
    public static void main(String[] args) {
        LocalDate dateOfBirth = LocalDate.of(1992, 9, 4);
        MonthDay birthday = MonthDay.of(dateOfBirth.getMonth(), dateOfBirth.getDayOfMonth());
        MonthDay currentMonthDay = MonthDay.from(LocalDate.now());
        if(currentMonthDay.equals(birthday)){
            System.out.println("Happy Birthday !");
        }else{
            System.out.println("Sorry, today is not your birthday！");
        }
    }
}

输出：

Happy Birthday !

判断某个日期是不是周几

同样，我们可以很方便的来判断某天是周几。DayOfWeek构建的是周几，然后使用from()方法，来构建某一日期为周几，这样我们就可以轻松判断出某一日期是周几，而不必向以前一样麻烦。

public class Test {
    public static void main(String[] args) {
        DayOfWeek dayOfWeek = DayOfWeek.of(2);
        DayOfWeek from = DayOfWeek.from(LocalDate.now());
        System.out.println(from.equals(dayOfWeek));
    }
}

输出：

true

延迟或者推前时间

有时候我们可能会需要用到一些日期计算，比如，昨天，前天，明天，一周前，一年前等。在Java8中可以轻松实现，因为这些类中已经提供了相关方法。plus开头的表示往后算，minus表示往前算。

public class Test {
    public static void main(String[] args) {
        // 获取当前日期
        LocalDate today = LocalDate.now();
        System.out.println(today);
        // 推前一天
        System.out.println(today.minusDays(1));
        // 延后一天
        System.out.println(today.plusDays(1));
    }
}

输出：

2017-09-04
2017-09-03
2017-09-05

时钟

Java8提供了时钟类，利用时钟类可以实现和System.currentTimeMillis()一样的功能，还能够获取当前时区。

public class Test {
    public static void main(String[] args) {
        // 获取当前时间戳
        System.out.println(Clock.systemUTC().millis());
        // 获取当前时间戳
        System.out.println(System.currentTimeMillis());
        // 获取当前系统默认时区
        System.out.println(Clock.systemDefaultZone().getZone());
    }
}

输出：

1504478880531
1504478880531
Asia/Shanghai

检查闰年

可以使用isLeapYear()方法直接判断是否为闰年，而不用我们再自己去计算。

public class Test {
    public static void main(String[] args) {
        System.out.println(LocalDate.of(2020, 1, 1).isLeapYear());
    }
}

输出：

true

带时区计算

Java 8不仅将日期和时间进行了分离，同时还有时区。现在已经有好几组与时区相关的类了，比如ZonId代表的是某个特定的时区，而ZonedDateTime代表的是带时区的时间。它等同于Java 8以前的GregorianCalendar类。使用这个类，你可以将本地时间转换成另一个时区中的对应时间。用ZoneOffset类来代表某个时区，比如印度是GMT或者UTC5：30，你可以使用它的静态方法ZoneOffset.of()方法来获取对应的时区。只要获取到了这个偏移量，你就可以拿LocalDateTime和这个偏移量创建出一个OffsetDateTime。

public class Test {
    public static void main(String[] args) {
        // 获取当前时间
        LocalDateTime now = LocalDateTime.now();
        // 设置时区
        ZonedDateTime zonedDateTime = ZonedDateTime.of(now, ZoneId.of("Australia/Darwin"));
        System.out.println("Current date and time in a particular timezone : " + zonedDateTime);

        // 构建一个时间
        LocalDateTime datetime = LocalDateTime.of(2017, Month.SEPTEMBER, 5, 7, 50);
        // 设置偏移量
        ZoneOffset offset = ZoneOffset.of("+05:30");
        // 构建带偏移量的日期和时间
        OffsetDateTime date = OffsetDateTime.of(datetime, offset);
        System.out.println("Date and Time with timezone offset in Java : " + date);
    }
}

输出：

Current date and time in a particular timezone : 2017-09-05T07:50:43.187+09:30[Australia/Darwin]
Date and Time with timezone offset in Java : 2017-09-05T07:50+05:30

OffSetDateTime主要是给机器来理解的，如果是给人看的，可以使用ZoneDateTime类。

固定日期

在前面我们用过一个MonthDay的类，用来构建特定的几月几日。这里用到了另一个YearMonth，它表示某年某月，我们可以它来知道某年某月有多少天，使用YearMonth的lengthOfMonth()方法。

public class Test {
    public static void main(String[] args) {
        // 获取当前年月
        YearMonth current = YearMonth.now();
        System.out.println(current);
        // 获取这个月有多少天
        System.out.println(current.lengthOfMonth());
        // 构建一个固定日期
        YearMonth expire = YearMonth.of(2017, Month.NOVEMBER);
        System.out.println(expire);
    }
}

输出：

2017-09
30
2017-11

格式化日期

public class Test {
    public static void main(String[] args) {
        String dayAfterTomorrow = "20170905";
        LocalDate formatted = LocalDate.parse(dayAfterTomorrow,
                DateTimeFormatter.BASIC_ISO_DATE);
        System.out.printf("Date generated from String %s is %s %n", dayAfterTomorrow, formatted);

        String goodFriday = "Sep 05 2017";
        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();
        }

        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();
        }

    }
}

输出：

Date generated from String 20170905 is 2017-09-05 
Successfully parsed String Sep 05 2018, date is 2017-09-05
Arriving at : Sep 06 2017 07:47 AM

计算时间间隔

Java8为我们提供了三个类来方便计算时间间隔，分别是

• Duration：计算秒、纳秒。
• ChronoUnit：计算天、时、分、秒。
• Period：计算年、月、日。

秒、纳秒

public class Test {
    public static void main(String[] args) {
        // 获取当前时间戳
        Instant i1 = Instant.now();
        // 当前时间推后10s
        Instant i2 = i1.plusSeconds(10);
        // 获取时间差
        Duration between = Duration.between(i1, i2);
        // 获取时间差的毫秒值
        System.out.println(between.toMillis());
        // 获取时间差的纳秒值
        System.out.println(between.toNanos());
        // 获取时间差的天数值
        System.out.println(between.toDays());
        // 获取时间差的小时值
        System.out.println(between.toHours());
        // 获取时间差的分钟值
        System.out.println(between.toMinutes());
        // 获取时间差的秒数值
        System.out.println(between.getSeconds());
    }
}

输出：

10000
10000000000
0
0
0
10

天、时、分、秒

public class Test {
    public static void main(String[] args) {
        // 获取当前时间
        LocalDateTime d1 = LocalDateTime.now();
        // 当前时间延后90000s
        LocalDateTime d2 = d1.plusSeconds(90000);
        // 获取两个时间之间隔了几个半天
        long b1 = ChronoUnit.HALF_DAYS.between(d1, d2);
        System.out.println(b1);
        // 获取两个时间之间隔了几个小时
        long b2 = ChronoUnit.HOURS.between(d1, d2);
        System.out.println(b2);
        // 获取两个时间之间隔了多少毫秒
        long b3 = ChronoUnit.MILLIS.between(d1, d2);
        System.out.println(b3);
    }
}

输出：

2
25
90000000

年、月、日

public class Test {
    public static void main(String[] args) {
        // 获取当前日期
        LocalDate d1 = LocalDate.now();
        // 构建2018-10-01
        LocalDate d2 = LocalDate.of(2018, 10, 1);
        // 获取两个日期的差值
        Period between = Period.between(d1, d2);
        // 获取两个日期隔了多少年
        System.out.println(between.getYears());
        // 获取两个日期隔了多少月
        System.out.println(between.getMonths());
        // 获取两个日期隔了多少天
        System.out.println(between.getDays());
    }
}

输出：

0
0
26

获取某天的日期

比如有时候我们还会有这样的需求，获取当前日期所在的周一，那么这种又该怎么处理呢；

public class Test {
  public static void main(String[] args) {
        LocalDate now = LocalDate.now();
        LocalDate date = now.with(DayOfWeek.MONDAY);
        System.out.println(date);
  }
}

输出：

2017-09-04

结语

好了，常用的用法就讲到这里，time包下的类搭配起来可以有更多的用法，需要同学们在使用过程中去摸索了，这里只是列举了部分常见的用法，可能在日常开发中能够用到，这也是我平时在开发中常用到的一些API。这里再提供两个工具类供参考一些格式化时间的方式以及一些常用转换处理，戳这里查看详情。