Java常用类API（包装类、时间类、数学类超详细）

小程序耿

已于 2024-10-16 12:14:47 修改

阅读量895

点赞数 38

CC 4.0 BY-SA版权

分类专栏： Java常用类及API 文章标签： java 开发语言 jvm

于 2024-10-16 11:52:29 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_52176709/article/details/142977663

Java常用类及API 专栏收录该内容

5 篇文章

订阅专栏

常用类API

写在开头

我还知道一个小技巧就是
// 使用 @DateTimeFormat 指定日期格式
@DateTimeFormat(pattern = “yyyy-MM-dd”)
private LocalDate birthDate;

确保依赖：首先，确保你的项目中已经包含了Spring Framework或Lombok的相关依赖。
使用场景：@DateTimeFormatter注解主要用于自动将字符串转换为日期时间对象，或反之，常用于实体类中的日期字段。
格式化模式：pattern属性用于定义日期时间的具体格式。

还有个问题也想请教大家就是Math.random()没有Random类好用，平常开发可不可以代替Math.random()。

java.lang.Object类

方法

public String toString()：建议重写，返回对象的属性值拼接。注意，当打印对象时，或对象与字符串拼接时，都会自动调用就toString方法。
public boolean equals(Object obj)：用于比较两个对象是否相等。如果没有重写，等价于==，比较地址值，建议重写，用于比较对象的属性值。重写equals方法时，会一并重写hashCode方法（关于hashCode的使用，后面再说）
public final Class<?> getClass()：用于返回对象的运行时类型，即对象new的类型。
protected void finalize() throws Throwable：用于对象在给GC（垃圾回收器）回收之前做临终遗言，因为某些Java对象涉及到调用底层C的代码，例如IO流，网络连接等资源类，当这些对象释放它占用的JVM的堆内存时，还要同时释放对应C代码占用的JVM以外的内存。现在这个方法已经过时了，不需要我们重写和使用了。
protected Object clone() throws CloneNotSupportedException：用于克隆/复制对象。子类如果要重写这个方法，同时还得实现java.lang.Cloneable接口，否则重写也没用。

举例getClass()

package com.gj.api.object;

import org.junit.Test;

public class TestObject {
    @Test
    public void test(){
        Object obj = "hello";
        /*
        obj是什么类型？
        （1）编译时 obj 是Object
        （2）运行时 obj 是String
         */
        System.out.println(obj.getClass());
        //class java.lang.String
    }
}

面试题：

final、finally、finalize的区别？

final是一个修饰符，用于修饰类时，表示不能被继承，用于修饰方法时，表示不能被重写，用于修饰变量，表示值不能修改。
finally是配合try-catch使用，用于编写无论try-catch有没有发生异常，有没有捕获异常，有没有return语句，都要执行的代码。
finalize是一个已过时的方法，当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。

如何克隆对象？

package com.gj.api.object;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Rectangle implements Cloneable{
    private double length;
    private double width;

    @Override
    public Rectangle clone() throws CloneNotSupportedException {
        return (Rectangle) super.clone();
    }
}

package com.gj.api.object;

public class TestRectangle {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4,3);
        System.out.println("r = " + r);
        //复制/克隆上面的r对象
        try {
            Rectangle r2 = r.clone();
            System.out.println("r2 = " + r2);
            //编译器提醒我们需要处理CloneNotSupportedException异常，说明它是编译时异常
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Object其他小知识

Object是所有引用数据类型的根父类。
Object的变量，可以引用或接收任意类型的对象

package com.gj.api.object;

import org.junit.Test;

public class TestObjectType {
    @Test
    public void test1(){
        Object o1 = "hello";
        Object o2 = new Rectangle();
        Object o3 = new int[3];
        //（1）Object的变量，可以引用或接收任意类型的对象
    }

    //下面这个方法形参是Object类型，意味着它的实参可以是任意类型
    public void method(Object obj){
        //....
    }
}

Object虽然可以接收任意类型的1个对象，但是Object[]只能接收一组对象的类型，即对象数组类型，不能接收int[]等类型。

 	@Test
    public void test2(){
        Object o1 = new int[3];//o1接收了一个int[]类型的数组，此时把这个数组看成一个对象
        Object o2 = new Rectangle[3];//o2接收了一个Rectangle[]类型的数组，此时把这个数组看成一个整体，是一个对象

//        Object[] arr1 = new int[3];//Object[]类型代表很多对象，而右边int[]只有1个对象，类型不匹配
        Object[] arr2 = new Rectangle[3];//Object[]类型代表很多对象，Rectangle[]也可以代表多个Rectangle类型的对象

//        double[] arr3 = new int[3];
        //double[]与int[]没有父子类关系
    }

数学工具类

java.lang.Math类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数等。

public static double random()：用于返回[0, 1)的double的小数
public static double sqrt(double a)：用于求a的平方根
public static double abs(double a)：用于求某个数的绝对值，有多个重载方法
public static int max(int a,int b)：用于求两个数的最大值，有多个重载方法
public static int min(int a,int b)：用于求两个数的最小值，有多个重载方法
public static double floor(double a)：直接向下取整
public static doubleceil(double a)：直接向上取整
public static long round(double a)：简单理解四舍五入。+0.5后向下取整
PI：圆周率
E：常数

	@Test
    public void test1(){
        System.out.println(Math.floor(3.6));//3.0  向下取整
        System.out.println(Math.ceil(3.6));//4.0  向上取整
        System.out.println(Math.round(3.6));//4   四舍五入  3.6 + 0.5 = 4.1    (int)4.1 = 4 往下取整

        System.out.println(Math.floor(-3.6));//-4.0
        System.out.println(Math.ceil(-3.6));//-3.0
        System.out.println(Math.round(-3.6));//-4   -3.6 + 0.5 = -3.1    (int)-3.1 = -4  往下（小）取整

        System.out.println(Math.round(3.5));//4
        System.out.println(Math.round(-3.5));//-3   -3.5 + 0.5 = -3.0  （int）-3.0  -3

        System.out.println(Math.round(3.4));//3
        System.out.println(Math.round(-3.4));//-3   -3.4 + 0.5 = -2.9  （int）-2.9  -3
        /*
        round计算的规则：
            假设参数是x，
             return (int)(x + 0.5)
         */
    }

java.util.Random类

用于产生各种类型的随机数。

package com.gj.api.math;

import org.junit.Test;

import java.util.Random;

public class TestRandom {
    @Test
    public void test1(){
        Random r = new Random();
        int a = r.nextInt();//[-2147483648,2147483647)
        int b = r.nextInt(100);//[0,100)
        int c = r.nextInt(10, 20);//[10,20)

        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
    }

    @Test
    public void test2(){
        Random r = new Random();
        double d = r.nextDouble();//等价于 Math.random()
        System.out.println("d = " + d);
    }
    
    @Test
    public void test3(){
        Random r = new Random();
        //可以产生各种基本数据类型的值，没有char
    }
}

java.math.BigInteger和java.math.BigDecimal类

当我们要计算的整数、小数比较大，或者精度要求比较高的时候，可以选择它们。

package com.gj.api.math;

import org.junit.Test;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;

public class TestBigIntegerAndBigDecimal {
    @Test
    public void test1(){
//        long a = 821786248638248632146324563214563245621452145L;//超过long的范围
        BigInteger a = new BigInteger("821786248638248632146324563214563245621452145");
        BigInteger b = new BigInteger("96256214584151452145242142");

        System.out.println("和：" + a.add(b));
        System.out.println("差：" + a.subtract(b));
        System.out.println("乘积：" + a.multiply(b));
        System.out.println("商：" + a.divide(b));
        System.out.println("余数：" + a.remainder(b));
    }

    @Test
    public void test2(){
        double a = 821786.248638248632146324563214563245621452145;
        double b = 9625.6214584151452145242142;

        System.out.println("a+b = " + (a+b));
        //a+b = 831411.8700966638精度丢失很严重
    }

    @Test
    public void test3(){
        BigDecimal a = new BigDecimal("821786.248638248632146324563214563245621452145");
        BigDecimal b = new BigDecimal("9625.6214584151452145242142");
        BigDecimal c = new BigDecimal("2.0");

        System.out.println("和：" + a.add(b));
        System.out.println("差：" + a.subtract(b));
        System.out.println("乘积：" + a.multiply(b));
//        System.out.println("商：" + a.divide(b));//当除不尽的时候，这样写要报错
        System.out.println("商：" + a.divide(b,1000, RoundingMode.CEILING));//如果除不尽，需要指定精度要求，保留到小数点后多少位
        System.out.println("商：" + a.divide(c));
        System.out.println("余数：" + a.remainder(b));
    }
}

包装类(java.lang)

什么是包装类

我们Java是面向对象的编程语言，但是Java不是纯的面向对象编程语言，因为它保留了C语言的8种基本数据类型。

但是Java希望“一切皆对象”，所以后面很多的API方法的参数都是用Object等引用数据类型，例如：集合等，很多新特性，例如：泛型等都是只支持对象，不支持基本数据类型。

基本数据类型很好用，有很丰富的运算符支持，底层的计算效率也很多。

为了解决，为了能实现在基本数据类型和对象之前自由切换，Java专门为8种基本数据类型设计对应的包装类：

	基本数据类型	基本数据类型对应的字节数	对应的包装类
1	byte	1	Byte
2	short	2	Short
3	int	4	Integer
4	long	8	Long
5	float	4	Float
6	double	8	Double
7	char	2	Character
8	boolean	1位	Boolean

在JDK5之前，基本数据类型与包装类之间转换是比较麻烦的，需要手动进行转换，现在JDK5（含）之后可以自由转换。

类型转换：装箱与拆箱

装箱（boxing）：把基本数据类型的数据，包装为对象的过程，称为装箱。
拆箱（unboxing）：把包装类的对象，拆解为基本数据类型的值的过程，称为拆箱。
JDK5（含）之后可以实现自动装箱和自动拆箱。
- 当我们要把基本数据类型的值，赋值给引用数据类型的变量时，或者把基本数据类型的值放到后面要学的集合中时，它们都会自动装箱。例如：Object obj = 1;
- 2、当我们想要把包装类的对象，赋值给基本数据类型的变量时，会自动拆箱。或者当我们要对包装类进行某些计算时，会自动拆箱。
算术运算：自动拆箱
大小比较：>,<.>=,<= ：自动拆箱
相等比较：==与!= 它们不会自动拆箱。如果==或!= 的左右两边有基本数据类型的值参与，那么也会自动拆箱。
注意：自动装箱与自动拆箱仅限于对应类型之前，不能跨类型。

举例：引出常量对象范围

package com.gj.api.wrapper;

import org.junit.Test;

public class TestBoxingAndUnBoxing {
    @Test
    public void test1(){
        Integer a = 1;//自动装箱的过程
        int b = a;//自动拆箱的过程
        //这里a是引用数据类型
        //b是基本数据类型

        Object obj = 1;//自动装箱为Integer对象
        System.out.println(obj.getClass());//class java.lang.Integer
    }

    @Test
    public void test2(){
        Integer a = Integer.valueOf(1);
        Integer b = Integer.valueOf(2);
        System.out.println(a+b);//3  当包装类对象进行算术计算时，会自动拆箱为基本数据类型
        System.out.println(a-b);//-1  当包装类对象进行算术计算时，会自动拆箱为基本数据类型
    }

    @Test
    public void test3(){
        Integer a = Integer.valueOf(1);
        Integer b = Integer.valueOf(2);
        System.out.println(a>b);//false  当包装类对象进行大小比较时，会自动拆箱为基本数据类型
        System.out.println(a<b);//true
    }

    @Test
    public void test4(){
        Integer a = Integer.valueOf(200);
        Integer b = Integer.valueOf(200);
        System.out.println(a==b);//false  200不在Integer的缓存范围内，每次用200需要重新new
        //当两个包装类的对象进行==或!=比较时，不会自动拆箱的，仍然按照引用数据类型的规则，比较地址值
    }

    @Test
    public void test5(){
        Integer a = Integer.valueOf(1);
        Integer b = Integer.valueOf(1);
        System.out.println(a==b);//true  是因为1在Integer的缓存对象范围内
    }

    @Test
    public void test6(){
        Integer a = Integer.valueOf(200);
        int b = 200;
        System.out.println(a == b);//true
    }

    @Test
    public void test7(){
        double d = 1;//OK  1是int,d是double，这里称为 基本数据类型的自动类型提升
       // Double d1 = 1;//报错  自动装箱。自动装箱只能在对应类型之间 double -> Double，不支持 int -> Double
        Double d1 = 1.0;
        Double d2 = 1D;
    }
}

常量对象的范围

部分包装类的对象使用非常频繁，JVM就将他们进行缓存，将他们设计为常量对象。

包装类	缓存对象的范围
Byte	-128~127
Short	-128~127
Integer	-128~127
Long	-128~127
Float	无
Double	无
Character	0-127
Boolean	false和true

包装类对象不可变（面试题）

Integer a = 1;
a = a + 1; //修改包装类的值，是让它指向新对象，不是直接在原对象中进行值的修改

在这里插入图片描述

举例：正因为包装类对象不可变，才可以安全的共享缓存对象。

package com.gj.api.wrapper;

import org.junit.Test;

public class TestWrapper {
    @Test
    public void test1(){
        int x = 1;
        Integer y = Integer.valueOf(1);
        int[] z = {1};
        int[] p = {1};
        change(x,y,z,p);
        System.out.println("x = " + x);//x=1
        System.out.println("z[0] = " + z[0]);//z[0] = 2
        System.out.println("y = " + y);//y=1
        System.out.println("p[0] = " + p[0]);//p[0] = 1

    }

    /*
    change方法的形参有3个：
    int：基本数据类型          上面实参x给a的是数据值，a的修改对x没影响
    Integer：引用数据类型，同时包装类  上面实参y给b的是地址值。但是因为b包装类，它的对象是不可变对象
                                对象中的属性值是无法修改的，要修改，只能产生新对象
    int[]：引用数据类型        上面的实参z给c的是地址值，c对元素的修改会影响z
     */
    public void change(int a, Integer b, int[] c,int[] d){
        a++;
        b++;//等价于 b = Integer.valueOf(b+1) 或 b = new Integer(b+1)
        c[0]++;
        d = new int[2];
        d[0]=100;
    }

    @Test
    public void test3(){
        Integer a = 1;
        Integer b = 1;
        //1在缓存对象范围内
        //a和b指向同一个对象
        a = a+1;//
        //如果包装类对象可变的话，上面这句代码，就会导致b也跟着变。
    }
}

API方法

MAX_VALUE：xx的最大值，例如：Integer.MAX_VALUE，Double.MAX_VALUE
MIN_VALUE：xx的最小值，例如：Integer.MIN_VALUE，Double.MIN_VALUE
解析字符串为基本数据类型的值
- Integer类中有：public static int parseInt(String s)throws NumberFormatException，
- Double类中有：public static int parseDouble(String s)throws NumberFormatException
- 以此类推：public static int parseXxx(String s)throws NumberFormatException
比较大小：
- Integer类中有：public static int compare(int x, int y) ：比较两个int值
- Double类中有：public static int compare(double x, double y) ：比较两个double值

举例

package com.gj.api.wrapper;

import org.junit.Test;

public class TestAPI {
    @Test
    public void test1(){
        String s1 = "123";
        String s2 = "456";
        System.out.println(s1 + s2);//123456  因为字符串的+是拼接
    }
    @Test
    public void test2(){
        String s1 = "123";
        String s2 = "456";
        //希望它们进行求和

        int a = Integer.parseInt(s1);
        int b = Integer.parseInt(s2);
        System.out.println(a+b);//579
    }

    @Test
    public void test3(){
        String s1 = "1.23";
        String s2 = "4.56";
        
        double a = Double.parseDouble(s1);
        double b = Double.parseDouble(s2);
        System.out.println(a+b);
    }
}

package com.gj.api.wrapper;

import org.junit.Test;

public class TestAPI {
    @Test
    public void test1(){
        String s1 = "123";
        String s2 = "456";
        System.out.println(s1 + s2);//123456  因为字符串的+是拼接
    }
    @Test
    public void test2(){
        String s1 = "123";
        String s2 = "456";
        //希望它们进行求和

        int a = Integer.parseInt(s1);
        int b = Integer.parseInt(s2);
        System.out.println(a+b);//579
    }

    @Test
    public void test3(){
        String s1 = "1.23";
        String s2 = "4.56";

        double a = Double.parseDouble(s1);
        double b = Double.parseDouble(s2);
        System.out.println(a+b);
    }

    @Test
    public void test4(){
        double a = 5.2;
        double b = 3.6;

//        a和b比较大小有3种结果
        /*
        a>b
        a<b
        a=b
         */
        System.out.println(Double.compare(a,b));//1 正整数，代表a>b

        a= 2.1;
        System.out.println(Double.compare(a,b));//-1 负整数，代表a<b

        a=3.6;
        System.out.println(Double.compare(a,b));//0  0，代表a=b
    }
}

日期时间API

在Java中日期时间API分为3代：

第一代

1、java.util.Date类，它里面很多方法都是已过时的。

Date()：获取系统时间
long getTime()：获取某个日期时间距离1970-1-1 0:0:0 的毫秒值

2、java.text.SimpleDateFormat：对日期进行格式化，或者把字符串按照某个模板转为日期时间值
在这里插入图片描述

package com.gj.api.date;

import org.junit.Test;

import java.util.Date;

public class TestDate {
    @Test
    public void test1(){
        /*
        打开某个类的源码的两种方式：
        （1）按住Ctrl键，单击你要查看的类名
        （2）Ctrl + N打开搜索框，输入你要查看的类名，打开源码

        快速查看某个类的成员列表：Ctrl + F12，部分同学要同时按Fn
         */
        Date d = new Date();//无参构造
        System.out.println(d);
        //Tue Oct 15 16:32:21 CST 2024
        //周二  十月 15日 时间  中国标准时间 2024

    }
    @Test
    public void test2(){
        Date d = new Date();
        long time = d.getTime();
        System.out.println(time);//1728981217724
        //当前系统时间距离1970-1-1 0:0:0 的毫秒值
    }

    @Test
    public void test3(){
        Date d = new Date(2024-1900,9-1,23);
        System.out.println(d);
        long time = d.getTime();
        System.out.println(time);
    }
}

package com.gj.api.date;

import org.junit.Test;

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


public class TestSimpleDateFormat {
    @Test
    public void test1(){
        Date d = new Date();//无参构造
        System.out.println(d);
        //Tue Oct 15 16:32:21 CST 2024

        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒 E，这一天是这一年的第D天");
        String str = sf.format(d);
        System.out.println(str);
        //2024年10月15日 16时38分46秒 943毫秒 周二
    }

    @Test
    public void test2(){
        String str = "2024年10月15日 16时38分46秒";
        //如果想要把字符串转为Date对象，也可以用SimpleDateFormat
        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        try {
            Date date = sf.parse(str);
            System.out.println(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

第二代

1、java.util.TimeZone：时区

2、java.util.Locale：地区

3、java.util.Calendar：日历类型

package com.gj.api.date;

import org.junit.Test;

import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.TimeZone;

public class TestCalendar {
    @Test
    public void test1(){
        //Calendar抽象类
        //GregorianCalendar是它的子类
        Calendar c = new GregorianCalendar();
        System.out.println(c);
        /*
        java.util.GregorianCalendar[
            time=1728982112799,
            areFieldsSet=true,
            areAllFieldsSet=true,
            lenient=true,
            zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,
            transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,
            YEAR=2024,MONTH=9,WEEK_OF_YEAR=42,WEEK_OF_MONTH=3,DAY_OF_MONTH=15,
            DAY_OF_YEAR=289,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=3,
            AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=48,SECOND=32,MILLISECOND=799,ZONE_OFFSET=28800000,DST_OFFSET=0]

         */
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR_OF_DAY);
        int minute = c.get(Calendar.MINUTE);
        System.out.println(year+"年" + month +"月"+day +"日" + hour +"时" + minute +"分");
       //2024年10月15日16时52分
    }

    @Test
    public void test2(){
        TimeZone zone = TimeZone.getTimeZone("America/Los_Angeles");
        Calendar c = new GregorianCalendar(zone);
        System.out.println(c);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR_OF_DAY);
        int minute = c.get(Calendar.MINUTE);
        System.out.println(year+"年" + month +"月"+day +"日" + hour +"时" + minute +"分");
        //2024年10月15日1时52分
    }
}

第三代

第1代的问题：

无法表示不同时区的日期时间
Date类很多API方法设计不够人性化，很麻烦
日期时间对象是可变的
线程不安全

第2代的问题：

日期时间对象是可变的
很难用，得到年、月、日等具体日期时间值时，需要调用get方法
线程不安全

第3代：从Java8引入，而且是参考了很多第三方的库设计的第3代。

本地日期时间类：

java.time.LocalDate
java.time.LocalTime
java.time.LocalDateTime

package com.gj.api.date;

import org.junit.Test;

import java.time.*;

public class TestLocalDateTime {
    @Test
    public void test1(){
        //今天日期
        LocalDate today = LocalDate.now();
        System.out.println("today = " + today);
        //today = 2024-10-15
    }

    @Test
    public void test2(){
        //现在时间
        LocalTime now =  LocalTime.now();
        System.out.println(now);
        //17:03:46.197152100
    }

    @Test
    public void test3(){
        //日期+时间、
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(dateTime);
        //2024-10-15T17:04:19.347364300
    }

    @Test
    public void test4(){
        LocalDate birthday = LocalDate.of(1990,1,6);
        System.out.println(birthday);//1990-01-06
    }

    @Test
    public void test5(){
        //今天日期
        LocalDate today = LocalDate.now();
        System.out.println(today);//2024-10-15
        //100天之前
        LocalDate before = today.minusDays(100);
        System.out.println(before);//2024-07-07
    }

    @Test
    public void test6(){
        LocalDate kai = LocalDate.of(2024,9,23);
        System.out.println(kai);
        //200天之后
        LocalDate bi = kai.plusDays(200);
        System.out.println(bi);//2025-04-11
    }

    @Test
    public void test7(){
        //今天日期
        LocalDate today = LocalDate.now();
        //看一下今年是不是闰年
        boolean leapYear = today.isLeapYear();
        System.out.println(leapYear);//true
    }

    @Test
    public void test8(){
        //今天日期
        LocalDate today = LocalDate.now();

        int year = today.getYear();
        System.out.println("year = " + year);

        Month month = today.getMonth();
        System.out.println(month);//OCTOBER

        int monthValue = today.getMonthValue();
        System.out.println(monthValue);//10

        DayOfWeek dayOfWeek = today.getDayOfWeek();
        System.out.println(dayOfWeek);
    }
}

在这里插入图片描述

日期时间间隔

java.time.Period：日期间隔，阶段
java.time.Duration：时间间隔，或持续时间

package com.gj.api.date;

import org.junit.Test;

import java.time.*;

public class TestPeroidAndDuration {
    @Test
    public void test1(){
        LocalDate one = LocalDate.of(2024,9,23);
        LocalDate two = LocalDate.of(2000,10,6);

        Period p = Period.between(one,two);
        System.out.println(p);
        //P-23Y-11M-17D
    }

    @Test
    public void test2(){
        LocalTime one = LocalTime.of(17,19);
        LocalTime two = LocalTime.of(21,45);
        Duration d = Duration.between(one,two);
        System.out.println(d);
        //PT4H26M
    }
}

不同时区的日期时间类

java.time.ZoneId：时区id，例如：本地：Asia/Shanghai
java.time.ZoneOffset：时区偏移，例如：本地：+8:00
java.time.ZonedDateTime：某个时区的日期时间
java.time.Instant：本初子午线的瞬时

package com.gj.api.date;

import org.junit.Test;

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

public class TestDateTimeZone {
    @Test
    public void test1(){
        ZoneId id = ZoneId.of("America/Los_Angeles");
        ZonedDateTime z = ZonedDateTime.now(id);
        System.out.println(z);
        //2024-10-15T02:24:05.168998400-07:00[America/Los_Angeles]
    }

    @Test
    public void test2(){
        Instant instant = Instant.now();//本初子午线的瞬时
        System.out.println(instant);
        //2024-10-15T09:25:15.571756500Z
    }

    @Test
    public void test3(){
        ZoneId id = ZoneId.of("Asia/Shanghai");
        ZonedDateTime z = ZonedDateTime.now(id);
        System.out.println(z);
        //2024-10-15T17:26:00.193161900+08:00[Asia/Shanghai]
    }
}

日期时间格式化

java.time.format.DateTimeFormatter

package com.gj.api.date;

import org.junit.Test;

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

public class TestDateTimeFormatter {
    @Test
    public void test1(){
        LocalDateTime datetime = LocalDateTime.now();
        //yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒 E，这一天是这一年的第D天
        DateTimeFormatter dt = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒 E，这一天是这一年的第D天");
        String str = dt.format(datetime);
        System.out.println(str);
        //2024年10月15日 17时29分49秒 474毫秒 周二，这一天是这一年的第289天
    }

    @Test
    public void test2(){
        String str = "2024年10月15日 16时38分46秒";
        DateTimeFormatter dt = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
        LocalDateTime dateTime = LocalDateTime.parse(str, dt);
        System.out.println(dateTime);
        //2024-10-15T16:38:46
    }

    @Test
    public void test3(){
        LocalDateTime datetime = LocalDateTime.now();
        DateTimeFormatter dt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);//短
        String str = dt.format(datetime);
        System.out.println(str);//2024/10/15 下午5:31
    }

    @Test
    public void test4(){
        LocalDateTime datetime = LocalDateTime.now();
        DateTimeFormatter dt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);//中等
        String str = dt.format(datetime);
        System.out.println(str);//2024年10月15日 下午5:31:55
    }

    @Test
    public void test5(){
        LocalDateTime datetime = LocalDateTime.now();
        DateTimeFormatter dt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG).withZone(ZoneId.systemDefault());//长
        String str = dt.format(datetime);
        System.out.println(str);//2024年10月15日 CST 下午5:32:59
    }

    @Test
    public void test6(){
        LocalDateTime datetime = LocalDateTime.now();
        DateTimeFormatter dt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).withZone(ZoneId.systemDefault());//全
        String str = dt.format(datetime);
        System.out.println(str);//2024年10月15日星期二 中国标准时间 下午5:33:27
    }
}