Java8新时间API

版权声明：本文为博主原创文章，转载请注明出处。 https://blog.csdn.net/xufei_0320/article/details/84947846

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

设计原则

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

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

java.time

java.time包中的是类是不可变且线程安全的。新的时间及日期API位于java.time中。下面是一些比较常用的类：

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

常见用法

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

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

计算日期/时间

获取当前时间/日期

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

输出：

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

更多方法就需要大家自己去点点看啦。

判断两个日期是否相等

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

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

输出：

false

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

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

public class Test {
    public static void main(String[] args) {
        // 构建2018-09-04
        LocalDate d1 = LocalDate.of(2018, 9, 4);
        // 构建2018-09-03
        LocalDate d2 = LocalDate.of(2018, 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));
    }
}

输出：

2018-09-04
2018-09-03
2018-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());
    }
}

输出：

1536101287531
1536101287531
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(2018, 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 : 2018-09-05T07:50:43.187+09:30[Australia/Darwin]
Date and Time with timezone offset in Java : 2018-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(2018, Month.NOVEMBER);
        System.out.println(expire);
    }
}

输出：

2018-09
30
2018-11

格式化日期

public class Test {
    public static void main(String[] args) {
        String dayAfterTomorrow = "20180905";
        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 2018";
        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 20180905 is 2018-09-05 
Successfully parsed String Sep 05 2018, date is 2018-09-05
Arriving at : Sep 06 2018 07:47 AM

计算时间间隔

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

• 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