java常用API-object，objects，包装类，bigDecimal，StringBuffer，LocalDateTime相关的

什么是API？

• API（Application Programming interface）应用程序编程接口
• 就是java帮我们已经写好的一些程序：比如：类，方法等。我们直接拿来调用即可

 object类：

object类的作用：

object类是java中所有类的祖宗类，因此：java中所有类的对象都可以直接使用object类提供的一些方法。

 object类的常见方法：

public String toString()       返回对象的字符串表示形式

public boolean eqeuals(Object to) 判断两个对象是是否相等

 toString存在的意义：toString()方法存在的意义就是为了被子类重写，以便返回对象具体的内容。

equals存在的意义：直接比较两个对象的地址是否完全相同。可以用‘==’替代，equals存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容）

Student类

public class Student {
    private Integer age;
    private String name;
    private char sex;

    public Student() {
    }

    public Student(Integer age, String name, char sex) {
        this.age = age;
        this.name = name;
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return sex == student.sex && Objects.equals(age, student.age) && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name, sex);
    }
}

Test1测试类：

public class Test1 {
    public static void main(String[] args) {
        Student s1 = new Student(18,"道恩",'男');
        Student s2 = new Student(18,"道恩",'男');
        //如果子类没有重写父类的toString方法，那么输出的就是地址。
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("------------");
        // == 比较引用数据类型，比较的就是地址
        System.out.println(s1 == s2);
        //如果子类不重写父类的equals方法，那么它们比较的就是地址。不会比较里面的内容，如果子类重写了父类的equals的方法，那么就会比较里面的内容
        System.out.println(s1.equals(s2));
    }
}

Objects类：

Objects类是一个工具类，提供了很多操作对象的静态方法给我们使用。

• public static boolean equals(Object 1,Object b)  先做非空判断，在比较两个对象
• public static boolean isNull(Object obj)  判断对象是否为null，为null返回true，反之false
• public static boolean nonNull(Object obj)  判断对象是否不为null，不为null则返回true，反之false。

使用Objects的equals方法更安全些

public class Test1 {
    public static void main(String[] args) {
        String s1 = "道恩";
        String s2 = "道恩";
        String s3 = null;
        System.out.println(Objects.isNull(s2));
        System.out.println(Objects.nonNull(s1));
        System.out.println(Objects.equals(s1, s2));
        System.out.println(s1.equals(s2));
        System.out.println("-------------");
        System.out.println(s3.equals(s2));  //会报错
    }
}

包装类：

为什么要有包装类？

java万物皆对象，但是8种基本数据类型还不是对象。

byte short int long char float double boolean

包装类就是把基本数据类型转换的数据包装成对象。

• 自动装箱：基本数据类型可以自动转换成包装类型
• 自动拆箱：包装类型可以自动转换为基本数据类型

 常用方法：

常用方法：
intValue()    把字符串转换成整数
parsent()     比较两个int类型的大小
intValue()    将Integer类型转换成int类型
max()         比较两个int类型，返回大的那个
min()         比较两个int类型，返回小的那个
sum()         计算两个数的和
valueOf()     将一个整数或者一个字符型整数转换成Integer型

 parseInt()方法：

 String str1 = "10";
 String str2 = "27";
        int ids1 = Integer.parseInt(str1);
        int ids2 = Integer.parseInt(str2);
     System.out.println(ids1+ids2);
     System.out.println("两个数的和是："+(ids1+ids2));

compare()方法：

static String num = "15";
    public static void main(String[] args) {

       int n1 = Integer.parseInt(num);
       int n2 = Integer.compare(10,n1);
        System.out.println(n2); //-1
    }
    输出的结果会有三个值，
    0   表示两个数相同
    1   表示这个数，比跟它比较的数大
    -1  表示这个数，比跟它比较的数小

intValue()方法：

Integer n1 =33;
int value = n1.intValue();
System.out.println(value);

max()方法：

int max = Integer.max(44,66);
System.out.println(max);    //输出66

min()方法：

int min = Integer.max(44,66);
System.out.println(min);  //输出，44

sum()方法：

 int sum = Integer.sum(20,60);
 System.out.println(sum);

valueOf()方法：

        int num = 3;
        String str = "22";
        Integer valueOf = Integer.valueOf(str);
        Integer integer = Integer.valueOf(num);
        System.out.println(valueOf*3);  //66
        System.out.println(integer-2);  // 1

   //自动装箱：
        Integer i1 = 12;
        int i2 = i1;
        System.out.println(i1);  //12
        System.out.println(i2);  //12
        System.out.println("-------------");
        //自动拆箱
        int i3 = i1;
        System.out.println(i3);  //12

包装类的其他常见操作：

• 可以把基本数据类型的数据转换成字符串类型

 //把基本数据类型的数据转换为字符串
        Double d1 = 12.5;
        Integer i4 = 88;
        String s = d1.toString();
        String intStr = i4.toString();
        System.out.println(s);  //12.5
        System.out.println(intStr); //88

• 把字符串类型的数值转换成数值本身对应的数据类型

  //字符串类型转换成基本数据类型
        String d2 = "99.9";
        String i7 = "123";
        double parseDouble = Double.parseDouble(d2);
        int parseInt = Integer.parseInt(i7);
        Double value = Double.valueOf(d2);
        Integer integer = Integer.valueOf(i7);
        System.out.println(parseDouble);  //99.9
        System.out.println(parseInt);    //123
        System.out.println(value);       // 99.9
        System.out.println(integer);     // 123

StringBuilder，StringBuffer，StringJoiner

StringBuilder

• StringBuilder 代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的。
• 优点：StringBuilder 比String更适合做字符串修改操作，效率更高，代码更简洁。

构造器：                                        说明

public StringBuilder()                    创建一个空白的可变的字符串对象，不包含任何内容

public StringBuilder(String str)       创建一个指定字符串内容的可变字符串对象

方法名称：                                                说明：

public StringBuilder append(任意类型)        添加数据并返回StringBuilder对象本身

public StringBuilder reverse()                        将对象的内容反转

public int length()                                           返回对象内容长度

public String toString()                         通过toString()就可以实现把StringBuilder转换为String

为什么不建议使用String操作字符串？

//使用StringBuffer

        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 1000000; i++) {
            sb.append("abc");
        }
        System.out.println(sb);

//使用for循环

  String str = "";
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            System.out.println(i);
        }
        long time2 = System.currentTimeMillis();
        System.out.println((time2 - time1) /1000.0+"s");

注意：如果操作字符串较少，或者不需要操作。遗迹定义字符串变量，还是建议使用String。

StringBuffer与StringBuilder的区别？

• StringBuffer的用法和StringBuilder的区别一摸一样
• StringBuilder是线程不安全的，StringBuffer是线程安全的

案例：

设计一个方法，用于返回任意整数类型数组的内容，要求返回的数组内容是[12,32,54,65]

​
public class Test2 {
    public static void main(String[] args) {
        int[] arr = {12,32,54,65,76,88};
        System.out.println(getStringArr(arr));
    }

   public static String getStringArr(int[] arr){
        StringBuffer sb = new StringBuffer();
        sb.append("[");
       for (int i = 0; i < arr.length; i++) {
           sb.append(arr[i]).append(i == arr.length - 1 ? "" : ",");
       }
       sb.append("]");
       return sb.toString();
   }
}

StringJoiner:

为什么要学习StringJoiner呢？

使用for循环操作字符串，速度很慢，使用StringBuffer操作字符串，速度快了，但是操作繁琐。

• JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的。
• 好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁。

public class Test {
    public static void main(String[] args) {
       int[] arr = {12,32,54,65,43,75,53,32};
        System.out.println(getIntArr(arr));
        //[12,32,54,65,43,75,53,32]
    }
    public static String getIntArr(int[] arr){
        StringJoiner sj = new StringJoiner(",","[","]");
        for (int i = 0; i < arr.length; i++) {
           sj.add(arr[i]+"");
        }
        return sj.toString();
    }
}

System，Runtime：

System代表程序所在系统，也是一个工具类

System提供的常见方法：

时间毫秒值：

指的是从 1970年1月1日 00:00:00走到刺客的总的毫秒值，因该是很大的。 1s = 1000ms

为啥选择‘1970年1月1日 00:00:00’作为时间起点：

  1969年8月，贝尔实验室的程序员肯汤普逊利用妻儿离开一个月的机会，开始着手创造一个全新的革命性的操作系统，他使用B编译语言在老旧的PDP-7机器上开发出了Unix的一个版本。随后，汤普逊和同事丹尼斯里奇改进了B语言，开发出了C语言，重写了UNIX。

1970年1月1日 算是C语言的生日

Runtime：

• 代表程序所在的运行环境
• Runtime 是一个单例类

 ①public static Runtime getRuntime()   返回当前java应用程序关联的运行时对象。
②public void exit(int status)   终止当前运行的虚拟机。
③public int avaliableProcessors()   返回java虚拟机可用的处理器数。
④public long totalMameoy()    返回java虚拟机中的内存总量。
⑤public long freeMemory()    返回java虚拟机中的可用内存。
⑥public Process exec(String command)   启动某个程序，并返回该程序的对象。

 public static void main(String[] args) throws IOException, InterruptedException {
        Runtime r = Runtime.getRuntime();
       // r.exit(0);
        //获取虚拟机能够使用的处理器数
        System.out.println(r.availableProcessors());
        //返回java虚拟机中的内存数量
        System.out.println(r.totalMemory() / 1024.0/1024.0 +"MB");
        //返回java虚拟机中可用的内存量
        System.out.println(r.freeMemory() /1024.0/1024.0 +"MB");
        //启动某个程序
        Process exec = r.exec("电脑中软件盘符路径");
        Thread.sleep(5000);//让程序在这里暂停5秒再走
        exec.destroy();//关闭程序
    }

BigDdecimal类：

BigDecimal

用于解决浮点型运算时，出现结果失真问题。

 public static void main(String[] args) {

        //浮点型运算时：加减乘除，精度可能会失真
        System.out.println(0.1 + 0.2);
        System.out.println(1.0 - 0.32);
        System.out.println(1.015 * 100);
        System.out.println(1.301 / 100);
    }

//
///0.30000000000000004
//0.6799999999999999
//101.49999999999999
//0.013009999999999999

BigDecimal常见的构造器，常用方法：

public class Test {
    public static void main(String[] args) {
        //bigDecimal的应用
        //把小数类型的转换成bigDecilaml的两种方式
        // 第一种：调用BigDecimal参数为String的构造器
        // 第二种：条用BigDecimal 的静态方法 valueOf()方法
        BigDecimal b1 = new BigDecimal("0.1");
        BigDecimal b2 = new BigDecimal("0.2");
        BigDecimal b3 = b1.add(b2);
        System.out.println(b3);
        System.out.println("--------------------");
        BigDecimal c1 = BigDecimal.valueOf(0.45);
        BigDecimal c2 = BigDecimal.valueOf(0.33);
        BigDecimal c3 = c1.add(c2);
        System.out.println(c3);
        System.out.println("-----------------");
        /**
         * 加减乘除的运算
         */
        System.out.println(c1.add(c2));  //加法
        System.out.println(c1.subtract(c2)); //减法
        System.out.println(c1.multiply(c2)); // 乘法
        System.out.println(c1.divide(c2,2, RoundingMode.HALF_UP));   //除法
    }
}

Date时间对象：

JDK8之前的Date对象：

java中的Date对象中，封装了有关时间和日期的信息。

import java.util.Date;  //Date类，在java,unil包中，使用时需要导包。只有java.lang包中的类，不需要使用import语句引入。
class Test {
	public static void main(String[] args) {
			Date date=new Date();//实例化date对象，获取系统当前时间。
			System.out.println("当期时间是："+date);
	}
}

Date的构造方法：

①public Date()  创建一个Date对象，代表的是系统当前此刻的日期时间。
②public Date(long time)  把时间毫秒值转换成Date日期对象。

Date的常见方法：

①public long getTime()   返回从1970年1月1日 00：00：00走到此刻的总的毫秒数。
②public void setTime(long time)   设置日期对象的时间为当前时间毫秒值对应的时间。

 public static void main(String[] args){
        Date date = new Date();
        System.out.println(date);
        //获得时间毫秒值
        long time = date.getTime();
        System.out.println(time);
        //把时间毫秒值转换成日期对象
        time += 1000*2;
        Date date1 = new Date(time);
        System.out.println(date1);

        //通过setTime进行修改
        Date date2 = new Date();
        date2.setTime(time);
        System.out.println(date2);
    }

//Sun Aug 13 15:19:50 CST 2023
1691911190144
Sun Aug 13 15:19:52 CST 2023
Sun Aug 13 15:19:52 CST 2023

SimpleDateFormat类：

SimpleDateFormat类，是用来格式化和解析日期的具体类。

Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = format.format(date);
        System.out.println(time); //2023-08-11 14:59:38

注意：

在"yyyy年MM月dd日 HH时mm分ss秒"中：y表示年，M表示月，d表示日，H表示时，m表示分，s表示秒。
常用的格式化字符串有：
yyyy-MM-dd,HH:mm:ss,yyyy/MM/dd,HH:mm:ss,yyyyMMddHHmmss

格式化时间，H表示24小时制，h表示12小时制。

Date date = new Date();
        SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //24小时制
        String time1 = format1.format(date);
  System.out.println(time1); //2023-08-11 15:04:36
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss"); //12小时制
        String time2 = format2.format(date);
        System.out.println(time2);//2023/08/11 03:04:36

把字符串转换成时间格式：

 public static void main(String[] args) throws ParseException { 
 String birthday = "2002-02-04";
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date time = format.parse(birthday);
   System.out.println(time); //Mon Feb 04 00:00:00 CST 2002
   }

秒杀案例：

public static void main(String[] args) throws ParseException {
        //1，定义开始，结束，和下单时间
       String start = "2023年11月11日 0:0:0";
       String end = "2023年11月11日 0:10:0";
       String sun = "2023年11月11日 0:01:18";
       String li = "2023年11月11日 0:10:57";
        //2，统一把字符串时间转换成日期对象
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date startS = dateFormat.parse(start);
        Date endS = dateFormat.parse(end);
        Date sunS = dateFormat.parse(sun);
        Date liS = dateFormat.parse(li);

        //3，开始判断是否秒杀成功
        //把日期对象转换成毫秒值来判断
        long startSTime = startS.getTime();
        long endTime = endS.getTime();
        long sunTime = sunS.getTime();
        long liTime = liS.getTime();
        if (sunTime >= startSTime && sunTime <= endTime){
            System.out.println("道恩下单秒杀成功");
        }else {
            System.out.println("道恩秒杀成功");
        }

        if (liTime >= startSTime && liTime <= endTime){
            System.out.println("李四下单秒杀成功");
        }else {
            System.out.println("李四秒杀失败");
        }

    }

Calendar类：

该类为抽象类，通过getinstance()方法，返回一个Calendar对象。并通过getTime()方法获取时间。

   Calendar now = Calendar.getInstance();
        Date time = now.getTime();
        System.out.println(time); //Fri Aug 11 15:12:25 CST 2023

Callendar类比Date类更加灵活。可以修改时或设置时间。

获取昨天或则之前和之后的时间：

 Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.YEAR,-1);减一年 //负数为当前日期时间，相减。正数为当前日期相加
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String s = format.format(calendar.getTime());
        System.out.println(s); //2022-08-11


calendar.add(Calendar.YEAR,1);加一年
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String s = format.format(calendar.getTime());
        System.out.println(s); //2024-08-11

  Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE,3); //2023-8-11号加三天就是14号。
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String s = format.format(calendar.getTime());
        System.out.println(s); //2023-8-14
        
        calendar.add(Calendar.DATE,-5);//11号向前减5天
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String s = format.format(calendar.getTime());
        System.out.println(s); //2023-8-6

set()方法设置日历：

 public static void main(String[] args) throws ParseException {
        Calendar calendar = Calendar.getInstance();
       calendar.set(2002,01,04);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String s = format.format(calendar.getTime());
        System.out.println("设置的日期为："+s);
        //设置的日期为：2002-02-04
    }

get(）方法获取时间的特定部分：

Calendar calendar = Calendar.getInstance();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String s = format.format(calendar.getTime());
        System.out.println("今天是："+s);
        System.out.println("星期："+calendar.get(Calendar.DAY_OF_WEEK)); //星期6-1=5
        System.out.println("那年："+calendar.get(Calendar.YEAR));那年：2023

小知识：

1秒 = 1000毫秒

1毫秒 = 1000微秒

1微秒 = 1000纳秒

JDK8新增的时间：

代替Canlendar

LocalDate:（本地日期）年，月，日。
LocalTime:（本地时间）时，分，秒。
LocalDateTime:（本地日期，时间） 年，月，日 时，分，秒。
ZoneId：时区
ZonedDateTime:带时区的时间

上面这些获取对象的方案：

//方法名：
public static Xxxx now();
//示例：
LocalDate ld = LocalDate.now();
LocalDate lt = LocalTime.now();
LocalDateTime ldt = LocalDateTime.now();

LocalDate常用的API：

①public int geYear() 获取年
②public int getMonthValue() 获取月份(1-12)
③public int getDayOfMonth() 获取日
④public int getDay0fYear() 获取当前是一年中的第几天
⑤Public DayOfweek getDayOfWeek() 获取星期几：ld.getDay0fWeek().getValue(0

①withYear、withMonth、withDay0fMonth、withDay0fYear 直接修改某个信息，返回新日期对象
②plusYears、plusMonths、plusDays、plusWeeks 把某个信息加多少，返回新日期对象
③minusYears, minusMonths, minusDays, minusWeeks 把某个信息减多少，返回新日期对象
④equals isBefore isAfter 判断两个日期对象，是否相等，在前还是在后

 public static void main(String[] args) throws ParseException {
        LocalDate ld = LocalDate.now(); //获取本地日期对象
        System.out.println(ld);
        //获取日期对应的信息
        int year = ld.getYear();//年
        int month = ld.getMonthValue();//月
        int day = ld.getDayOfMonth();//日
        int dayOfYear = ld.getDayOfYear();//一年中的第几天
        int week = ld.getDayOfWeek().getValue();//星期几
        System.out.println(year+"-"+month+"-"+day+" "+dayOfYear+"-"+week);
       //直接修改某个信息 withYear,withMoth,withDayOfMonth,withDayOfYear
        LocalDate ld2 = ld.withYear(2034);
        LocalDate ld3 = ld.withMonth(11);
        System.out.println(ld2);
        System.out.println(ld3);
        //把某个信息加多少plusYear,plusMonth,plusDays,plusWeeks
        LocalDate l1 = ld.plusYears(3);
        LocalDate l2 = ld.plusMonths(2);
        System.out.println(l1);
        System.out.println(l2);
        //把某个信息减多少 minusYears,minusMonth,minusDays,minusWeeks
        LocalDate l3 = ld.minusYears(2);
        LocalDate l4 = ld.minusMonths(2);
        System.out.println(l3);
        System.out.println(l4);
        //获取某个日期对象的LocalDate对象，public static LocalDate.of(int year,int month,int dayOfMonth);
        LocalDate l5 = LocalDate.of(2002,02,04);
        LocalDate l6 = LocalDate.of(2002,02,04);
        //判断2个日期对象，是否相等，在前还是在后 equals isBefore isAfter
        System.out.println(l5.isEqual(l6));
        System.out.println(l5.isAfter(l6));
        System.out.println(l5.isBefore(l6));
    }
//2023-08-13
2023-8-13 225-7
2034-08-13
2023-11-13
2026-08-13
2023-10-13
2021-08-13
2023-06-13
true
false
false

LocalTime常用的API：

①public int getHour()    获取小时    
②public int getMinute()    获取分    
③public int getSecond()    获取秒    
④public int getNano()    获取纳秒    

①withHour、 withMinute, withSecond. withNano    修改时间，返回新时间对象    
②plusHours、plusMinutes、plusSeconds、plusNanos    把某个信息加多少，返回新时间对象    
③minusHoursminusMinutesminusSecondsminusNanos    把某个信息减多少，返回新时间对象    
④equals isBefore isAfter    判断2个时间对象，是否相等，在前还是

ZoneId时区：

什么是时区：

世界各个国家与地区的经度不同，各地区时间也有所不同，因此会划分不同的时区。

世界标准时间（UTC）

中国标准时间：世界标准时间（UTC）+8小时

ZoneId时区的常见方法：

①public static Set<String> getAvailableZonelds() 获取Java中支持的所有时区
②public static Zoneld systemDefault() 获取系统默认时区
③public static Zoneld of(String zoneld) 获取一个指定时区

ZonedDateTime 带时区时间的常见方法:

①public static ZonedDateTime now() 获取当前时区的ZonedDateTime对象
②public static ZonedDateTime now(Zoneld zone) 获取指定时区的ZonedDateTime对象
③getyear.getMonthValue、getDayOfMonth、getDayOfYeargetbayOfweek、 获取年月日、时分秒、纳秒等
getHour、getMinute、getSecond、getNano
④public ZonedDateTime withXxx(时间) 修改时间系列的方法
⑤public ZonedDateTime minusXxx(时间) 减少时间系列的方法
⑥public ZonedDateTime plusXxx(时间) 增加时间系列的方法

 //获取系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);
        //获取java支持的全部ZoneId
        System.out.println(ZoneId.getAvailableZoneIds());
        //把某个时区id封装成ZoneId对象
        ZoneId of = ZoneId.of("Africa/Nairobi");
        System.out.println(of);
        //2，ZoneDateTime 根据时区获取时间
        ZonedDateTime zonedDateTime = ZonedDateTime.now(of);
        System.out.println(zonedDateTime);
        ZonedDateTime now = ZonedDateTime.now(Clock.systemUTC());//获取世界标准时间
        System.out.println(now);
        ZonedDateTime now1 = ZonedDateTime.now();//获取系统默认时间
        System.out.println(now1);

Instant：时间戳/时间线。

instant：时间线上的某一刻/时间戳

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

常见的方法：

①public static Instant now() 获取当前时间的Instant对象（标准时问)
②public long getEpochSecond() 获取从1978-01-01Te0：00：00开始记录的秒数
③publicint getNano() 从时间线开始，获取从第二个开始的纳秒数
④plusMillisplusSeconds plushanos 判断系列的方法
⑤minusMi1lisminusSeconds minusNanos 减少时间系列的方法
⑥equals.isBefore、isAfter 增加时间系列的方法

//创建Instant对象，获取此刻时间信息
       Instant now = Instant.now();
       //获取总秒钟数
        long second = now.getEpochSecond();
        System.out.println(second);
        //不够1秒的纳秒数
        int nano = now.getNano();
        System.out.println(nano);

        System.out.println(now);

        Instant instant = now.plusNanos(666);
        Instant instant1 = now.minusSeconds(1000);

        //instant对象的作用:做代码性能分析，记录用户的操作时间点
        Instant now1 = Instant.now();
        //代码执行。。。
        Instant now2 = Instant.now();

DateTimeFormatter：

用于时间格式化和解析

public static DateTimeFormatter ofPattern(时间格式)  获取格式化器对象。
public String format（时间对象）   格式化时间

//1，创建一个日期是啊您格式化器对象
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        //2，对时间进行格式化
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        String format = formatter.format(now);//正向格式化
        System.out.println(format);
        //3，格式化时间 还有一种方案
        String s = now.format(formatter);//反向格式化
        System.out.println(s);
        //4，解析时间，一般使用LocalDateTime提供的解析方法
        String str = "2002年2月4日 10:12:1";
        LocalDateTime parse = LocalDateTime.parse(str,formatter);
        System.out.println(parse);
//2023-08-13T18:46:33.513
2023年08月13日 18:46:33
2023年08月13日 18:46:33

Period（一段时期）

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

public class PeriodTest {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2023, 7, 24);
        LocalDate end = LocalDate.now();
        //创建period对象，封装两个日期对象
        Period between = Period.between(start, end);
        //通过period对象获取两个日期对象相差的信息
        System.out.println(between.getYears());
        System.out.println(between.getMonths());
        System.out.println(between.getDays());
    }

//0
//3
//19
}

Duration（持续时间）

用于计算两个时间对象相差的天数，小时数，分数，纳秒数：支持LocalTime，LocalDateTime，Instant等时间。

public class DurationDemo {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2023, 11, 12, 16, 45, 55);
        LocalDateTime end = LocalDateTime.of(2024, 1, 1, 11, 12, 34);
        //得到Duration对象
        Duration duration = Duration.between(start, end);
        //获取两个时间对象间隔的信息
        System.out.println(duration.toDays());  //间隔多少天
        System.out.println(duration.toHours());  //间隔多少小时
        System.out.println(duration.toMinutes()); //间隔多少分钟
        System.out.println(duration.toMillis());  //间隔多少毫秒
        System.out.println(duration.toNanos());   //间隔多少纳秒
    }
  49
//            1194
//            71666
//            4299999000
//            4299999000000000
    
}

计算距离2024年高考倒计时：

 System.out.println("=====高考倒计时=====");
        // 需求：高考时间是 2024-06-07 09：00：00
        LocalDateTime ldt = LocalDateTime.now();  //获取今天的时间
        System.out.println(ldt);
        String str = "2024-06-07 09:00:00";
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime ldt2 = LocalDateTime.parse(str, dtf);

        //计算现在距离高考还有多少天，小时，分钟，秒钟
        Duration duration1 = Duration.between(ldt, ldt2);
        System.out.println(duration1.toDays()+" "+duration1.toHoursPart()+" "+duration