java .time包 是基于Joda-Time库构建，是一种免费的开源组件,处理日期尽量使用该包下面相关类

import java.time.*;

该包下的所有类都是final修饰,所以所有的类对象不能通过new实例化，所以它是线程安全的,获取当前系统时间：

 public static LocalDateTime now() {
    Clock clock = Clock.systemDefaultZone();
    Objects.requireNonNull(clock, "clock");
    final Instant now = clock.instant();  // called once
    ZoneOffset offset = clock.getZone().getRules().getOffset(now);
    Objects.requireNonNull(offset, "offset");
    NANO_OF_SECOND.checkValidValue(nanoOfSecond);
    long localSecond = epochSecond + offset.getTotalSeconds();  // overflow caught later
    long localEpochDay = Math.floorDiv(localSecond, SECONDS_PER_DAY);
    int secsOfDay = (int)Math.floorMod(localSecond, SECONDS_PER_DAY);
    LocalDate date = LocalDate.ofEpochDay(localEpochDay);
    LocalTime time = LocalTime.ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + nanoOfSecond);
    return new LocalDateTime(date, time);
}  

2.1.LocalDate类

LoacalDate类是一个不可变的 日期 对象，表示格式年月日（YYYY-MM-DD HH:mm:ss.nas+偏移量[时区]）

 /**
* 日期类 LocalDate: 获取 年 月 日
*/
log.debug("日期类:package: java.time.LocalDate-----------------------------");
//获取本地日期  2021-06-10
LocalDate ld = LocalDate.now();
log.debug("获取本地日期:{}",ld);
//年份2021
int year = ld.getYear();
//月分
Month month = ld.getMonth();
//一年中的第几天
int dayOfYear = ld.getDayOfYear();
//一年中的第几个月
int dayOfMonth = ld.getDayOfMonth();
//一年中的第几周
DayOfWeek dayOfWeek = ld.getDayOfWeek();
log.debug("日期类:java.time.LocalDate: n" +
    "年份:{}，n" +
    "月份:{}-{}，n" +
    "当前时间一年中的第几天：{}，n" +
    "一年中的第几个月:{}，n" +
    "星期(?)：{}-{}n",
    year,
    month, month.getValue(),
    dayOfYear,
    dayOfMonth,
    dayOfWeek,dayOfWeek.getValue()
);
//日期类:java.time.LocalDate: 
//当前日期：2021-06-10,
//年份:2021，
//月份:JUNE-6，
//当前时间一年中的第几天：161，
//一年中的第几个月:10，
//星期(?)：THURSDAY-4  

2.2.LocalDateTime类

LoacalDateTime类是一个不可变的 日期时间 对象，表示格式年-月-日 时-分-秒（YYYY-MM-DD HH:mm:ss）

 log.debug("日期时间类:java.time.LocalDateTime-----------------------------");
//获取本地当前时间  2021-06-10T22:12:58.250
LocalDateTime ldt = LocalDateTime.now();
log.debug("日期时间类:{}",ldt);
//年份
int year1 = ldt.getYear();
//月分
Month month1 = ldt.getMonth();
//一年中的第几天
int dayOfYearT = ldt.getDayOfYear();
//一年中的第几个月
int dayOfMonthT = ldt.getDayOfMonth();
//当前是周几
DayOfWeek dayOfWeekT = ldt.getDayOfWeek();
//时
int  hour  = ldt.getHour();
//分钟
int  Minute  = ldt.getMinute();
//秒
int second = ldt.getSecond();
log.debug("日期类java.time.LocalDateTime: n" +
                "当前日期：{},n" +
                "年份:{}，n" +
                "月份:{}-{}，n" +
                "当前时间一年中的第几天：{}，n" +
                "一年中的第几个月:{}，n" +
                "星期(?)：{}-{},n" +
                "当前时间：{}，n" +
                "当前分钟: {}，n" +
                "当前秒: {}n",
        ldt,
        year1,
        month1,month1.getValue(),
        dayOfYearT,
        dayOfMonthT,
        dayOfWeekT,dayOfWeekT.getValue(),
        hour,
        minute,
        second
);
//当前日期：2021-06-10T22:40:00.060,
//年份:2021，
//月份:JUNE-6，
//当前时间一年中的第几天：161，
//一年中的第几个月:10，
//星期(?)：THURSDAY-4,
//当前时间：22，
//当前分钟: 40，
//当前秒: 0  

2.3.LoacalTime类

LoacalTime类是一个不可变的 日期时间 对象，代表一个时间，表示格式时-分-秒（HH:mm:ss）

 log.debug("时间类:java.time.LocalTime-----------------------------");
 LocalTime  now = LocalTime.now();//时间13:58:22.826
LocalTime of = LocalTime.of(23, 24, 24);//指定时间23:24:24
LocalTime ptr = LocalTime.parse("11:15:30");
log.debug(now + "    "+of+"    "+ptr);
log.debug("n当前时间：{}，n" +
                "指定时间：{}，n" +
                "解析时间字符串：{}n",
        now,
        of,
        ptr
);
//当前时间：22:47:56.277，
//指定时间：23:24:24，
//解析时间字符串：11:15:30  

2.4. Instant 类

Instant类对时间轴上的单一瞬时点建模，可以作为时间戳，与System.currentTimeMillis()类似。但Instant可以精确到 纳秒 （Nano-Second）。

Instant除了可以使用now()方法创建，还可以通过ofEpochSecond方法创建。

 *  - 秒:单位s（second）  60s=1分钟
*  - 毫秒：单位ms(milliseconds) 1毫秒等于千分之一秒 （1000ms= 1秒）
*  -  微秒 ，单位μs（英语：microsecond ）.1微秒等于一百万分之一秒
*  - 纳秒：单位ns(nanoseconds) 一纳秒的10亿分之一秒
理解一个关联概念，最近芯片工艺最新量产5nm,到底有多大?
*   芯片工艺：
*  - 1米(m)=1000毫米(mm)
*  - 1毫米(mm)=1000微米(um)
*  - 1微米(um)=1000纳米(nm)
*  - 1毫米，1000微米，1,000,000纳米。  

跑题了，说回正题，一纳秒能干什么也（十亿分之一秒），光在真空中一纳秒仅传播30厘米（不足一个步长）。个人电脑的微处理器执行一道指令（如将两数相加）约需2至4纳秒

 long cMillis = System.currentTimeMillis();
log.debug("当前时间：{}/milliseconds（毫秒）",cMillis);
//从系统时钟获取当前时刻
Instant now = Instant.now();
log.debug("当前时间：{}/nanoseconds（纳秒）",now);
//获取当前时候秒后面的纳秒值
int nano = now.getNano();
log.debug("当前时间的纳秒值：{}",nano);
//手动指定纳秒值100
Instant instant = Instant.ofEpochSecond(365 * 24 * 60, 100);
log.debug("手动设定Instant值：{}",instant);
// - 当前时间：1623339373763/milliseconds（毫秒）
// - 当前时间：2021-06-10T15:36:13.778Z/nanoseconds（纳秒）
// - 当前时间的纳秒值：778000000
// - 手动设定Instant值：1970-01-07T02:00:00.000000100Z