一、 StringBuilder类
StringBuilder代表可变字符串对象，相当于是一个容器，它里面的字符串是可以改变的，就是用来操作字符串的。
好处：StringBuilder比String更合适做字符串的修改操作，效率更高，代码也更加简洁。
接下来我们用代码演示一下StringBuilder的用法:
package com.itheima.test01;public class Test2 {public static void main(String[] args) {StringBuilder sb = new StringBuilder("itehima");//1.拼接内容sb.append(12);sb.append("黑马");sb.append(true);//2.append方法，支持临时编程sb.append(666).append("黑马2").append(666);System.out.println(sb); //打印：itehima12黑马true666黑马2666//3.反转操作sb.reverse();System.out.println(sb); //打印：6662马黑666eurt马黑21amiheti//4.返回字符串的长度System.out.println(sb.length()); //打印： 24//5.StringBuilder还可以转换为字符串String s = sb.toString();System.out.println(s); //打印：6662马黑666eurt马黑21amiheti}
}
为什么要用StringBuilder对字符串进行操作呢？因为它的效率比String更高。
经过我的验证，直接使用String拼接100万次，等了1分钟，还没结束，我等不下去了；但是使用StringBuilder做拼接，不到1秒钟出结果了。
二、StringJoiner类
学习这个类干嘛用呢？是因为我们前面使用StringBuilder拼接字符串的时，代码写起来还是有一点麻烦，而StringJoiner号称是拼接神器，不仅效率高，而且代码简洁。
下面演示一下StringJoiner的基本使用:
public class Test{public static void main(String[] args){StringJoiner s = new StringJoiner(",");s.add("java1");s.add("java2");s.add("java3");System.out.println(s); //结果为： java1,java2,java3//参数1：间隔符//参数2：开头//参数3：结尾StringJoiner s1 = new StringJoiner(",","[","]");s1.add("java1");s1.add("java2");s1.add("java3");System.out.println(s1); //结果为： [java1,java2,java3]}
}三、Math类
Math是数学的意思，该类提供了很多个进行数学运算的方法，如求绝对值，求最大值，四舍五入等，话不多说，直接上代码。
public class MathTest {public static void main(String[] args) {// 目标：了解下Math类提供的常见方法。// 1、public static int abs(int a)：取绝对值（拿到的结果一定是正数）// public static double abs(double a)System.out.println(Math.abs(-12)); // 12System.out.println(Math.abs(123)); // 123System.out.println(Math.abs(-3.14)); // 3.14// 2、public static double ceil(double a): 向上取整System.out.println(Math.ceil(4.0000001)); // 5.0System.out.println(Math.ceil(4.0)); // 4.0// 3、public static double floor(double a): 向下取整System.out.println(Math.floor(4.999999)); // 4.0System.out.println(Math.floor(4.0)); // 4.0// 4、public static long round(double a)：四舍五入System.out.println(Math.round(3.4999)); // 3System.out.println(Math.round(3.50001)); // 4// 5、public static int max(int a, int b)：取较大值// public static int min(int a, int b)：取较小值System.out.println(Math.max(10, 20)); // 20System.out.println(Math.min(10, 20)); // 10// 6、 public static double pow(double a, double b)：取次方System.out.println(Math.pow(2, 3)); // 2的3次方 8.0System.out.println(Math.pow(3, 2)); // 3的2次方 9.0// 7、public static double random()： 取随机数 [0.0 , 1.0) (包前不包后)System.out.println(Math.random());}
}四、 System类
这是系统类，提供了一些获取获取系统数据的方法。比如获取系统时间。
public class SystemTest {public static void main(String[] args) {// 1、public static void exit(int status):// 终止当前运行的Java虚拟机。// 该参数用作状态代码; 按照惯例，非零状态代码表示异常终止。System.exit(0); // 人为的终止虚拟机。(不要使用)// 2、public static long currentTimeMillis():// 获取当前系统的时间// 返回的是long类型的时间毫秒值：指的是从1970-1-1 0:0:0开始走到此刻的总的毫秒值，1s = 1000mslong time = System.currentTimeMillis();System.out.println(time);for (int i = 0; i < 1000000; i++) {System.out.println("输出了：" + i);}long time2 = System.currentTimeMillis();System.out.println((time2 - time) / 1000.0 + "s");}
}五、Runtime类
我们再学习一个Java的运行时类，叫Runtime类。这个类可以用来获取JVM的一些信息，也可以用这个类去执行其他的程序。话不多少，上代码。
package com.itheima.test01;import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException, InterruptedException {// 1、public static Runtime getRuntime() 返回与当前Java应用程序关联的运行时对象。Runtime r = Runtime.getRuntime();// 2、public void exit(int status) 终止当前运行的虚拟机,该参数用作状态代码; 按照惯例，非零状态代码表示异常终止。// r.exit(0);// 3、public int availableProcessors(): 获取虚拟机能够使用的处理器数。System.out.println(r.availableProcessors());// 4、public long totalMemory() 返回Java虚拟机中的内存总量。System.out.println(r.totalMemory()/1024.0/1024.0 + "MB"); // 1024 = 1K 1024 * 1024 = 1M// 5、public long freeMemory() 返回Java虚拟机中的可用内存量System.out.println(r.freeMemory()/1024.0/1024.0 + "MB");// 6、public Process exec(String command) 启动某个程序，并返回代表该程序的对象。// r.exec("D:\\soft\\XMind\\XMind.exe");Process p = r.exec("D:\\qq\\Bin\\QQScLauncher.exe");Thread.sleep(5000); // 让程序在这里暂停5s后继续往下走！！p.destroy(); // 销毁！关闭程序！ 这里并不是把QQ关了，是把当前程序关闭，不要误解。//上面三个输出： 12// 252.0MB// 248.67017364501953MB}
}
六、BigDecimal类
为了解决计算精度损失的问题，Java给我们提供了BigDecimal类，它提供了一些方法可以对数据进行四则运算，而且不丢失精度，同时还可以保留指定的小数位。下面看代码，演示一下:
public class Test2 {public static void main(String[] args) {double a = 0.1;double b = 0.2;// 1、把浮点型数据封装成BigDecimal对象，再来参与运算。// a、public BigDecimal(double val) 得到的BigDecimal对象是无法精确计算浮点型数据的。 注意：不推荐使用这个，// b、public BigDecimal(String val) 得到的BigDecimal对象是可以精确计算浮点型数据的。 可以使用。// c、public static BigDecimal valueOf(double val): 通过这个静态方法得到的BigDecimal对象是可以精确运算的。是最好的方案。BigDecimal a1 = BigDecimal.valueOf(a);BigDecimal b1 = BigDecimal.valueOf(b);// 2、public BigDecimal add(BigDecimal augend): 加法BigDecimal c1 = a1.add(b1);System.out.println(c1);//0.3// 3、public BigDecimal subtract(BigDecimal augend): 减法BigDecimal c2 = a1.subtract(b1);System.out.println(c2);//-0.1// 4、public BigDecimal multiply(BigDecimal augend): 乘法BigDecimal c3 = a1.multiply(b1);System.out.println(c3);//0.02// 5、public BigDecimal divide(BigDecimal b): 除法BigDecimal c4 = a1.divide(b1);System.out.println(c4);//0.5// 6、public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式) : 除法，可以设置精确几位。BigDecimal d1 = BigDecimal.valueOf(0.1);BigDecimal d2 = BigDecimal.valueOf(0.3);BigDecimal d3 = d1.divide(d2, 2, RoundingMode.HALF_UP); // 0.33System.out.println(d3);//0.33// 7、public double doubleValue() : 把BigDecimal对象又转换成double类型的数据。double db1 = d3.doubleValue();double db2 = c1.doubleValue();print(db1);//0.33print(db2);//0.3}public static void print(double a){System.out.println(a);}
}五、Date类
Java中是由这个类的对象用来表示日期或者时间。
Date对象记录的时间是用毫秒值来表示的。Java语言规定，1970年1月1日0时0分0秒认为是时间的起点，此时记作0，那么1000（1秒=1000毫秒）就表示1970年1月1日0时0分1秒，依次内推。
下面是Date类的构造方法，和常见的成员方法，利用这些API写代码尝试一下:
public class Test1Date {public static void main(String[] args) {// 1、创建一个Date的对象：代表系统当前时间信息的。Date d = new Date();System.out.println(d);//Fri Feb 09 22:21:27 CST 2024// 2、拿到时间毫秒值。long time = d.getTime();System.out.println(time);//1707488487399// 3、把时间毫秒值转换成日期对象： 2s之后的时间是多少。time += 2 * 1000;Date d2 = new Date(time);System.out.println(d2);//Fri Feb 09 22:21:29 CST 2024// 4、直接把日期对象的时间通过setTime方法进行修改Date d3 = new Date();d3.setTime(time);System.out.println(d3);//Fri Feb 09 22:21:29 CST 2024}
}六、SimpleDateFormat类
我们学习的SimpleDateFormat类就可以转换Date对象表示日期时间的显示格式。
我们把Date对象转换为指定格式的日期字符串这个操作，叫做日期格式化，反过来把指定格式的日期符串转换为Date对象的操作，叫做日期解析。
接下来，我们先演示一下日期格式化，需要用到如下的几个方法:
注意：创建SimpleDateFormat对象时，在构造方法的参数位置传递日期格式，而日期格式是由一些特定的字母拼接而来的。我们需要记住常用的几种日期/时间格式:
字母 表示含义
yyyy 年
MM 月
dd 日
HH 时
mm 分
ss 秒
SSS 毫秒"2022年12月12日" 的格式是 "yyyy年MM月dd日"
"2022-12-12 12:12:12" 的格式是 "yyyy-MM-dd HH:mm:ss"
按照上面的格式可以任意拼接，但是字母不能写错
最后，上代码演示一下:
public class Test2SimpleDateFormat {public static void main(String[] args) throws ParseException {// 1、准备一些时间Date d = new Date();System.out.println(d);//Sat Feb 10 09:32:52 CST 2024long time = d.getTime();System.out.println(time);//1707528772933// 2、格式化日期对象，和时间 毫秒值。SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");//EEE代表周几的意思，a代表上下午的意思。String rs = sdf.format(d);String rs2 = sdf.format(time);System.out.println(rs);//2024年02月10日 09:32:52 周六 上午System.out.println(rs2);//2024年02月10日 09:32:52 周六 上午System.out.println("----------------------------------------------");// 目标：掌握SimpleDateFormat解析字符串时间 成为日期对象。String dateStr = "2022-12-12 12:12:11";// 1、创建简单日期格式化对象 , 指定的时间格式必须与被解析的时间格式一模一样，否则程序会出bug.SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date d2 = sdf2.parse(dateStr);System.out.println(d2);//Mon Dec 12 12:12:11 CST 2022}
}七、Calendar类
我们再学习一个和日期相关的类，它是Calendar类。Calendar类表示日历，它提供了一些比Date类更好用的方法。
Calendar类提供了方法可以直接对日历中的年、月、日、时、分、秒等进行运算。
该类的常见方法：
public class Test4Calendar {public static void main(String[] args) {// 1、得到系统此刻时间对应的日历对象。Calendar now = Calendar.getInstance();System.out.println(now);//java.util.GregorianCalendar[time=1707529640644,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=1,WEEK_OF_YEAR=6,//WEEK_OF_MONTH=2,DAY_OF_MONTH=10,DAY_OF_YEAR=41,DAY_OF_WEEK=7,DAY_OF_WEEK_IN_MONTH=2,AM_PM=0,HOUR=9,HOUR_OF_DAY=9,//MINUTE=47,SECOND=20,MILLISECOND=644,ZONE_OFFSET=28800000,DST_OFFSET=0]// 2、获取日历中的某个信息int year = now.get(Calendar.YEAR);System.out.println(year);//2024int days = now.get(Calendar.DAY_OF_YEAR);//一年中的第多少天System.out.println(days);//41// 3、拿到日历中记录的日期对象。Date d = now.getTime();System.out.println(d);//Sat Feb 10 09:47:20 CST 2024// 4、拿到时间毫秒值long time = now.getTimeInMillis();System.out.println(time);//1707529640644// 5、修改日历中的某个信息now.set(Calendar.MONTH, 9); // 修改月份成为10月份。now.set(Calendar.DAY_OF_YEAR, 125); // 修改成一年中的第125天。System.out.println(now);// 6、为某个信息增加或者减少多少now.add(Calendar.DAY_OF_YEAR, 100);now.add(Calendar.DAY_OF_YEAR, -10);now.add(Calendar.DAY_OF_MONTH, 6);now.add(Calendar.HOUR, 12);now.set(2026, 11, 22);System.out.println(now);}
}八、为什么JDK8要新增日期类
传统的时间类（Date、SimpleDateFormat、Calendar）存在如下问题：
1、设计不合理，使用不方便，很多都被淘汰了。2、都是可变对象，修改后会丢失最开始的时间信息。
3、线程不安全。
4、不能精确到纳秒，只能精确到毫秒。
1秒 = 1000毫秒
1毫秒 = 1000微妙
1微妙 = 1000纳秒
九、JDK8日期、时间、日期时间
JDK8新增的日期类分得更细致一些，比如表示年月日用LocalDate类、表示时间秒用LocalTime类、而表示年月日时分秒用LocalDateTime类等；除了这些类还提供了对时区、时间间隔进行操作的类等。它们几乎把对日期/时间的所有操作都通过了API方法，用起来特别方便。
先学习表示日期、时间、日期时间的类；有LocalDate、LocalTime、以及LocalDateTime类。仔细阅读代码，你会发现这三个类的用法套路都是一样的。
LocalDate类的基本使用：
public class Test1_LocalDate {public static void main(String[] args) {// 0、获取本地日期对象(不可变对象)LocalDate ld = LocalDate.now(); // 年 月 日System.out.println(ld);//2024-02-10// 1、获取日期对象中的信息int year = ld.getYear(); // 年int month = ld.getMonthValue(); // 月(1-12)int day = ld.getDayOfMonth(); // 日int dayOfYear = ld.getDayOfYear(); // 一年中的第几天int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几System.out.println(year);//2024System.out.println(day);//10System.out.println(dayOfWeek);//6System.out.println(ld.getDayOfWeek());//6 SATURDAY// 2、直接修改某个信息: withYear、withMonth、withDayOfMonth、withDayOfYearLocalDate ld2 = ld.withYear(2099);LocalDate ld3 = ld.withMonth(12);System.out.println(ld2);//2099-02-10System.out.println(ld3);//2024-12-10System.out.println(ld);//2024-02-10// 3、把某个信息加多少: plusYears、plusMonths、plusDays、plusWeeksLocalDate ld4 = ld.plusYears(2);LocalDate ld5 = ld.plusMonths(2);// 4、把某个信息减多少：minusYears、minusMonths、minusDays、minusWeeksLocalDate ld6 = ld.minusYears(2);LocalDate ld7 = ld.minusMonths(2);// 5、获取指定日期的LocalDate对象： public static LocalDate of(int year, int month, int dayOfMonth)LocalDate ld8 = LocalDate.of(2099, 12, 12);LocalDate ld9 = LocalDate.of(2099, 12, 12);// 6、判断2个日期对象，是否相等，在前还是在后： equals isBefore isAfterSystem.out.println(ld8.equals(ld9));// trueSystem.out.println(ld8.isAfter(ld)); // trueSystem.out.println(ld8.isBefore(ld)); // false}
}LocalTime类的基本使用：
public class Test2_LocalTime {public static void main(String[] args) {// 0、获取本地时间对象LocalTime lt = LocalTime.now(); // 时 分 秒 纳秒 不可变的System.out.println(lt);// 1、获取时间中的信息int hour = lt.getHour(); //时int minute = lt.getMinute(); //分int second = lt.getSecond(); //秒int nano = lt.getNano(); //纳秒// 2、修改时间：withHour、withMinute、withSecond、withNanoLocalTime lt3 = lt.withHour(10);LocalTime lt4 = lt.withMinute(10);LocalTime lt5 = lt.withSecond(10);LocalTime lt6 = lt.withNano(10);// 3、加多少：plusHours、plusMinutes、plusSeconds、plusNanosLocalTime lt7 = lt.plusHours(10);LocalTime lt8 = lt.plusMinutes(10);LocalTime lt9 = lt.plusSeconds(10);LocalTime lt10 = lt.plusNanos(10);// 4、减多少：minusHours、minusMinutes、minusSeconds、minusNanosLocalTime lt11 = lt.minusHours(10);LocalTime lt12 = lt.minusMinutes(10);LocalTime lt13 = lt.minusSeconds(10);LocalTime lt14 = lt.minusNanos(10);// 5、获取指定时间的LocalTime对象：// public static LocalTime of(int hour, int minute, int second)LocalTime lt15 = LocalTime.of(12, 12, 12);LocalTime lt16 = LocalTime.of(12, 12, 12);// 6、判断2个时间对象，是否相等，在前还是在后： equals isBefore isAfterSystem.out.println(lt15.equals(lt16)); // trueSystem.out.println(lt15.isAfter(lt)); // falseSystem.out.println(lt15.isBefore(lt)); // true}
}LocalDateTime类的基本使用：
public class Test3_LocalDateTime {public static void main(String[] args) {// 0、获取本地日期和时间对象。LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒 纳秒System.out.println(ldt);// 1、可以获取日期和时间的全部信息int year = ldt.getYear(); // 年int month = ldt.getMonthValue(); // 月int day = ldt.getDayOfMonth(); // 日int dayOfYear = ldt.getDayOfYear(); // 一年中的第几天int dayOfWeek = ldt.getDayOfWeek().getValue(); // 获取是周几int hour = ldt.getHour(); //时int minute = ldt.getMinute(); //分int second = ldt.getSecond(); //秒int nano = ldt.getNano(); //纳秒// 2、修改时间信息：// withYear withMonth withDayOfMonth withDayOfYear withHour// withMinute withSecond withNanoLocalDateTime ldt2 = ldt.withYear(2029);LocalDateTime ldt3 = ldt.withMinute(59);// 3、加多少:// plusYears plusMonths plusDays plusWeeks plusHours plusMinutes plusSeconds plusNanosLocalDateTime ldt4 = ldt.plusYears(2);LocalDateTime ldt5 = ldt.plusMinutes(3);// 4、减多少：// minusDays minusYears minusMonths minusWeeks minusHours minusMinutes minusSeconds minusNanosLocalDateTime ldt6 = ldt.minusYears(2);LocalDateTime ldt7 = ldt.minusMinutes(3);// 5、获取指定日期和时间的LocalDateTime对象：// public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour,// int minute, int second, int nanoOfSecond)LocalDateTime ldt8 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);LocalDateTime ldt9 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);// 6、 判断2个日期、时间对象，是否相等，在前还是在后： equals、isBefore、isAfterSystem.out.println(ldt9.equals(ldt8));System.out.println(ldt9.isAfter(ldt));System.out.println(ldt9.isBefore(ldt));// 7、可以把LocalDateTime转换成LocalDate和LocalTime// public LocalDate toLocalDate()// public LocalTime toLocalTime()// public static LocalDateTime of(LocalDate date, LocalTime time)LocalDate ld = ldt.toLocalDate();LocalTime lt = ldt.toLocalTime();LocalDateTime ldt10 = LocalDateTime.of(ld, lt);}
}十、JDK8日期（时区）
接着，我们学习代表时区的两个类。由于世界各个国家与地区的经度不同，各地区的时间也有所不同，因此会划分为不同的时区。每一个时区的时间也不太一样。
public class Test4_ZoneId_ZonedDateTime {public static void main(String[] args) {// 1、ZoneId的常见方法：// public static ZoneId systemDefault(): 获取系统默认的时区ZoneId zoneId = ZoneId.systemDefault();System.out.println(zoneId.getId());//Asia/ShanghaiSystem.out.println(zoneId);//Asia/Shanghai// public static Set<String> getAvailableZoneIds(): 获取Java支持的全部时区IdSystem.out.println(ZoneId.getAvailableZoneIds());// public static ZoneId of(String zoneId) : 把某个时区id封装成ZoneId对象。ZoneId zoneId1 = ZoneId.of("America/New_York");// 2、ZonedDateTime：带时区的时间。// public static ZonedDateTime now(ZoneId zone): 获取某个时区的ZonedDateTime对象。ZonedDateTime now = ZonedDateTime.now(zoneId1);System.out.println(now);//2024-02-09T21:24:31.088834600-05:00[America/New_York]// 世界标准时间ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());System.out.println(now1);//2024-02-10T02:24:31.088834600Z// public static ZonedDateTime now()：获取系统默认时区的ZonedDateTime对象ZonedDateTime now2 = ZonedDateTime.now();System.out.println(now2);//2024-02-10T10:24:31.088834600+08:00[Asia/Shanghai]}
}十一、JDK8日期（Instant类）
接下来，我们来学习Instant这个类。通过获取Instant的对象可以拿到此刻的时间，该时间由两部分组成：从1970-01-01 00:00:00 开始走到此刻的总秒数+不够1秒的纳秒数。
类提供的方法如下图所示，可以用来获取当前时间，也可以对时间进行加、减、获取等操作。
public class Test5_Instant {public static void main(String[] args) {// 1、创建Instant的对象，获取此刻时间信息Instant now = Instant.now(); // 不可变对象// 2、获取总秒数long second = now.getEpochSecond();System.out.println(second);// 3、不够1秒的纳秒数int nano = now.getNano();System.out.println(nano);System.out.println(now);Instant instant = now.plusNanos(111);// Instant对象的作用：做代码的性能分析，或者记录用户的操作时间点Instant now1 = Instant.now();// 代码执行。。。。Instant now2 = Instant.now();LocalDateTime l = LocalDateTime.now();}
}十二、JDK8日期（格式化器）
接下来，我们学习一个新增的日期格式化类，叫DateTimeFormater。它可以从来对日期进行格式化和解析。它代替了原来的SimpleDateFormat类。
需要用到的方法，如下图所示：
接下来，将上面的方法用代码来演示一下：
public class Test6_DateTimeFormatter {public static void main(String[] args) {// 1、创建一个日期时间格式化器对象出来。DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");// 2、对时间进行格式化LocalDateTime now = LocalDateTime.now();System.out.println(now);//2024-02-10T10:45:47.141480100String rs = formatter.format(now); // 正向格式化System.out.println(rs);//2024年02月10日 10:45:47// 3、格式化时间，其实还有一种方案。String rs2 = now.format(formatter); // 反向格式化System.out.println(rs2);//2024年02月10日 10:45:47// 4、解析时间：解析时间一般使用LocalDateTime提供的解析方法来解析。String dateStr = "2029年12月12日 12:12:11";LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);System.out.println(ldt);//2029-12-12T12:12:11}
}十三、JDK8日期（Period类）
JDK8还补充了两个类，一个叫Period类、一个叫Duration类；这两个类可以用来对计算两个时间点的时间间隔。
其中Period用来计算日期间隔（年、月、日），Duration用来计算时间间隔（时、分、秒、纳秒）
先来演示Period类的用法，它的方法如下图所示。可以用来计算两个日期之间相隔的年、相隔的月、相隔的日。只能两个计算LocalDate对象之间的间隔
public class Test7_Period {public static void main(String[] args) {LocalDate start = LocalDate.of(2029, 8, 10);LocalDate end = LocalDate.of(2029, 12, 15);// 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());}
}十四、JDK8日期（Duration类）
接下来，我们学习Duration类。它是用来表示两个时间对象的时间间隔。可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持LocalTime、LocalDateTime、Instant等时间。
public class Test8_Duration {public static void main(String[] args) {LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);// 1、得到Duration对象Duration duration = Duration.between(start, end);// 2、获取两个时间对象间隔的信息System.out.println(duration.toDays());// 间隔多少天System.out.println(duration.toHours());// 间隔多少小时System.out.println(duration.toMinutes());// 间隔多少分System.out.println(duration.toSeconds());// 间隔多少秒System.out.println(duration.toMillis());// 间隔多少毫秒System.out.println(duration.toNanos());// 间隔多少纳秒}
}
