java常用类

最新推荐文章于 2024-05-21 10:23:42 发布

小郑在努力ing

最新推荐文章于 2024-05-21 10:23:42 发布

阅读量99

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_53999102/article/details/128908737

版权

JavaSE 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

常用类

根据源码学习

构造器 -> 字段 -> 方法

一、System类

java.lang.System 系统

常用方法

currentTimeMillis():获取从1970-01-01 00:00:00到现在的毫秒数

exit(0):退出java虚拟机 0代表正常退出，否则异常退出

getenv(String)：获取指定的环境变量

getProperty(String):获取系统属性

getProperties():获取所有系统属性

arraycopy(源,源索引,目标,目标索引,长度):从源数组指定索引位置复制给定长度到目标数组的索引位置

gc()：执行垃圾回收
```
//学习数组的时候，自己写过数组拷贝的代码
 public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos, int length);

//查询当前系统时间
System.currentTimeMillis();
public static native long currentTimeMillis();

//垃圾回收器
public static void gc() {
    Runtime.getRuntime().gc();
}
```

二、String 字符串类

2.1 简介

String 不是基本数据类型，是一种引用类型
String代表一组不可改变的Unicode字符序列。String对象一旦被初始化，不能再改变
String类是final修饰的终结类，不能产生子类

2.2 创建String

静态方式创建：String str = “abc”；在方法区常量池中产生唯一一个字符串对象，如果有另一个引用指向了相同的字符串，则两个引用变量的地址相同

动态方式创建：String str = new String(“abc”); 在堆内存中会产生一个不同的对象，会产生两个对象

2.3 构造方法

new String()；
new String(“abc”)；
new String(char类型数组);
new String( char类型数组，数组下标起始位置，取出数组的长度);
new String( byte数组);
new String( byte类型数组，数组下标起始位置，取出数组的长度);

构造器

//无参构造器
public String() {
    //做了数组初始化
    this.value = new char[0];
}
//带一个参数
public String(String original) {
    //给char 数组赋值
    this.value = original.value;
    //缓存String 的 hash 值
    this.hash = original.hash;
}
//传递 char 类型数组
public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

字段

/** The value is used for character storage. */
//存储字符的数组
private final char value[];

/** Cache the hash code for the string */
//缓存 hash code
private int hash; // Default to 0

方法

//查看字符串长度
public int length() {
    return value.length;
}
//判断是否为空
public boolean isEmpty() {
    return value.length == 0;
}
//返回一个索引对应字符值
public char charAt(int index) {
    return value[index];
}
//判断是否包含一个字符
public boolean contains(CharSequence s) {
    return indexOf(s.toString()) > -1;
}
//获取byte[]
public byte[] getBytes() {
    return StringCoding.encode(value, 0, value.length);
}
//以什么开头
public boolean startsWith(String prefix) {
    return startsWith(prefix, 0);
}
//以什么结尾
public boolean endsWith(String suffix) {
    return startsWith(suffix, value.length - suffix.value.length);
}
//equals 方法
equals(Object obj)
//以什么什么断开
public String[] split(String regex) {
    return split(regex, 0);
}
//去掉空字符串 “   abc   ”
public String trim() {}

2.4 常用方法

length( ) 返回int 类型的值，获取字符串长度
equals( ) 判断两个字符串中的字面量值是否相等
equalslgnoreCase(String) 不区分大小写比较字面量值是否相等
indexOf(int)
indexOf(String) 查找给定值在字符串第一次出现的下标位置，如果不存在，则返回-1
indexOf(int,int)
indexOf(String,int):查找给定值在字符串中给定索引位置开始，第一次出现的下标位置。如果值不存在，则返回-1
lastIndexOf(int):
lastIndexOf(String):查找给定值在字符串中最后一次出现的下标位置。如果值不存在，则返回-1
lastIndexOf(int,int):
lastIndexOf(String,int):查找给定值在字符串中给定索引位置开始，最后一次出现的下标位置。如果值不存在，则返回-1
toUpperCase():将字符串中所有字符都转换为大写
toLowerCase():将字符串中所有字符都转换为小写
charAt(int):返回下标引处的char值
substring(int):对字符串进行截取，从指定索引位置开始，一直截取到最后
substring(int,int): 对字符串进行截取，从指定开始位置，截取到结束位置(不包含结束位置)
trim():将字符串前后空格去除
concat(String)：字符串连接和+实现相同的功能，如果字符串是null值不能使用，并且只能传字符串参数，其他类型不可以使用
getBytes():将字符串转换成byte数组
toCharArray():将字符串转换成char数组
contains(String)：判断在字符串是否包含给定值，返回boolean类型的值
startsWith(String):判断字符串是否以给定值做为开始
startsWith(String,int):判断字符串从索引位置，是否以给定值做为开始
endsWith(String):判断字符串是否以给定值做为结束
replace(char,char):对字符串指定字符，使用新的字符进行替换
replace( CharSequence, CharSequence):对字符串指定的字符序列，使用新的字符序列进行替换
replaceAll(String,String)：按正则表达式要求，将给定的值替换满足正则的字符串
split(String)：按给定的正则表达式，将字符串分隔成字符串数组
maches(String):判断字符串是否可以匹配给定的正则表达式
contentEquals(CharSequence)
contentEquals(StringBuffer):字符串和StringBuffer或者字符序列比较内容
Pattern.matcher(String,String):和字符串maches()方法执行相同结果

三、StringBuffer

内容可变的字符串类，使用StringBuffer来对字符串的内容进行动态操作，不会产生额外的现象

初始时，默认是有16个字符来作为缓冲区

使用synchronized修饰，是线程安全的

3.1 构造方法

new StringBuffer();
new StringBuffer(String)
new StringBuffer(int)
new StringBUffer(charSequence)

3.2 常用方法

append():在当前StringBuffer对象上，追加其他内容
capacity():返回当前容量
length():返回长度
setCharAt(int,char):将给定索引位置的字符设置为第二个参数给定的值
reverse():将StringBuffer内容反转
delete(int,int):删除StringBuffer从指定索引开始(包含)到结束(不包含)的字符串
toString():将StringBuffer转成字符串
insert(int,Object):在指定索引位置，插入给定值
replace(int,int,String):将指定的字符串替换到起始位置(包含)和结束位置(不包含)中
deleteCharAt(int):删除指定索引位置的字符

四、 StringBuilder（字符缓冲区）

线程是不安全的，单线程操作效率最高

StringBuilder 也是final 修饰的不可以不继承
里面的 char[] 数组不是使用 final 修饰的，可以替换

构造器

//默认的数组长度为16
public StringBuilder() {
    super(16);
}
//指定容量
public StringBuilder(int capacity) {
    super(capacity);
}

方法

//做char[] 的拷贝或者拼接
@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;//放回当前对象
}

//将 StringBuilder 对象转换成字符串对象
@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

字段

/**
* The value is used for character storage.
*/
char[] value;

/**
* The count is the number of characters used.
*/
int count;

五、Math类

5.1 简介

提供了大量用于数学运算的相关方法
使用final修饰的终结类，不能产生子类
方法都是static修饰的静态方法，可以通过类名.方法名直接调用

5.2 常用方法

abs(int)：求绝对值(int,long,float,double做为参数)
ceil(double):求大于等于给定值的最小整数值，以double类型返回
floor(double):求小于等于给定值的最大整数值，以double类型返回
max(int,int)：求两个数字中最大的值(int long float double做为参数)
min(int,int)：求两个数字中最小的值(int long float double做为参数)
random()：获取一个0到1之间的随机小数
round(float|double):返回int或long，采用四舍五入法，获取最接近的整数值
sqrt(double)：获取平方根,如果传值为负数，返回NaN
pow(double,double):求一个数的N次方
sin(double)/cos(double)/tan(double)：获取给定弧度值的三角函数值

六、Random类

6.1 简介

java.util下有一个Random类，根据随机算法的起源数字（种子）进行一些迭代变化，来产生随机数。

虽然Random产生的数字是随机的，但在相同种子数下的相同次数产生的随机数是相同的(伪随机)

//伪随机数验证
Random random=new Random(100);
Random random1=new Random(100);
int num=random.nextInt();
int num1=random1.nextInt();
System.out.println("num = " + num);
System.out.println("num1 = " + num1);

6.2 常用方法

nextInt():获取int类型的随机数

nextInt(int)：获取0(包含)到给定值(不包含)之间的随机数

**nextlong()：获取long类型的随机数 **

nextfloat():获取一个随机单精度浮点数0到1之间

nextDouble()：获取一个随机双精度浮点数 0到1之间

nextBoolean(): 返回一个随机boolean类型的值，true或false，概率相同

七、BigInteger和BigDecimal

7.1 简介

BigInteger可以支持任意长度的整数
BigDecimal可以支持任意精度的浮点数
用来做精确计算

7.2 创建方式

new BigInteger();

new BigInteger(参数1,进制)：可以将不同进制转成10进制显示

new BigDecimal();

BigInteger.valueOf();

BigDecimal.valueOf();

Scanner对象的nextBigInteger() nextBigDecimal();

7.3 常用方法

add()：加法

intValue()：将BigInteger转成int类型值

doubleValue():将BigDecimal转成double类型值

substract()：减法

multiply()：乘法

divide()：除法，BigInteger只保留整数。BigDecimal用法是和BigInteger完全不同

remainder():求余数

divideAndRemainder():求除法商和余数，返回的是BigInteger数组

max()：求大值

min()：求小值

public BigInteger add(BigInteger val) {}

public BigInteger subtract(BigInteger val) {}

public BigInteger multiply(BigInteger val) {}

public BigInteger divide(BigInteger val) {}

八、Date类

java.util.Date.表示指定的时间信息，不支持国际化

构造方法

new Date()：当前系统日期和时间

new Date(long)：给定日期和时间

主要方法：

after(Date):判断当前日期对象是否在给定日期对象之后

before(Date):判断当前日期对象是否在给定日期对象之前

equals(Object):判断两个日期是否相等

compareTo(Date)：比较两个日期的顺序，如果当前日期对象大于给定日期对象，返回正数，如果小于给定日期对象，返回负数，如果等于给定日期对象，返回零

//构造方法 创建当前日期对象
public Date() {
    this(System.currentTimeMillis());
}

//打印符合我们本地人观看的时间日期
@Deprecated
public String toLocaleString() {
    DateFormat formatter = DateFormat.getDateTimeInstance();
    return formatter.format(this);
}

8.1 Dateformat

对日期类型进行格式化和解析

DateFormat本身是一个抽象类，实例化的方式

一种是通过静态方法的调用,处理的是长日期和长时间类型

getDateInstance()
getTimeInstance()
getDateTimeInstance()

一种是通过创建子类对象

创建SimpleDateFormat对象，处理的是短日期和短时间类型

8.2 可以自定义格式：

yyyy-MM-dd
yyyy-MM-dd HH:mm:ss

字母	含义	示例
y	年份。一般用 yy 表示两位年份，yyyy 表示 4 位年份	使用 yy 表示的年扮，如 11；使用 yyyy 表示的年份，如 2011
M	月份。一般用 MM 表示月份，如果使用 MMM，则会根据语言环境显示不同语言的月份	使用 MM 表示的月份，如 05；使用 MMM 表示月份，在 Locale.CHINA 语言环境下，如“十月”；在 Locale.US 语言环境下，如 Oct
d	月份中的天数。一般用 dd 表示天数	使用 dd 表示的天数，如 10
D	年份中的天数。表示当天是当年的第几天，用 D 表示	使用 D 表示的年份中的天数，如 295
E	星期几。用 E 表示，会根据语言环境的不同，显示不同语言的星期几	使用 E 表示星期几，在 Locale.CHINA 语言环境下，如“星期四”；在 Locale.US 语言环境下，如 Thu
H	一天中的小时数（0~23)。一般用 HH 表示小时数	使用 HH 表示的小时数，如 18
h	一天中的小时数（1~12)。一般使用 hh 表示小时数	使用 hh 表示的小时数，如 10 (注意 10 有可能是 10 点，也可能是 22 点）
m	分钟数。一般使用 mm 表示分钟数	使用 mm 表示的分钟数，如 29
s	秒数。一般使用 ss 表示秒数	使用 ss 表示的秒数，如 38
S	毫秒数。一般使用 SSS 表示毫秒数	使用 SSS 表示的毫秒数，如 156

8.3 常用方法

把日期变成字符串

 public final String format(Date date)

把字符串变成日期

 public Date parse(String source)

创建一个日期格式类的对象 new + 构造器(“日期格式”)

SimpleDateFormat format = new SimpleDateFormat(“yyyy-MM-dd”);

九、Calendar 日历类

一个抽象类

//获取实例对象
Calendar calendar=Calendar.getInstance();
/*calendar.set(2000,Calendar.MAY,12);//设置年月日
calendar.set(Calendar.HOUR_OF_DAY,9);//设置小时
//获取年份 月份 日期
int year = calendar.get(Calendar.YEAR);
System.out.println("year = " + year);
int month = calendar.get(Calendar.MONTH)+1;//0-11
System.out.println("month = " + month);
int date = calendar.get(Calendar.DATE);
System.out.println("date = " + date);
int week = calendar.get(Calendar.DAY_OF_WEEK);//一周的第几天
System.out.println("week = " + week);//从周日开始是第1天
int day = calendar.get(Calendar.DAY_OF_MONTH);//一个月的第几天
System.out.println("day = " + day);
int dy = calendar.get(Calendar.DAY_OF_YEAR);
System.out.println("dy = " + dy);
int hour = calendar.get(Calendar.HOUR);//12小时制的
System.out.println("hour = " + hour);
int hour1=calendar.get(Calendar.HOUR_OF_DAY);//24小时制
System.out.println("hour1 = " + hour1);
int minute = calendar.get(Calendar.MINUTE);
System.out.println("minute = " + minute);
int second = calendar.get(Calendar.SECOND);
System.out.println("second = " + second);*/
//Calendar转Date
//Date time = calendar.getTime();
//System.out.println(DateUtil.getSystemDateTime(time));
//Date转成Calender
Date date= DateUtil.parse("yyyy-MM-dd HH:mm:ss","2012-01-3110:10:23");
calendar.setTime(date);

获取日历对象
```
public static Calendar getInstance()
```

获取当前时间

public final Date getTime() {
    return new Date(getTimeInMillis());
}

十、GregorianCalendar

格里高利历是公历的标准名称，教皇格里高利十三世于1582年颁布。公历纪元，又称“西元”

儒略历：公元前45年1月1日起执行的一种历法。一年12个月，大小月交替，四年一闰，平年365日，闰年366天。年平均长度365.25天。

1949年9月27日，中国政协通过，采用国际社会通用的西历和西元作业历法和纪年。

四年一闰，百年不闰，四百年一大闰

年均长度365天5小时49分12秒，按此计算方式，3000年左右误差一天。

判断闰年的方法 isLeapYear(int)，返回一个boolean类型的值，1582年后，计算方式不同

十一、JDK8新增日期工具类

LocalDate:获取本地日期

LocalTime:获取本地时间

LocalDateTime：获取本地日期和时间

public class Test1 {
    public static void main(String[] args) {
        //获取当前系统日期和时间
        LocalDate date=LocalDate.now();
        System.out.println(date);
        LocalTime time=LocalTime.now();
        System.out.println(time);
        LocalDateTime dateTime=LocalDateTime.now();
        System.out.println(dateTime);
        //自定义设置系统日期和时间
        LocalDate date1=LocalDate.of(2022,9,2);
        System.out.println(date1);
        LocalTime time1=LocalTime.of(19,30,30);
        System.out.println(time1);
        LocalDateTime dateTime1=LocalDateTime.of(date1,time1);
        System.out.println(dateTime1);
        LocalDateTime dateTime2=LocalDateTime.of(2022,9,2,19,30,30);
        System.out.println(dateTime2);
    }
}

单独获取日期时间类中的每个值

public class Test2 {
    public static void main(String[] args) {
        LocalDateTime dateTime=LocalDateTime.now();
        //获取年份
        int year = dateTime.getYear();
        System.out.println("year = " + year);
        //获取月份
        Month month = dateTime.getMonth();
        System.out.println("month = " + month.getValue());
        System.out.println("month = "+dateTime.getMonthValue());
        //获取第几天
        int dayOfMonth = dateTime.getDayOfMonth();
        System.out.println("dayOfMonth = " + dayOfMonth);
        //获取星期几
        DayOfWeek dayOfWeek = dateTime.getDayOfWeek();
        System.out.println("dayOfWeek = " + dayOfWeek.getValue());
        //获取小时
        int hour = dateTime.getHour();
        System.out.println("hour = " + hour);
        //获取分钟
        int minute=dateTime.getMinute();
        System.out.println("minute = " + minute);
        //获取秒钟
        int second = dateTime.getSecond();
        System.out.println("second = " + second);
    }
}

使用给定值修改日期

public class Test3 {
    public static void main(String[] args) {
        LocalDate date=LocalDate.now();
        System.out.println(date);
        //获取本月的第10天
        LocalDate date1=date.withDayOfMonth(30);
        date1=date.withYear(2021)//修改年龄为2021年
        .withDayOfMonth(10)//修改日期为10号
        .withMonth(4);//修改月份为4月 2021-04-10
        date1=date.withDayOfYear(360);//修改日期为这一年的第360天
        System.out.println("date1 = " + date1);
    }
}

设置日期和时间的偏移量

public class Test4 {
    public static void main(String[] args) {
        LocalDateTime dateTime=LocalDateTime.now();
        System.out.println(dateTime);
        //3天后的时间
            LocalDateTime dateTime1 = dateTime.plusDays(3);
        //2天前的时间
        dateTime1=dateTime.minusDays(2);
        //2个月后的时间
        dateTime1=dateTime.plusMonths(2);
        //3年后的时间
        dateTime1=dateTime.plusYears(3);
        //4周之前的时间
        dateTime1=dateTime.minusWeeks(4);
        //4小时之后的时间
        dateTime1=dateTime.plusHours(4);
        System.out.println(dateTime1);
    }
}

十二、Instant类

代表时间点，获取日期变更子午线时间

public class Test5 {
    public static void main(String[] args) {
        /* Instant instant=Instant.now();
        System.out.println(instant);//
        //获取时间戳
        long l = instant.toEpochMilli();
        System.out.println(l);
        System.out.println(System.currentTimeMillis());*/
        /*Instant max = Instant.MAX;
        System.out.println(max);
        Instant min=Instant.MIN;
        System.out.println(min);*/
        Instant instant=Instant.now();
        //具有偏移量的日期时间对象
        //东八区
        OffsetDateTime dateTime = instant.atOffset(ZoneOffset.of("+8"));
        dateTime=instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(dateTime);
        //将OffsetDateTime转成LocalDateTime
        LocalDateTime dateTime1=dateTime.toLocalDateTime();
        System.out.println(dateTime1);
        //将时间戳转为Instant
        Instant instant1=Instant.ofEpochMilli(System.currentTimeMillis());
        System.out.println(instant1);
    }
}

DateTimeFormatter格式化和解析

public class Test6 {
    public static void main(String[] args) {
        //将LocalDate转换成字符串String格式
        DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        LocalDate date=LocalDate.now();
        String s = formatter.format(date);
        System.out.println(s);
        //将LocalDateTime转换成字符串String格式
        formatter=DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        LocalDateTime localDateTime = LocalDateTime.now();
        String s1 = formatter.format(localDateTime);
        System.out.println("s1 = " + s1);
        //将时间戳转换成字符串日期格式
        long x= Instant.now().toEpochMilli();
        LocalDateTime dateTime =
        LocalDateTime.ofInstant(Instant.ofEpochMilli(x)
        , ZoneId.systemDefault());
        String s2=formatter.format(dateTime);
        System.out.println("s2 = " + s2);
        /* System.out.println(ZoneId.systemDefault());
        System.out.println("dateTime = " + dateTime);*/
        //将字符解析成日期
        formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd");
        String s4="2022-09-01";
        LocalDate parse1 = LocalDate.parse(s4, formatter);
        System.out.println("parse1 = " + parse1);
        //将字符解析成日期时间
        formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String s3="2022-05-01 12:20:30";
        LocalDateTime parse = LocalDateTime.parse(s3,formatter);
        System.out.println("parse = " + parse);
    }
}

Period 计算两个"日期"之间的间隔，得到的是年月日，假设 2022年9月2日和2021年2月1日去计算，得到相关1年7月1天，没有办法知道具体是多少天。

public class Test7 {
    public static void main(String[] args) {
        LocalDate date1=LocalDate.of(1949,10,1);
        LocalDate date2=LocalDate.now();
        /*
        Period x = Period.between(date1, date2);
        System.out.println(x.getYears()); //获取相差年份
        System.out.println(x.getMonths()); //获取相差月份
        System.out.println(x.getDays()); //获取相差天数
        */
        //计算两个日期相差天数方法1
        long days = ChronoUnit.DAYS.between(date1, date2);
        System.out.println("days = " + days);
        //计算两个日期相差天数方法2
        long days1 = date2.toEpochDay() - date1.toEpochDay();
        System.out.println("days1 = " + days1);
    }
}

Duration计算两个日期时间的间隔

public class Test8 {
    public static void main(String[] args) {
        LocalDateTime dateTime=LocalDateTime.
        of(1922,7,10,10,10,5);
        LocalDateTime now=LocalDateTime.now();
        //计算方式1
        Duration duration = Duration.between(dateTime, now);
        /* System.out.println(duration.toDays());//计算两个日期时间相差的天数
        System.out.println(duration.toHours());//计算两个日期时间相差的小时
        System.out.println(duration.toSeconds());//计算两个日期时间相差的秒数
        System.out.println(duration.getSeconds());//和上面相同*/
        //计算方式2
        /*long days = dateTime.until(now, ChronoUnit.DAYS);
        System.out.println("days = " + days);
        long hours = dateTime.until(now, ChronoUnit.HOURS);
        System.out.println("hours = " + hours);
        long months = dateTime.until(now, ChronoUnit.MONTHS);
        System.out.println("months = " + months);*/
        //计算方式3
        long years = ChronoUnit.YEARS.between(dateTime, now);
        System.out.println("years = " + years);
        long hours = ChronoUnit.HOURS.between(dateTime, now);
        System.out.println("hours = " + hours);
        long centuries= ChronoUnit.CENTURIES.between(dateTime, now);
        System.out.println("centuries = " + centuries);
    }
}

时间调节器

public class Test9 {
    public static void main(String[] args) {
        LocalDate date=LocalDate.now();
        //获取本周一时间
        LocalDate date1 = date.with(DayOfWeek.MONDAY);
        //获取下周一时间
        date1=date.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
        //获取本月第一天
        date1=date.with(TemporalAdjusters.firstDayOfMonth());
        //获取本月最后一天
        date1=date.with(TemporalAdjusters.lastDayOfMonth());
        //获取本年第一天
        date1=date.with(TemporalAdjusters.firstDayOfYear());
        System.out.println(date1);
    }
}

Date类和LocalDate（LocalTime\LocalDateTime）转换

public class Test10 {
    public static void main(String[] args) {
        /*//将LocalDate转成Date
        LocalDate date2=LocalDate.now();
        ZonedDateTime zonedDateTime1 = date2.atStartOfDay().atZone(ZoneId.systemDefault());
        Instant instant = zonedDateTime1.toInstant();
        Date date1=Date.from(instant);
        String s = new SimpleDateFormat("yyyy-MM-dd").format(date1);
        System.out.println(s);
        //将LocalDateTime转成Date类型
        LocalDateTime date=LocalDateTime.now();
        ZonedDateTime zonedDateTime = date.atZone(ZoneId.systemDefault());
        Instant instant1 = zonedDateTime.toInstant();
        Date date3= Date.from(instant1);
        String s1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date3);
        System.out.println(s1);*/
        //Date转成LocalDate
        /*Date date4=new Date();
        ZonedDateTime zonedDateTime =  date4.toInstant().atZone(ZoneId.systemDefault());
        LocalDate date5=zonedDateTime.toLocalDate();
        System.out.println(date5);*/
        //Date转成LocalDateTime
        Date date6=new Date();
        ZonedDateTime zonedDateTime =  date6.toInstant().atZone(ZoneId.systemDefault());
        LocalDateTime date7=zonedDateTime.toLocalDateTime();
        LocalTime time=zonedDateTime.toLocalTime();//转成localtime
        System.out.println(date7);
    }
}