关于Java新增时间

一:LocalDate

1.代表本地日期( 年，月，日，星期)

2.LocalDate的常用API（都是处理年，月，日，星期相关的）

getYear() 获取年

getMonthValue() 获取月份

getDayOfYear() 获取当前是一年中的第几天

getDayOfWeek() 获取周几

getDayOfWeek().getValue() 获取星期几

withYear，withMonth，withDayofMonth，withDayOfyear 直接修改某个信息，返回新日期对象

plusYears，plusMonths，plusDays，plusWeeks 把某个信息加多少，返回新日期对象

minusYears，minusMonths，MinusDays，minusWeeks 把某个信息减多少，返回新日期对象

public static LocalDate of(int year, int month, int DayOfMonth) 获取指定的LocalDate对象

equal isBefore isAfter 判断两个日期对象，是否相等，在前还是在后

3.示例：

import java.time.LocalDate;

public class LocalDateTest {
    public static void main(String[] args) {
        //0.获取本地日期对象
        LocalDate ld1 = LocalDate.now();
        System.out.println(ld1);
        //1.获取日期对象中的信息
        ld1.getYear();
        ld1.getMonthValue();//获取月份（1-12）
        ld1.getDayOfYear();//获取当前是一年中的第一天
        ld1.getDayOfWeek();//获取周几
        ld1.getDayOfWeek().getValue();//获取星期几

        //2.直接修改某个信息，返回新日期对象
        LocalDate ld2 = ld1.withMonth(10);
        LocalDate ld3 = ld1.withYear(1989);
        LocalDate ld4 = ld1.withDayOfMonth(3);
        LocalDate ld5 = ld1.withDayOfYear(43);

        //3.把某个信息加多少，返回新的日期对象
        LocalDate ld6 = ld1.plusDays(5);

        //4.把某个信息减多少，返回新的日期对象
        LocalDate ld7 = ld1.minusMonths(3);

        //5.获取指定的LocalDate对象:public static LocalDate of(int year, int month, int DayOfMonth);
        LocalDate ld8 = LocalDate.of(2077, 9, 17);

        //6.判断两个日期对象，是否相等，在前还是在后
        ld1.equals(ld2);//false
        ld1.isAfter(ld3);//true
        ld1.isBefore(ld6);//true
    }
}

二:LocalTime

1.代表本地时间（时，分，秒，纳秒）

2.LocalTime的常用API（都是处理是，分，秒，纳秒相关的）。

getHour() 获取获取小时

getMinute() 获取分

getSecond() 获取秒

getNano() 获取纳秒

WithHour，WithMinute，WithSecond，WithNano 修改时间，返回新时间对象

plusHours，plusMinute，plusSeconds，plusNanos 把某个信息加多少，返回新时间对象

minusHours，minusMinute，minusSeconds，minusNanos 把某个信息减多少，返回新时间对象

public static Localtime.of(int hour,int minute,int second) 获取指定的LocalTime对象

equal isBefore isAfter 判断两个时间对象，是否相等，在前还是在后

3.示例：

import java.time.LocalTime;

public class LocalTimeTest {
    public static void main(String[] args) {
        //0.获取本地日期和时间对象
        LocalTime lt1 = LocalTime.now();
        System.out.println(lt1);

        //1.获取日期对象中的信息
        lt1.getHour();//获取小时
        lt1.getMinute();//获取分
        lt1.getSecond();//获取秒
        lt1.getNano();//获取纳秒

        //2.修改时间，返回新时间对象
        LocalTime lt2 = lt1.withHour(4);
        LocalTime lt3 = lt1.withMinute(5);
        LocalTime lt4 = lt1.withNano(323);
        LocalTime lt5 = lt1.withSecond(54);

        //3.把某个信息加多少，返回新时间对象
        lt1.plusHours(5);

        //4.把某个信息减多少,返回新时间对象
        lt1.minusMinutes(55);

        //5.获取指定的LocalTime对象:public static Localtime.of(int hour,int minute,int second)
        LocalTime lt6 = LocalTime.of(6, 53, 35);

        //6.判断两个时间对象，是否相等，在前还是在后
        lt1.equals(lt2);
        lt1.isAfter(lt4);
        lt1.isBefore(lt3);

    }
}

三:LocalDateTime

1.代表本地日期，时间（年，月，日，星期，时，分，秒，纳秒）

2.LocalDateTime常用的API（都是处理年，月，日，星期，时，分，秒，纳秒等信息）

getYear，getMonthValue，getDayOfYear，getDayOfMonth，getDayOfWeek，getHour，getSecond，getMinute，getNano 获取年月日，时分秒，纳秒等

withYear，withMonth，withDayOfMonth，withDayOfYear，withHour，withMinute，withSecond，withNano 修改某个信息，返回新日期时间对象

plusYears，plusMonths，plusDays，plusWeeks，plusHours，plusMinutes，plusSeconds，plusNanos 把某个信息加多少，返回新日期时间对象。

minusYears，minusSeconds，minusMonths，minusWeeks，minusHours，minusMinutes，minusNanos，minusSeconds 把某个信息减多少，返回新日期时间对象

equals isBefore isAfter 判断两个时间对象，是否相等，在前还是在后

toLocalDateTime() 可将LocalDateTime转换成LocalDate和LocalTime

LocalDateTime.of(LocalDate,LocalTime) 可将LocalDate和LocalTime转化LocalDateTime

3.示例：

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

public class LocalDateTimeTest {
    public static void main(String[] args) {
        //0.获取本地时间和日期对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);

        //1.可以获取日期或时间的全部信息
        ldt.getHour();//获取小时
        ldt.getMinute();//获取分钟
        ldt.getMonthValue();//获取月份
        ldt.getYear();//获取年
        ldt.getDayOfYear();//获取一年中的第一天
        ldt.getDayOfMonth();//获取日
        ldt.getDayOfWeek();//获取周几
        ldt.getSecond();//获取秒
        ldt.getNano();//获取毫秒

        //2.修改时间信息
        ldt.withMinute(12);//修改分钟
        ldt.withMonth(6);//修改月份

        //3.加多少
        ldt.plusYears(4);//加四年
        ldt.plusSeconds(5);//加五秒

        //4.减多少
        ldt.minusDays(8);//减八天
        ldt.minusNanos(100);//加一百毫秒

        //5.获取指定的LocalDateTime对象:
        // public static LocalDateTime of(int year, int month, int DayOfMonth, int hour, int minute, int second, int nanoOfSecond)
        LocalDateTime ldt2 = LocalDateTime.of(2077, 10, 9, 5, 32, 21, 43435);

        //6.判断两个时间对象，是否相等，在前还是在后
        ldt.equals(ldt2);
        ldt.isAfter(ldt2);
        ldt.isAfter(ldt2);

        //7.将LocalDateTime转换成LocalDate和LocalTime
        LocalDate ld = ldt.toLocalDate();
        LocalTime lt = ldt.toLocalTime();

        //8.将LocalDate和LocalTime转化为LocalDateTime
        LocalDateTime ldt3 = LocalDateTime.of(ld,lt);

    }
}

四:ZoneId

1.时区：由于各个国家与地区的经度不同，各地区的时间也有所不同，因此会划分为不同的时区。世界标准时间(UTC) 中国标准时间：世界标准时间(UTC) + 8小时

2.方法

ZoneId的常见方法：

systemDefault() 获取默认的时区

getAvailableZoneIds() 获取Java支持的全部时区Id

of(String zoneId) 把某个时区id封装为ZoneId对象

ZonedDateTime的常见方法：

now(ZoneId zone) 获取某个时区的ZonedDateTime对象

now() 获取系统默认时区的ZonedDateTime对象

3.示例：

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

public class ZoneIdTest {
    public static void main(String[] args) {
        //1.获取系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId.getId());
        System.out.println(zoneId);

        //2.获取Java支持的全部时区Id
        System.out.println(ZoneId.getAvailableZoneIds());

        //3.把某个时区的Id封装成ZoneId对象
        ZoneId zoneId1 = ZoneId.of("America/Cuiaba");

        //4.ZonedDateTime:带时区的时间
        //public static  ZonedDateTime now(ZoneId zone):获取某个时区的ZonedDateTime对象
        ZonedDateTime zonedDateTime1 = ZonedDateTime.now(zoneId1);
        System.out.println(zonedDateTime1);

        //5.public static ZonedDatetime now(): 获取系统默认时区的ZonedDateTime对象
        ZonedDateTime zonedDateTime2 = ZonedDateTime.now();
        System.out.println(zonedDateTime2);
    }
}

五:Instant

1.时间线上的某个时刻/时间戳

通过获取Instant的对象可以拿到此刻的时间，该时间由两部分组成：从1970-01-01 00:00:00 开始走到此刻的总秒数+不够一秒的纳秒数

2.方法

now() 创建当前时间的Instant对象(标准时间)获取时间信息

getEpochSecond() 获取从1970-01-01T00:00:00开始记录的秒数

getNano() 从时间线开始，获取从第二个开始的纳秒数(不够一秒的纳秒数)

plusMillis，plusSeconds，plusNanos 增加时间系列的方法

minusMillis，minusSeconds，minusNanos 减少时间系列的方法

equals isAfter isBefore 判断系列的方法

3.示例：

import java.time.Instant;

public class InstantTest {
    public static void main(String[] args) {
        //1.创建当前时间的Instant对象(标准时间)获取时间信息
        Instant now = Instant.now();
        System.out.println(now);

        //2.获取从1970-01-01T00:00:00开始记录的秒数
        long Second = now.getEpochSecond();
        System.out.println(Second);

        //3.从时间线开始，获取从第二个开始的纳秒数(不够一秒的纳秒数)
        int Nano = now.getNano();
        System.out.println(Nano);

        //4.增加/减少/判断时间系列的方法
        Instant now2 = now.plusMillis(10);
        Instant now3 = now.minusNanos(23);
        now.equals(now2);
        now.isBefore(now3);

    }
}

4.作用：可以用来记录代码的执行时间，或用于记录用户操作某个事件的时间点

5.传统的Date类，只能精确到毫秒，并且是可变对象

6.新增的Instan类，可以精确的纳秒，并且是不可变对象，推荐用Instant代替Date

六:DateTimeFormatter

1.格式化器，用于时间的格式化和解析(线程安全)。

2.方法

DateTimeFormatter:

ofPattern(时间格式) 获取格式化对象

format(时间对象) 格式化时间

LocalDateTime提供的格式化，解析时间的方法:

format(DateTimeFormatter formatter) 格式化时间

parse(CharSequence text, DateTimeFormatter formatter) 解析时间

3.示例：

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

public class DateTimeFormatterTest {
    public static void main(String[] args) {
        //1.创建一个时间格式化器对象出来
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        //2.对时间进行格式化
        LocalDateTime now = LocalDateTime.now();
        String rs1 = formatter.format(now);
        System.out.println(rs1);

        //3.格式化时间的另一种方式
        String rs2 = now.format(formatter);
        System.out.println(rs2);

        //4.解析时间:一般使用LocalDateTime提供的解析方法来解决
        String rs3 = "2005年10月07日 19:56:32";
        LocalDateTime parse = LocalDateTime.parse(rs3, formatter);
        System.out.println(parse);
    }
}

七:Period：计算日期间隔(年，月，日)

1.可以用于计算两个LocalDate对象相差的年数，月数，天数。

2.方法

between(LocalDate start, LocalDate end) 传入两个日期对象，得到Period对象

getYears() 计算间隔几年，并返回

getMonths() 计算间隔个几月，并返回

getDays() 计算间隔几天，并返回

3.示例：

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

public class PeriodTest {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(1985, 3, 19);
        LocalDate end = LocalDate.of(2005, 10, 7);

        //1.创建Period对象，封装两个日期
        Period period = Period.between(start, end);

        //2.通过Period对象获取两个日期对象相差的信息
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());

    }
}

八:Durtion：计算时间间隔（时，分，秒，纳秒）

1.可用于计算两个时间对象相差的天数，小时数，分数，秒数，纳秒数；支持LocalTime，LocalDateTime，Intant等时间。

2.方法

between(开始时间对象1,结束时间对象2) 传入两个时间对象，得到Duration对象

toDays() 计算间隔多少天，并返回

toHours() 计算间隔多少小时，并返回

toMinutes() 计算间隔多少分钟，并返回

toMillis() 计算间隔多少毫秒，并返回

toNanos() 计算间隔多少纳秒，并返回

getSeconds() 计算间隔多少秒，并返回

3.示例：

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

public class DurationTest {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2077, 11, 11, 11, 11, 11, 11);
        LocalDateTime end = LocalDateTime.of(2099, 12, 12, 12, 12, 12, 12);

        //1.得到Duration对象
        Duration duration = Duration.between(start, end);

        //2.通过Duration获得两个日期对象相差的信息
        System.out.println(duration.toDays());
        System.out.println(duration.getSeconds());
        System.out.println(duration.toHours());
    }