java8时间类

本博客为b站学习纯手打笔记，加上一些自己的理解补充
学习参考视频：传送门
如果有不足欢迎指出，可以评论区讨论

1、Date

java.util.Date为传统的时间类，很多项目仍然在用，因此需要了解

import java.util.Date;

public class Test1Date {
    public static void main(String[] args) {
        //1、创建Date对象
        Date date = new Date();
        System.out.println(date);  //Wed Nov 09 21:01:22 CST 2022

        //2、拿到时间毫秒值
        long time = date.getTime();
        System.out.println(time);  //1667998882304

        //3、把毫秒值转成日期对象，并把时间延后2s
        time += 2 * 1000;
        Date date1 = new Date(time);
        System.out.println(date1);  //Wed Nov 09 21:01:24 CST 2022

        //4、直接把日期对象的时间通过setTime的方法进行修改
        Date date2 = new Date();
        date2.setTime(time);
        System.out.println(date2);  //Wed Nov 09 21:01:24 CST 2022
    }
}

2、SimpleDateFormat

SimpleDateFormat主要用于时间格式化和解析

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test2SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        //1、初始化Date类和时间戳
        Date d = new Date();
        System.out.println(d);//Wed Nov 09 21:32:26 CST 2022

        long time = d.getTime();
        System.out.println(time);//1668000746653

        //2、格式化日期对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String s = sdf.format(d);
        System.out.println(s);//2022-11-09 21:32:26

        String s2 = sdf.format(time);
        System.out.println(s2);//2022-11-09 21:32:26

        //3、将字符转换成日期对象
        Date d2 = sdf.parse(s);
        System.out.println(d2);//Wed Nov 09 21:32:26 CST 2022
    }
}

3、Calendar

Calendar类使用场景：求9月10号一个月之后的日期

import java.util.Calendar;
import java.util.Date;

public class Test3Calendar {
    public static void main(String[] args) {
        //1、创建Calendar对象
        Calendar now = Calendar.getInstance();
        System.out.println(now);

        //2、获取Calendar对象中某个信息
        int year = now.get(Calendar.YEAR);
        System.out.println(year);//2022

        int days = now.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);//313

        //3、Calendar对象转Date对象
        Date d = now.getTime();
        System.out.println(d);//Wed Nov 09 22:04:50 CST 2022

        //4、Calendar对象转时间戳
        long time = now.getTimeInMillis();
        System.out.println(time);//1668002690428

        //5、修改Calendar对象中某个信息
        now.set(Calendar.MONTH,9);
        now.set(Calendar.DAY_OF_YEAR,125);
        System.out.println(now);

        //6、增加或减少Calendar对象中某个信息
        now.add(Calendar.DAY_OF_YEAR,100);
        now.add(Calendar.DAY_OF_YEAR,-10);
        now.add(Calendar.DAY_OF_YEAR,6);
        now.add(Calendar.HOUR,6);
        System.out.println(now);
    }
}

4、JDK8为什么要新增时间类

主要原因还是之前设计的的不合理，不合理的地方在于：
1、设计不合理，不符合逻辑，例如：

        Date d = new Date();
        System.out.println(d.getYear());//122，但目前是2022年，不合逻辑

        Calendar cal = Calendar.getInstance();
        int year = cal.get(Calendar.YEAR);
        System.out.println(year);//2022，但是我们要记住Calendar.YEAR这个字段的名称

2、都是可变对象，修改之后会丢失原本的信息
3、线程不安全
4、不能精确到纳秒，只能精确到毫秒
jdk8新增的时间类去解决以上的问题

5、LocalDate、LocalTime和LocalDateTime

LocalDate记录年月日

import java.time.LocalDate;

public class Test1_LocalDate {
    public static void main(String[] args) {
        //1、获取LocalDate对象以及其中的信息
        LocalDate ld = LocalDate.now();
        System.out.println(ld);

        int year = ld.getYear();
        System.out.println(year);

        int month = ld.getMonthValue();
        System.out.println(month);

        int day = ld.getDayOfMonth();
        System.out.println(day);

        //2、修改某个信息值，此时返回的是一个新的LocalDate对象
        LocalDate ld2 = ld.withYear(2099);
        System.out.println(ld2);
        System.out.println(ld);

        //3、把某个信息加多少
        LocalDate ld3 = ld.plusDays(3);
        System.out.println(ld3);

        //4、把某个信息减多少
        LocalDate ld4 = ld.minusDays(3);
        System.out.println(ld4);

        //5、指定年月日
        LocalDate ld5 = LocalDate.of(2099,12,12);

        //6、判断两个日期在前在后
        System.out.println(ld4.equals(ld5));
        System.out.println(ld4.isAfter(ld5));
        System.out.println(ld4.isBefore(ld5));
    }
}

LocalTime和LocalDate的api形式基本相同，但不同的是记录的是时分秒信息，因此只能查询修改时分秒信息
LocalDateTime包含LocalTime和LocalDate所有的api，相当于这两个类的组合。同时有LocalDateTime单独的api，包含：

        LocalDateTime ldt = LocalDateTime.now();

        //1、将LocalDateTime对象拆分成LocalTime对象和LocalDate对象
        LocalTime lt = ldt.toLocalTime();
        LocalDate ld = ldt.toLocalDate();

        //2、将LocalTime对象和LocalDate对象合并成LocalDateTime对象
        LocalDateTime ldt1 = LocalDateTime.of(ld,lt);

6、ZoneId和ZoneDateTime

ZoneDateTime已经完全取代了calendar类时区的功能

import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class TestZone {
    public static void main(String[] args) {
        //1、ZoneId常见方法
        //获取系统默认时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);

        //获取java支持的全部时区id
        System.out.println(ZoneId.getAvailableZoneIds());

        //根据zoneId封装成ZoneId对象
        ZoneId zoneId1 = ZoneId.of("Asia/Aden");

        //2、ZoneDateTime带时区的时间
        //获取某个时区的ZonedDateTime对象
        ZonedDateTime zdt = ZonedDateTime.now(zoneId1);
        System.out.println(zdt);

        //获取世界标准时间
        ZonedDateTime now = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now);

        //获取系统默认时区的时间
        ZonedDateTime now1 = ZonedDateTime.now();
        System.out.println(now1);
    }
}

7、Instant对象

Instant对象的用处：
1、代码执行时间，做时间差
2、记录用户操作时间

package test1;

import java.time.Instant;

public class TestInstant {
    public static void main(String[] args) {
        //1、获取Instant对象
        In
            stant now = Instant.now();

        //2、获取秒信息
        long second = now.getEpochSecond();
        System.out.println(second);

        //3、获取纳秒信息
        long nano = now.getNano();
        System.out.println(nano);

        //4、修改Instant对象
        Instant instant = now.plusNanos(111);
    }
}

8、DateTimeFormatter

DateTimeFormatter用于替换SimpleDateFormat，主要是改进了线程安全

package test1;

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

public class TestDateTimeFormatter {
    public static void main(String[] args) {
        //1、创建DateTimeFormat转换器
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        //2、对时间进行格式化
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);

        String res = dateTimeFormatter.format(ldt);
        System.out.println(res);

        //3、另一种格式化方案
        String format = ldt.format(dateTimeFormatter);
        System.out.println(format);

        //4、解析时间
        String s = "2029-12-12 12:00:12";
        LocalDateTime parse = LocalDateTime.parse(s, dateTimeFormatter);
        System.out.println(parse);
    }
}

9、Period和Duration

Period用于计算两个LocalDate对象相差的年月日

import java.time.LocalDate;
import java.time.Period;

public class TestPeriod {
    public static void main(String[] args) {
        //1、创建Period对象
        LocalDate ld1 = LocalDate.of(2029, 10, 11);
        LocalDate ld2= LocalDate.of(2029, 11, 11);
        Period period = Period.between(ld1,ld2);

        //2、获取两个日期相差的年月日
        System.out.println(period.getYears());//0
        System.out.println(period.getMonths());//1
        System.out.println(period.getDays());//0
    }
}

Duration用于计算两个对象相差天，小时，分，秒，纳秒。支持localTime、LocalDateTime和Instant对象

import java.time.Duration;
import java.time.LocalDateTime;

public class TestDuration {
    public static void main(String[] args) {
        //1、得到duration对象
        LocalDateTime ldt1 = LocalDateTime.of(2029,11,11,11,11,11);
        LocalDateTime ldt2 = LocalDateTime.of(2029,12,12,12,12,12);
        Duration duration = Duration.between(ldt1,ldt2);

        //2、获取两个时间对象的间隔信息
        System.out.println(duration.toDays());//31
        System.out.println(duration.toHours());//745
        System.out.println(duration.toMinutes());//44701
    }
}