详解 JDK8 新增的日期时间类

JDK8 新增的日期时间类

在本人之前的博文《处理时间的类 —— System类、Date类、SimpleDateFormat类与 Calendar类》中，讲到过表示时间的类，有三类：Date、SimpleDateFormat、Calendar类（System.currentTimeMillis()勉强也能算作是一个）

那么，在JDK8的时代，Java提供了几个新的、线程安全的、用于处理时间的类。
现在，本人就来讲讲这几个类：

JDK8 新增的日期时间类

首先是 LocalDate、LocalTime、LocalDateTime类：

LocalDate、LocalTime、LocalDateTime类：

概述：

这三个类分别表示使用 ISO-8601日历系统的日期、时间、日期和时间
它们提供了简单的日期或时间，并不包含当前的时间信息。
也不包含与时区相关的信息。
注： ISO-8601日历系统 是 国际标准化组织制定的现代公民的日期和时间的表示法
这些新增的日期时间API都在 java.time包下

获取对象的方法：

获取对象的方法：

通过静态方法 ：now()（获取的时间是系统当前的时间）

通过静态方法：of()（方法参数可以指定时间）

那么，现在，本人来通过代码来展示下如何去获取对象：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Test {

    public static void main(String[] args) {
        /* 通过静态方法 now() 返回该类的实例 */
        //获取当前的日期时分秒
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        //获取当前的日期
        LocalDate now1 = LocalDate.now();
        System.out.println(now1);

        //获取当前的时分秒
        LocalTime now2 = LocalTime.now();
        System.out.println(now2);

        System.out.println("=========================================");
        /* 静态方法 of() 返回该类的实例 */
        //指定日期时分秒
        LocalDateTime localDateTime = LocalDateTime.of(2048, 11, 25, 12, 00, 30);
        System.out.println(localDateTime);

        //指定日期
        LocalDate date = LocalDate.of(2020, 12, 12);
        System.out.println(date);
        
        //指定时分秒
        LocalTime time = LocalTime.of(14, 20, 30);
        System.out.println(time);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

常用方法：

与获取相关的方法(get系类的方法)：

getYear()：
获取年

ldt.getHour()：
获取小时

getMinute():
获取分钟

getSecond():
获取秒值

getDayOfMonth()：
获得月份天数(1-31)

getDayOfYear()：
获得年份天数(1-366)

getDayOfWeek()：
获得星期几(返回一个 DayOfWeek枚举值)

getMonth()：
获得月份(返回一个 Month 枚举值)

getMonthValue()：
获得月份(1-12)

getYear()：
获得年份

那么，现在，本人来通过代码来展示下与获取相关的方法的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDateTime;
import java.time.Month;

public class Test {

    public static void main(String[] args) {
        //获取日期时分秒
        LocalDateTime now = LocalDateTime.now();

        //获取年份
        int year = now.getYear();
        System.out.println(year);

        //获取月份枚举
        //Month 枚举类，定义了十二个月份
        Month month = now.getMonth();
        System.out.println(month);

        //获取月份的数值
        int monthValue = now.getMonthValue();
        System.out.println(monthValue);

        //获取当天在本月的第几天
        int dayOfMonth = now.getDayOfMonth();
        System.out.println(dayOfMonth);

        //获取小时
        int hour = now.getHour();
        System.out.println(hour);

        //获取分钟
        int minute = now.getMinute();
        System.out.println(minute);

        //获取秒值
        int second = now.getSecond();
        System.out.println(second);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

格式化日期日期字符串的方法：

format()：
格式化字符串

那么，现在，本人来通过代码来展示下如何去格式化日期日期字符串：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Test {

    public static void main(String[] args) {
        //获取当前日期时分秒
        LocalDateTime now = LocalDateTime.now();

        //默认格式  年-月-日T时:分:秒
        System.out.println(now);

        //指定格式
        DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern("yyyy年MM月DD日 HH时mm分ss秒");
        //传入格式
        String dateStr = now.format(ofPattern);
        System.out.println(dateStr);
    }

}

那么，现在，本人来展示下运行结果：

在这里插入图片描述

转换的方法：

toLocalDate()：
将目标LocalDateTime转换为相应的LocalDate对象

toLocalTime()：
将目标LocalDateTime转换为相应的LocalTime对象

那么，现在，本人来通过代码来展示下如何去转换：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Test {

    public static void main(String[] args) {
        //获取当前年月日，时分秒
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        //将目标LocalDateTime转换为相应的LocalDate对象
        LocalDate localDate = now.toLocalDate();
        System.out.println(localDate);

        ///将目标LocalDateTime转换为相应的LocalTime对象
        LocalTime localTime = now.toLocalTime();
        System.out.println(localTime);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

判断的方法：

isAfter()：
判断一个日期是否在指定日期之后

isBefore()：
判断一个日期是否在指定日期之前

isEqual()：
判断两个日期是否相同

isLeapYear()：
判断是否是闰年（注意是LocalDate类和 LocalDateTime类特有的方法）

那么，现在，本人来通过代码来展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;

public class Test {

    public static void main(String[] args) {
        //获取当前的日期
        LocalDate now = LocalDate.now();

        //指定的日期
        LocalDate of = LocalDate.of(2015, 12, 12);

        //判断一个日期是否在另一个日期之前
        boolean before = of.isBefore(now);
        System.out.println(before);

        //判断一个日期是否在另一个日期之后
        boolean after = of.isAfter(now);
        System.out.println(after);

        //判断这两个日期是否相等
        boolean after1 = now.equals(of);
        System.out.println(after1);

        //判断闰年
        boolean leapYear = of.isLeapYear();
        System.out.println(leapYear);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

解析字符串的方法：

paser(String str)：
将一个日期字符串解析成日期对象,注意字符串日期的写法的格式要正确,否则解析失败

paser(String str, DateTimeFormatter formatter)：
将字符串按照参数传入的格式进行解析

那么，现在，本人来通过代码来展示下如何去解析字符串：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class Test {

    public static void main(String[] args) {
        //给出一个符合默认格式要求的日期字符串
        String dateStr="2020-01-01";

        //把日期字符串解析成日期对象 如果日期字符串时年月日 解析时用  LocalDate
        LocalDate parse = LocalDate.parse(dateStr);
        System.out.println(parse);

        System.out.println("===========================================");
        //给出一个符合默认格式要求的 时分秒 字符串
        String dateTimeStr="14:20:30";

        //把 时分秒 字符串解析成时分秒对象
        LocalTime parse1 = LocalTime.parse(dateTimeStr);
        System.out.println(parse1);

        System.out.println("=========================================");
        //给出一个符合默认格式要求的 日期时分秒 字符串
        String str="2018-12-12T14:20:30";

        //把 日期时分秒 字符串解析成时分秒对象
        LocalDateTime parse2 = LocalDateTime.parse(str);
        System.out.println(parse2);

        System.out.println("========================================");
        //给出一个自定义日期时分秒格式字符串
        String dateStr2="2020年12月12日 12:13:14";

        //给出一个自定义解析格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        //按照指定的格式去解析
        LocalDateTime parse3 = LocalDateTime.parse(dateStr2,formatter);
        System.out.println(parse3);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

增减年月日时分秒的方法（plus/minus系列的方法）：

plusYears(int offset)：
增加指定年份

plusMonths(int offset)：
增加指定月份

plusWeeks(int offset)：
增加指定周

plusDates(int offset)：
增加指定日

plusHours(int offset)：
增加指定时

plusMinuets(int offset)：
增加指定分

plusSeconds(int offset)：
增加指定秒

plusNanos(int offset)：
增加指定纳秒

minusYears(int offset)：
减少指定年

minusMonths(int offset)：
减少指定月

minusWeeks(int offset)：
减少指定周

minusDates(int offset)：
减少指定日

minusHours(int offset)：
减少指定时

minusMinuets(int offset)：
减少指定分

minusSeconds(int offset)：
减少指定秒

minusNanos(int offset)：
减少指定纳秒

那么，现在，本人来通过代码来展示下部分API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;
import java.time.LocalDateTime;

public class Test {

    public static void main(String[] args) {
        //增加时间量的方法 plusXXX系类的方法 返回的是一个新的日期对象
        LocalDateTime now = LocalDateTime.now();
        //可以给当前的日期增加时间量
        LocalDateTime newDate= now.plusYears(1);
        int year = newDate.getYear();
        System.out.println(year);

        System.out.println("================================");
        //减去时间量的方法minusXXX 系列的方法 返回的是一个新的日期对象
        LocalDate now1 = LocalDate.now();
        LocalDate newDate2 = now1.minusDays(10);
        int dayOfMonth = newDate2.getDayOfMonth();
        System.out.println(dayOfMonth);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

指定年月日时分秒的方法：

with(TemporalAdjuster adjuster):
指定特殊时间

withYear(int year):
指定年

withDayOfYear(int dayOfYear):
指定日

withMonth(int month):
指定月

withDayOfMonth(int dayOfMonth):
指定日

那么，现在，本人来通过代码来展示下部分API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.TemporalAdjusters;

public class Test {

    public static void main(String[] args) {
        //指定某个日期的方法 with()方法
        LocalDate now2 = LocalDate.now();
        LocalDate localDate = now2.withYear(2014);
        System.out.println(localDate);

        // TemporalAdjusters工具类，提供了一些获取特殊日期的方法
        LocalDate with = now2.with(TemporalAdjusters.firstDayOfMonth());
        System.out.println(with);
        LocalDate with1 = now2.with(TemporalAdjusters.firstDayOfNextMonth());
        System.out.println(with1);

        //获取这个月的第几个星期几是几号,比如 TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY)
        // 代表的意思是这个月的第二个星期五是几号
        LocalDate with2 = now2.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY));
        System.out.println(with2);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

在上文中，本人运用到了TemporalAdjuster接口，
那么，现在，本人就来讲解下这个接口：

TemporalAdjuster接口 —— 时间校正器：

概述：

一般我们用该接口的一个对应的工具类 TemporalAdjusters中的一些常量,
来指定日期
对于这个接口，我们主要运用它的几个常量 和 next()方法来指定日期
或者采用自定义的方式来指定日期

现在，本人来通过一段代码来展示下这个接口的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

public class Test {

    public static void main(String[] args) {
        LocalDate now = LocalDate.now();
        //指定日期
        //对于一些特殊的日期，可以通过一个工具类TemporalAdjusters 来指定
        TemporalAdjuster temporalAdjuster = TemporalAdjusters.firstDayOfMonth();    //见名知意，本月第一天
        LocalDate with = now.with(temporalAdjuster);
        System.out.println(with);

        TemporalAdjuster next = TemporalAdjusters.next(DayOfWeek.SUNDAY);   //下周周末
        LocalDate with1 = now.with(next);
        System.out.println(with1);
        System.out.println("===================================");


        LocalDate now1 = LocalDate.now();
        //自定义日期 —— 下一个工作日
        LocalDate with2 = now1.with(new TemporalAdjuster() {
            @Override
            //参数 nowDate 当前的日期对象
            public Temporal adjustInto(Temporal nowDate) {
                //向下转型
                LocalDate date= (LocalDate) nowDate;
                if(date.getDayOfWeek().equals(DayOfWeek.FRIDAY)){
                    LocalDate localDate = date.plusDays(3);
                    return localDate;
                }else if(date.getDayOfWeek().equals(DayOfWeek.SATURDAY)){
                    LocalDate localDate = date.plusDays(2);
                    return localDate;
                }else{
                    LocalDate localDate = date.plusDays(1);
                    return localDate;
                }
            }
        });
        System.out.println("下一个工作日是：" + with2);
    }

}

那么，现在，本人来展示下运行结果：
在这里插入图片描述

Instant 时间戳类：

获取对象的方法：
now():
注意默认获取出来的是当前的美国时间，
和我们相差八个小时（因为我们在东八时区）

设置偏移量的方法:
atOffset():

获取系统默认时区时间的方法:
atZone():
方法的参数是要一个时区的编号(可以通过时区编号类获取ZonedDateTime类的对象)

get系列的方法:

getEpochSecond():
获取从1970-01-01 00:00:00到当前时间的秒值

toEpochMilli():
获取从1970-01-01 00:00:00到当前时间的毫秒值

getNano():
把获取到的当前时间的秒数 换算成纳秒

ofEpoch系列方法：

ofEpochSecond():
给计算机元年增加秒数

ofEpochMilli():
给计算机元年增加毫秒数

现在，本人来展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.util.Date;

public class Test {

    public static void main(String[] args) {
        //  Instant 时间戳类从1970 -01 - 01 00:00:00 截止到当前时间的毫秒值
        Instant now = Instant.now();
        System.out.println(now); //获取的是默认时区，获取的不是中国 的时区

        //获取当前时区的，我们可以添加偏移量,返回偏移过后的日期
        OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);
        System.out.println("===========================");

        //从1970 - 01 - 01 00:00:00 截止到当前时间的毫秒值
        long l = System.currentTimeMillis();
        System.out.println(l);
        long time = new Date().getTime();

        //JDK1.8 Instant 时间戳类从1970 -01 - 01 00:00:00 截止到当前时间的毫秒值
        Instant now1 = Instant.now();

        //toEpochMilli():从1970 -01 - 01 00:00:00 截止到当前时间间隔的毫秒值
        long l1 = now1.toEpochMilli();
        System.out.println(l1);

        //获取从1970 -01 - 01 00:00:00 截止到当前时间间隔的秒值
        long epochSecond = now1.getEpochSecond();
        System.out.println(epochSecond);

        System.out.println("==========================");
        //给计算机元年增加相应的时间量
        Date date = new Date(1000 * 60 * 60*24);
        System.out.println(date);

        //现在 给计算机元年增加相应的时间量
        //5. ofEpochSecond() 方法 给计算机元年增加秒数
        //ofEpochMilli() 给计算机元年增加毫秒数
        Instant instant = Instant.ofEpochMilli(1000 * 60 * 60 * 24);
        System.out.println(instant);

        //ofEpochSecond() 方法 给计算机元年增加秒数
        Instant instant1 = Instant.ofEpochSecond(60 * 60 * 24);
        System.out.println(instant1);
    }

}

那么，现在本人来展示下运行结果：
在这里插入图片描述

Duration类 —— 用于计算两个“时间”间隔的类：

常用API：

静态方法 between()：
计算两个时间的间隔，默认是秒

toDays():
将时间转换为以天为单位的

toHours():
将时间转换为以时为单位的

toMinutes():
将时间转换为以分钟为单位的

toMillis()：
将时间转换为以毫秒为单位的

toNanos():
将时间转换为以纳秒为单位的

那么，现在本人来通过一段代码展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.Duration;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.util.Date;

public class Test {

    public static void main(String[] args) {
        //计算时间的间隔
        Instant start = Instant.now();
        for (int i = 0; i < 15; i++) {
            System.out.println(i);
        }
        Instant end = Instant.now();
        Duration duration = Duration.between(start, end);
        long l = duration.toNanos();

        //间隔的时间
        System.out.println("循环耗时："+l+"纳秒");
    }

}

现在，本人来展示下运行结果：
在这里插入图片描述

Period类 —— 用于计算两个“日期”间隔的类：

静态方法 between()：
计算两个日期之间的间隔

getYears()：
获取年份

getMonths()：
获取月份

getDays()：
获取天数

那么，现在本人来通过一段代码展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.*;

public class Test {

    public static void main(String[] args) {
        //计算两个日期的间隔
        LocalDate birthday = LocalDate.of(2012, 12, 12);
        LocalDate now = LocalDate.now();
        //我从出生到现在，有多少岁，零几个月，几天
        //计算两个日期的间隔
        Period between = Period.between(birthday, now);
        int years = between.getYears();
        int months = between.getMonths();
        int days = between.getDays();
        System.out.println("玛雅人的地球都消灭了"+years+"年"+months+"月"+days+"天了...");
    }

}

那么，现在，本人来展示下运行结果:
在这里插入图片描述

DateTimeFormatter类 —— 解析和格式化日期或时间的类

本人现在来展示下这个类的常用API ：

静态方法ofPattern("yyyy-MM-dd")：
通过给定格式获取对象

format()：
把一个日期对象的默认格式 格式化成指定的格式的字符串

那么，现在，本人来展示下这个类的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

public class Test {

    public static void main(String[] args) {
        // 之前格式化日期的类  new SimpleDateFormat()
        //JDK1.8 DateTimeFormatter
        //指定格式 静态方法 ofPattern()
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // DateTimeFormatter 自带的格式方法
        LocalDateTime now = LocalDateTime.now();
        //把日期对象，格式化成字符串
        String format = formatter.format(now);
        //刚才的方式是使用的日期自带的格式化方法
        String format1 = now.format(formatter);
        System.out.println(format);
        System.out.println(format1);
    }

}

那么，现在本人来展示下运行结果：
在这里插入图片描述

ZonedDate、ZonedTime、ZonedDateTime —— 带时区的时间或日期

概述：

这个三个类方法及用法和 LocalDate、 LocalTime、 LocalDateTime 基本一样
只不过ZonedDate,ZonedTime、ZonedDateTime 这三个带有当前系统的默认时区的时间表示类

那么使用这三个类，就不得不介绍下 ZoneID类：

ZoneID —— 世界时区类：

常用API：

getAvailableZoneIds()：
.获取世界各个地方的时区的集合

systemDefault()：
获取系统默认时区的ID

of(String zoneName):
根据各个地区的时区ID名创建对象

那么，现在，本人就来展示下这几个类的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.*;
import java.util.Set;

public class Test {

    public static void main(String[] args) {
        //ZoneID 世界时区类
        //获取世界各地的时区编号。
        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
        for (String availableZoneId : availableZoneIds) {
            System.out.println(availableZoneId);
        }

        System.out.println("=====================");
        //获取系统的默认时区编号
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);

        //获取其他国家的日期
        LocalDateTime now = LocalDateTime.now();
        //获取指定时区的日期时间
        ZoneId zoneId1 = ZoneId.of("Europe/Monaco");
        ZonedDateTime zonedDateTime = now.atZone(zoneId1);  //获得指定时区的当前时间
        System.out.println(zonedDateTime);

        System.out.println("=====================");
        //根据时区，获取该地区的日期
        LocalDateTime now1 = LocalDateTime.now(ZoneId.of("America/Phoenix"));  //获得指定时区的当前时间（不带时区信息）
        System.out.println(now1);
    }

}

由于世界各地的时区编号太多，所以，本人仅展示最后的几个输出结果：
在这里插入图片描述

posted @ 2020-03-05 11:21 在下右转，有何贵干阅读(3519) 评论(3) 编辑收藏举报

刷新页面返回顶部

在下右转，有何贵干

带你深究Java的本质！

详解 JDK8 新增的日期时间类

JDK8 新增的日期时间类

LocalDate、LocalTime、LocalDateTime类：

获取对象的方法：

常用方法：

与获取相关的方法(get系类的方法)：

格式化日期日期字符串的方法：

转换的方法：

判断的方法：

解析字符串的方法：

增减年月日时分秒的方法（plus/minus系列的方法）：

指定年月日时分秒的方法：

TemporalAdjuster接口 —— 时间校正器：

Instant 时间戳类：

Duration类 —— 用于计算两个“时间”间隔的类：

Period类 —— 用于计算两个“日期”间隔的类：

DateTimeFormatter类 —— 解析和格式化日期或时间的类

ZonedDate、ZonedTime、ZonedDateTime —— 带时区的时间或日期

ZoneID —— 世界时区类：

公告