JDK1.8 新增的日期时间API_getepochsecond-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_62520626/article/details/122034159

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

1.获取对象的方法

方式1通过静态方法 now();
例如:LocalDateTime ldt = LocalDateTime.now();

方式2通过静态方法of()方法参数可以指定年月日时分秒
例如:LocalDateTime of = LocalDateTime.of(2018, 12, 30, 20, 20, 20);

public class MyTest {
    public static void main(String[] args) {
        //之前我们学的时间日期API
        // Data
        // SimpleDateFormat
        // Calendar
        //JDK1.8 之后提供了一套处理时间日期的API 他说线程安全的
        // LocalDate 表示年月日
        // LocalTime  表示时分秒
        //  LocalDateTime 表示年月日时分秒

        //获取对象
        LocalDate now = LocalDate.now(); //获取当前的年月日
        System.out.println(now);

        LocalTime now1 = LocalTime.now();
        System.out.println(now1);

        LocalDateTime now2 = LocalDateTime.now();
        System.out.println(now2);

        System.out.println("============================");
        //指定日期 of()
        LocalDate of = LocalDate.of(2000, 10, 10); //返回的是指定后的日期对象
        System.out.println(of);

        LocalTime of1 = LocalTime.of(14, 20, 30);
        System.out.println(of1);

        LocalDateTime of2 = LocalDateTime.of(2010, 10, 20, 14, 30, 30);
        System.out.println(of2);
    }
}

2.与获取相关的方法:get系类的方法

ldt.getYear();获取年
       ldt.getMinute();获取分钟
       ldt.getHour();获取小时
       getDayOfMonth 获得月份天数(1-31)
       getDayOfYear 获得年份天数(1-366)
       getDayOfWeek 获得星期几(返回一个 DayOfWeek枚举值)
       getMonth 获得月份, 返回一个 Month 枚举值
       getMonthValue 获得月份(1-12)
       getYear 获得年份

public class MyTest2 {
    public static void main(String[] args) {
        //有关与获取的方法 getXXX
        LocalDateTime now = LocalDateTime.now();
        int year = now.getYear();
        //返回的是枚举
        Month month = now.getMonth();
        int monthValue = now.getMonthValue(); //月份从1开始数
        int dayOfMonth = now.getDayOfMonth();
        //返回的星期也是枚举
        DayOfWeek dayOfWeek = now.getDayOfWeek();
        int dayOfYear = now.getDayOfYear();
        int hour = now.getHour();
        int minute = now.getMinute();
        int second = now.getSecond();
        System.out.println(year);
        System.out.println(month); //DECEMBER 枚举项的名称
        System.out.println(monthValue);
        System.out.println(dayOfMonth);
        System.out.println(dayOfWeek); //FRIDAY 枚举项的名称
        System.out.println(hour);
        System.out.println(minute);
        System.out.println(second);

    }
}

3.格式化日期日期字符串的方法 format()

String yyyy = ldt.format(DateTimeFormatter.ofPattern("yyyy"));

public class MyTest3 {
    public static void main(String[] args) {
        // 2. 格式化日期日期字符串的方法 format ()
        // 例如:
        // String yyyy = ldt.format(DateTimeFormatter.ofPattern("yyyy"));
        LocalDate now = LocalDate.now();
        System.out.println(now.toString()); // 2021-12-17 默认格式

        //JDK1.8 格式化日期的类 DateTimeFormatter
        //指定格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        String dateStr = now.format(formatter);

        System.out.println(dateStr);

        System.out.println("===========================");

        LocalDateTime now1 = LocalDateTime.now();
        System.out.println(now1.toString()); //默认格式 2021-12-17T09:24:32.713


        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH点mm分ss秒");
        //把日期对象，格式化成日期字符串
        String str = now1.format(formatter2);

        System.out.println(str);

    }
}

4.转换的方法 toLocalDate();toLocalTime();

LocalDate localDate = ldt.toLocalDate();
LocalTime localTime = ldt.toLocalTime();

public class MyTest4 {
    public static void main(String[] args) {
        //有关转换的方法
        LocalDateTime now = LocalDateTime.now(); //年月日 时分秒
        System.out.println(now);
        LocalDate localDate = now.toLocalDate();
        System.out.println(localDate);
        LocalTime localTime = now.toLocalTime();
        System.out.println(localTime);

    }
}

5.判断的方法

isAfter()判断一个日期是否在指定日期之后
       isBefore()判断一个日期是否在指定日期之前
       isEqual(); 判断两个日期是否相同
       isLeapYear()判断是否是闰年注意是LocalDate类中的方法

boolean after = ldt.isAfter(LocalDateTime.of(2024, 1, 1, 2, 3));
boolean b= LocalDate.now().isLeapYear();

public class MyTest5 {
    public static void main(String[] args) {
        //有关判断的方法
        // isAfter() 判断一个日期是否在指定日期之后
        // isBefore() 判断一个日期是否在指定日期之前
        // isEqual();
        // 判断两个日期是否相同
        // isLeapYear() 判断是否是闰年注意是LocalDate类中的方法
        LocalDate now = LocalDate.now();
        LocalDate of = LocalDate.of(2000, 12, 12);

        boolean after = now.isAfter(of);
        System.out.println(after);
        boolean before = of.isBefore(now);
        System.out.println(before);

        boolean equal = now.isEqual(of);
        System.out.println(equal);

        boolean equal1 = of.isEqual(of);
        System.out.println(equal1);

        //判断是不是闰年
        boolean leapYear = now.isLeapYear();
        System.out.println(leapYear);

    }
}

6.解析的静态方法parse("2007-12-03T10:15:30");

paser() 将一个日期字符串解析成日期对象,注意字符串日期的写法的格式要正确,否则解析失败
           例如:LocalDateTime parse = LocalDateTime.parse("2007-12-03T10:15:30");

按照我们指定的格式去解析:

注意细节:如果用LocalDateTime 想按照我们的自定义的格式去解析,注意
日期字符串的年月日时分秒要写全,不然就报错
           LocalDateTime ldt4 = LocalDateTime.now();
           DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
           LocalDateTime.parse("2018-01-21 20:30:36", formatter2);

public class MyTest {
    public static void main(String[] args) {
        //解析的静态方法parse("2007-12-03T10:15:30");
        //把一个日期字符串解析成日期对象

        String dateStr = "2007-12-03";
        LocalDate parse = LocalDate.parse(dateStr); //按照默认格式来解析
        System.out.println(parse);


        String dateStr2 = "2007年12月03日";
        //按照指定格式来解析
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        LocalDate parse2 = LocalDate.parse(dateStr2, formatter); //
        System.out.println(parse2);

        System.out.println("======================");
        String dateStr3 = "2021年10月05日 14点20分30秒";
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH点mm分ss秒");
        LocalDateTime parse1 = LocalDateTime.parse(dateStr3, formatter2);
        System.out.println(parse1);

    }
}

7.添加年月日时分秒的方法 plus系列的方法都会返回一个新的LocalDateTime的对象
,减去年月日时分秒的方法 minus 系列的方法注意都会返回一个新的LocalDateTime的对象

LocalDateTime localDateTime = ldt.plusYears(1);
LocalDateTime localDateTime1 = ldt.plusMonths(3);
LocalDateTime localDateTime2=ldt.plusHours(10);
LocalDateTime localDateTime2 = ldt.minusYears(8);

public class MyTest {
    public static void main(String[] args) {
        //6.添加年月日时分秒的方法 plusXXX系列的方法 都会返回一个新的LocalDateTime的对象

        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        //注意：调用 plusXXX系列的方法 都会返回一个新的LocalDateTime的对象
        LocalDateTime localDateTime = now.plusYears(2);
        System.out.println(localDateTime);

        System.out.println("==================================");

        //7.减去年月日时分秒的方法 minusXXX 系列的方法 注意都会返回一个新的LocalDateTime的对象
        LocalDateTime localDateTime1 = now.minusYears(3);
        System.out.println(localDateTime1);
    }
}

8.指定年月日时分秒的方法 with系列的方法注意都会返回一个新的LocalDateTime的对象

LocalDateTime localDateTime3 = ldt.withYear(1998);
//获取这个月的第几个星期几是几号,比如 TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY) 代表的意思是这个月的第二个星期五是几号
// TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY)
LocalDateTime with1 =now.with(TemporalAdjusters.dayOfWeekInMonth(2,DayOfWeek.FRIDAY));

public class MyTest2 {
    public static void main(String[] args) {
        // 8. 指定年月日时分秒的方法 with系列的方法 注意都会返回一个新的LocalDateTime的对象

        LocalDate now = LocalDate.now();
        //LocalDateTime.of()
        //LocalDate localDate = now.withYear(2000);
        //System.out.println(localDate);
        //TemporalAdjuster 接口
        TemporalAdjuster temporalAdjuster = TemporalAdjusters.next(DayOfWeek.FRIDAY);

        TemporalAdjuster previous = TemporalAdjusters.previous(DayOfWeek.MONDAY);
        TemporalAdjuster temporalAdjuster1 = TemporalAdjusters.lastDayOfMonth();
        LocalDate with = now.with(temporalAdjuster1);
        System.out.println(with);
    }
}

Instant 时间戳类从1970-01-01 00:00:00 截止到当前时间的毫秒值

1获取对象的方法 now()
   注意默认获取出来的是当前的美国时间和我们相差八个小时
       Instant ins = Instant.now();
       System.out.println(ins);
       我们在东八区所以可以加8个小时就是我们的北京时间
2. Instant中设置偏移量的方法:atOffset() 设置偏移量
       OffsetDateTime time = ins.atOffset(ZoneOffset.ofHours(8));
       System.out.println(time);
3.获取系统默认时区时间的方法atZone()
   方法的参数是要一个时区的编号可以通过时区编号类获取出来
       ZoneId.systemDefault()获取本地的默认时区ID
       ZonedDateTime zonedDateTime = ins.atZone(ZoneId.systemDefault());
       System.out.println(zonedDateTime);
4.get系列的方法

   getEpochSecond() 获取从1970-01-01 00:00:00到当前时间的秒值
   toEpochMilli();获取从1970-01-01 00:00:00到当前时间的毫秒值
   getNano()方法是把获取到的当前时间的秒数换算成纳秒
   long epochSecond = ins.getEpochSecond();//获取从1970-01-01 00:00:00到当前时间的秒值
   getNano()方法是把获取到的当前时间的豪秒数换算成纳秒比如当前时间是2018-01-01 14:00:20:30
   那就把30豪秒换算成纳秒 int nano = ins.getNano();
5. ofEpochSecond()方法给计算机元年增加秒数
   ofEpochMilli() 给计算机元年增加毫秒数
   例如 Instant instant = Instant.ofEpochSecond(5);
       System.out.println(instant);
       单位换算
       0.1 毫秒 = 10 的5次方纳秒 = 100000 纳秒
        1 毫秒 = 1000 微妙 = 1000000 纳秒

public class MyTest {
    public static void main(String[] args) {
        // Instant 时间戳类从1970 -01 - 01 00:00:00 截止到当前时间的毫秒值
        Instant now = Instant.now();
        System.out.println(now.toString());
        //设置时间的偏移量
        OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);
        //设置时区
        ZonedDateTime zonedDateTime = now.atZone(ZoneId.systemDefault());
        System.out.println(zonedDateTime);

        System.out.println("==========================");
        Instant now2 = Instant.now();
        //获取970 -01 - 01 00:00:00 截止到当前时间的毫秒值
        long l = now2.toEpochMilli();
        //970 -01 - 01 00:00:00 截止到当前时间的秒值
        long epochSecond = now2.getEpochSecond();
        System.out.println(l / 1000);
        System.out.println(epochSecond);


        System.out.println("===============================");

        //给计算机元年添加相应的毫秒值
        Instant instant = Instant.ofEpochMilli(1000 * 60 * 60 * 24);
        System.out.println(instant);
        //给计算机元年添加相应的秒值
        Instant instant2 = Instant.ofEpochSecond(60 * 60 * 24 * 2);
        System.out.println(instant2);
    }
}

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

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

Duration类中静态方法between()
   Instant start = Instant.now();
       for(int i=0;i<1000L;i++){
           System.out.println("循环内容");
       }
   Instant end = Instant.now();
   静态方法:between() 计算两个时间的间隔,默认是秒
   Duration between = Durati’on.between(start, end);
   Duration中的toMillis()方法:将秒转成毫秒
   System.out.println(between.toMillis());

Period类中的静态方法between()
   计算两个日期之间的间隔
   LocalDate s = LocalDate.of(1985, 03, 05);
   LocalDate now = LocalDate.now();
   Period be = Period.between(s, now);
   System.out.println(be.getYears());间隔了多少年
   System.out.println(be.getMonths());间隔了多少月
   System.out.println(be.getDays());间隔多少天

Duration:

public class MyTest2 {
    public static void main(String[] args) {
        //记录一下开始的时间戳
        Instant now = Instant.now();
        for (int i = 0; i < 5000; i++) {
            System.out.println(i);
        }
        //记录一下结束的时间戳
        Instant end = Instant.now();

        //Duration:用于计算两个"时间”间隔的类
        Duration between = Duration.between(now, end);
        //long seconds = between.getSeconds(); //间隔的秒值
        long l = between.toMillis();
        System.out.println("耗时：" + l + "毫秒");
        //long l1 = between.toDays();
        //long l2 = between.toMinutes();
    }
}

Period:

public class MyTest3 {
    public static void main(String[] args) {
        LocalDate birthday = LocalDate.of(1985, 3, 20);
        LocalDate now = LocalDate.now();
        //Period:用于计算两个“日期”间隔的类
        Period between = Period.between(birthday, now);
        int years = between.getYears();
        int months = between.getMonths();
        int days = between.getDays();
        System.out.println(years);
        System.out.println(months);
        System.out.println(days);
    }
}

TemporalAdjuster : 时间校正器,是个接口

一般我们用该接口的一个对应的工具类 TemporalAdjusters中的一些常量,来指定日期

LocalDate now = LocalDate.now();
System.out.println(now);
1 使用TemporalAdjusters自带的常量来设置日期
   LocalDate with = now.with(TemporalAdjusters.lastDayOfYear());
   System.out.println(with);
2 采用TemporalAdjusters中的next方法来指定日期
   LocalDate date = now.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
   System.out.println(date);
   例如:TemporalAdjusters.next(DayOfWeek.SUNDAY) 本周的星期天
   例如:TemporalAdjusters.nextOrSame(DayOfWeek.MONDAY) 下一周的星期一
3 采用自定义的方式来指定日期比如指定下个工作日
   LocalDateTime ldt = LocalDateTime.now();
   LocalDateTime workDay = ldt.with(new TemporalAdjuster() {
       @Override
   public Temporal adjustInto(Temporal temporal) {
       //向下转型
       LocalDateTime ld = (LocalDateTime) temporal;
       //获取这周的星期几
       DayOfWeek dayOfWeek = ld.getDayOfWeek();
   if (dayOfWeek.equals(DayOfWeek.FRIDAY)) {
           return ld.plusDays(3);//如果这天是星期五,那下个工做日就加3天
       } else if (dayOfWeek.equals(DayOfWeek.SATURDAY)) {
           return ld.plusDays(2);//如果这天是星期六,那下个工做日就加2天
       } else {
           //其他就加一天
           return ld.plusDays(1);
   }
}
});

System.out.println(workDay);

public class MyTest2 {
    public static void main(String[] args) {
        //TemporalAdjusters 这个工具类中提供的方法，不可能满足我们所有的要求，比如我想知道下个工作日是几号
        //那我们就得按照自己的方式来实现 TemporalAdjuster 接口
        LocalDate now = LocalDate.now();
        //我要获取下个工作日的日期
        //如果当前是星期五 下个工作日 加3天
        //如果当前是星期六 下个工作日 加2天
        //如果是其他星期 下个工作日 加1天

        LocalDate date = now.with(new TemporalAdjuster() {
            @Override
            public Temporal adjustInto(Temporal temporal) {
                //传过来的这个参数，就是当前的日期
                LocalDate mydate = (LocalDate) temporal;
                //获取当前的星期
                DayOfWeek dayOfWeek = mydate.getDayOfWeek();
                if (dayOfWeek.equals(DayOfWeek.FRIDAY)) {
                    return mydate.plusDays(3);
                } else if (dayOfWeek.equals(DayOfWeek.SATURDAY)) {
                    return mydate.plusDays(2);
                } else {
                    return mydate.plusDays(1);
                }
            }
        });

        System.out.println(date);

    }
}

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

1.获取对象的方式,通过静态方法ofPattern("yyyy-MM-dd");
   DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd");
   LocalDateTime now = LocalDateTime.now();
2.format()方法把一个日期对象的默认格式格式化成指定的格式
   String format1 = dateFormat.format(now);
   System.out.println(format1);
3.格式化日期方式2使用日期类中的format方法传入一个日期格式化类对象

   LocalDateTime now1 = LocalDateTime.now();
   使用日期类中的format方法传入一个日期格式化类对象
   使用DateTimeFormatter中提供好的日期格式常量
   now1.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
4.使用自定义的日期格式格式化字符串
   DateTimeFormatter timeFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");//自定义一个日期格式
   String time = now1.format(timeFormat);
   System.out.println(time);

5. 把一个日期字符串转成日期对象
   使用日期类中的parse方法传入一个日期字符串,传入对应的日期格式化类
   DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd");
   LocalDateTime parse = LocalDateTime.parse(time, timeFormat);
   System.out.println(parse);

public class MyTest {
    public static void main(String[] args) {
        // DateTimeFormatter:解析和格式化日期或时间的类
        //指定日期格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        LocalDateTime now = LocalDateTime.now();
        //格式化日期方式1：

        String format = now.format(formatter);
        System.out.println(format);

        //方式2：
        String format1 = formatter.format(now);
        System.out.println(format1);

    }
}

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

用法和 LocalDate、 LocalTime、 LocalDateTime 一样只不过ZonedDate,ZonedTime、ZonedDateTime 这三个带有当前系统的默认时区

ZoneID 世界时区类

1.获取世界各个地方的时区的集合的方法getAvailableZoneIds()
使用ZoneID中的静态方法getAvailableZoneIds();来获取 ?
例如:Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();

2.获取系统默认时区的ID
ZoneId zoneId = ZoneId.systemDefault(); //Asia/Shanghai

3.获取带有时区的日期时间对象
//创建日期对象
LocalDateTime now = LocalDateTime.now();
//获取不同国家的日期时间根据各个地区的时区ID名创建对象
ZoneId timeID = ZoneId.of("Asia/Shanghai");
//根据时区ID获取带有时区的日期时间对象
ZonedDateTime time = now.atZone(timeID);
System.out.println(time);
//方式2 通过时区ID 获取日期对象
LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
System.out.println(now2);

public class MyTest2 {
    public static void main(String[] args) {

        // LocalDate 表示年月日
        // LocalTime  表示时分秒
        //  LocalDateTime 表示年月日时分秒


        //：带时区的时间或日期
        //ZonedDate, 年月日
        //ZonedTime、 时分秒
        //ZonedDateTime  年月日时分秒
        ZonedDateTime now = ZonedDateTime.now();
        //System.out.println(now);

        //  ZoneId 时区类
        ZoneId zoneId = ZoneId.systemDefault(); //获取系统的默认时区
        //System.out.println(zoneId); //Asia / Shanghai
        //获取世界所有时区id
        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
        for (String availableZoneId : availableZoneIds) {
            if (availableZoneId.startsWith("E")) {
                System.out.println(availableZoneId);
            }
        }


        //获取美国某个地方的日期，需要传入时区id
        // LocalDateTime now1 = LocalDateTime.now(zoneId);
        //System.out.println(now1);
        ZoneId of = ZoneId.of("Europe/Berlin");
        LocalDateTime now1 = LocalDateTime.now(of);
        System.out.println(now1);

        //2021-12-17T04:18:32.197
    }
}