六、常用API
API ：应用程序编程接口
1、Object
作用：Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用0bject类中提供的一些方法。
| 方法名 | 说明 |
|---|---|
| toString() | 返回字符串数据 |
| equals(Object o) | 比较两个对象地址是否相同 |
| clone( ) | 克隆对象 |
1.1 toString() 方法
作用：返回字符串对象，如果要返回对象的数据，那么就重写toString() 方法。
//测试类
public class Test {public static void main(String[] args) {Student student=new Student("小明",19,"男");System.out.println(student.toString());//输出结果：Student{name='小明', age=19, sex='男'}}
}//学生类
public class Student {private String name;private int age;private String sex;public Student() {}//重写toString方法@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", sex='" + sex + '\'' +'}';}public Student(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}
}
1.2 equals() 方法
作用：比较两个对象引用地址是否一样，一样返回 true ，否则返回 false
场景：一般是通过重写 equals 方法，这样就可以比较两个对象的数据是否相同。
注意：两个相同的字符串比较，返回的是true ，因为相同的String值，java只会存一个值，然后只引用一个地址。
//测试类
public class Test {public static void main(String[] args) {Student student=new Student("小明",19,"男");Student student1=new Student("小明",19,"男");//比较2个对象的数据是否相同System.out.println(student.equals(student1));//输出结果：true}
}//学生类
public class Student {private String name;private int age;private String sex;public Student() {}public Student(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}//重写equals 方法@Overridepublic boolean equals(Object o) {//直接判断，当前对象地址和传入对象是否相同（避免比较的对象和传入的对象是同一个对象）if (this == o) return true;//判断传入的地址是不是null，或者 当前对象的数据类型，与传入的数据类型相不相同（比如：比较的是学生对象，结果传入的是狗对象）if (o == null || getClass() != o.getClass()) return false;//将接收的Object对象，转换为学生对象。Student student = (Student) o;//比较对应的数值和字符串是否相同，并返回结果。return age == student.age &&Objects.equals(name, student.name) &&Objects.equals(sex, student.sex);}
}
1.3 clone() 方法
作用：克隆对象
浅克隆：如果克隆的对象有数组之类的数据，那么克隆的只有地址，不会新建一个数组。
深克隆：如果克隆的对象有数组之类的数据，那么克隆的是整个数组，会新建一个数组对象，数据相同，保存新的数组地址数据。
//测试类
public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student=new Student("小明",19,"男");//将 学生对象克隆，原本克隆出来的是Object对象，强制转换为学生对象Student student2=(Student) student.clone();//通过重写的equals方法比较数据是否相同System.out.println(student.equals(student2));//结果：true}
}//学生类
//实现Cloneable 空接口，代表可以克隆
public class Student implements Cloneable {private String name;private int age;private String sex;public Student() {}public Student(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}//重写equals对象@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age &&Objects.equals(name, student.name) &&Objects.equals(sex, student.sex);}@Overridepublic int hashCode() {return Objects.hash(name, age, sex);}//重写clone对象，浅克隆。 如果要深克隆，就将数组数据单独克隆一次，在赋值回去。@Overrideprotected Object clone() throws CloneNotSupportedException {//返回调用父类对象Object的clone 方法，实现中转站。（因为 clone 在Object是私有的）return super.clone();}
}
2、Objects
是一个最终类、静态工具类
| 常用方法名 | 说明 |
|---|---|
| public static boolean equals (Object a, Object b ) | 先做非空判断，在比较两个对像 |
| public static boolean isNull ( Object obj ) | 判断对象是否为 null ，为null 返回 true ，反之 |
| public static boolean nonNull ( Object obj ) | 判断对象是否为null，不为null则返回true ，反之 |
2.1 equals() 方法
它和对象的equals方法的区别在于，Objects类的方法可以识别对象为空的时候，就行判断。
当对象自身的equals方法，遇到一个值为null时，会报空指针异常。
String name="小明";
String name2="小明";
String name3=null;name.equals(name2) //返回：true
Objects.equals(name,name2) //返回：truename.equals(name3) //可能报错：空指针异常
Objects.equals(name,name3) //返回：false
3、包装类
定义：包装类就是把基础类型的数据包装成对象。
自动装箱：自动将基本数据类型转为引用数据类型
自动拆箱：自动将引用数据类型转换为基本数据类型
作用：像集合不能直接用基本数据类型，所以就用引用数据类型
| 基本数据类型 | 对应的包装类（引用数据类型） |
|---|---|
| byte | Byte |
| short | Short |
| int | Inteter |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
| boolean | Boolean |
//通过 valueOf 将基本数据类型转为引用数据类型
Integer a1=Integer.valueOf(12);//自动装箱
Integer a2=10;//自动拆箱
int a3=a2;
int a3=15;//集合只能装引用数据类型
ArrayList<Integer> arrList=new ArrayList<>();
arrList.add(10);
System.out.println(arrList.get(0));
包装常见方法
| 常用方法名 | 说明 |
|---|---|
| public static String toString ( double d ) | 将数值转换为字符串 |
| public String toString( ) | Object的方法，将数值转换为字符串 |
| public static int parseInt( String s ) | 将字符串转换为数值 |
| public static Integer valueOf( String s ) | 将字符串转换为数值 |
int a1=10;//数值转换为字符串String a2=Integer.toString(a1)+1;System.out.println(a2); //结果：101//将字符串数值转换为数值String y="10";int y1=Integer.parseInt(y);System.out.println(y1+1); //结果：11//通常我们用valueOf 只需要记这个String x="10.5";int x1=Integer.valueOf(y);double x2=Double.valueOf(x);System.out.println(x1+1); //结果：11System.out.println(x2+1); //结果：11.5
4、StringBuilder
StringBuilder代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的。
好处：StringBuilder比String 更适合做字符串的修改操作，效率会更高，代码也会更简洁。
StringBuffer的用法与StringBuilder是一模一样的。
但StringBuilder是线程不安全的StringBuffer是 线程安全的。
| 构造器 | 说明 |
|---|---|
| public StringBuilder( ) | 空构造器 |
| public StringBuilder( String str ) | 有参构造器，一开始可以传入参数，传入的值可以就会参与到计算中 |
| 常用方法名 | 说明 |
|---|---|
| public StringBuilder append( 任意类型数据 ) | 追加字符串，可以链式追加 |
| public StringBuilder reverse( ) | 将字符串对象进行反转 |
| public int length( ) | 返回字符串长度 |
| public String toString( ) | 把StringBuilder类型的数据转换为String |
//创建一个Stringbuilder对象sStringBuilder s=new StringBuilder();//给s对象添加数据s.append("小明");s.append(520);//链式连接s.append(1314).append(true);System.out.println(s); //结果：小明5201314true// 将对象反正s.reverse();System.out.println(s); //结果：eurt4131025明小//将StringBuilder转换为StringString str=s.toString();System.out.println(str); //结果：eurt4131025明小
示例如下：传入整数数组，进行拼接后返回字符串数组。
public class Test {public static void main(String[] args) {System.out.println(getArrayString(new int[]{50, 20, 30, 10})); //结果：[50, 20, 30, 10]}public static String getArrayString(int[] arr){StringBuilder sb=new StringBuilder();sb.append("[");for (int i = 0; i < arr.length; i++) {if (i == arr.length - 1) {sb.append(arr[i]).append("]");} else {sb.append(arr[i]).append(", ");}}return sb.toString();}
}
5、StringJoiner
JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的。
好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁
| 构造器 | 说明 |
|---|---|
| public StringJoiner( 间隔符号 ) | 创建一个StringJoiner对象，指定间隔符合 |
| public StringJoiner( 间隔符号，开始符号，结束符合 ) | 创建一个StringJoiner对象，指定中间、开始、结束间隔符号。 |
| 常用方法名 | 说明 |
|---|---|
| public StringJoiner add(String str) | 添加数据，并返回对象本身 |
| public int length() | 返回长度（字符出现个数） |
| public String toString( ) | 返回一个字符串（该字符串就是拼接后的结果） |
示例如下：传入整数数组，进行拼接后返回字符串数组。
public class Test {public static void main(String[] args) {System.out.println(getArrayString(new int[]{50, 20, 30, 10}));//结果：[50, 20, 30, 10]}public static String getArrayString(int[] arr){// 这个构造器：参数为：中间的间隔符号，开始的间隔符号，最后的间隔符号StringJoiner sj=new StringJoiner(", ","[","]");for (int i = 0; i < arr.length; i++) {//add方法只能传入字符串，所以要转换一下sj.add(Integer.toString(arr[i]));}return sj.toString();}
}
6、Math
定义：代表数学，是一个工具类，里面提供的都是对数据进行操作的一些静态方法。
| 常用方法名 | 说明 |
|---|---|
| public static int abs ( int a ) | 获取参数绝对值 |
| public static double ceil ( double a ) | 向上取值 |
| public static double floor (double a) | 向下取值 |
| public static int round ( float a ) | 四舍五入 |
| public static int max ( int a , int b ) | 返回较大的数据 |
| public static double pow( double a , double b ) | 返回a 的 b 次幂值 |
| public static double random( ) | 返回为double的随机值，范围 [0 , 1.0) |
Math.abs(-10); //返回：10Math.ceil(10.1); //返回：11.0Math.floor(10.7); //返回：10.0Math.round(10.5); //返回：11Math.max(10,20); //返回：20Math.pow(10,2); //返回：100Math.random(); //随机返回一个 [0.0 ,1.0 )的数
7、System
定义：System代表程序所在的系统，也是一个工具类。
| 常用方法名 | 说明 |
|---|---|
| public static void exit(int status ) | 终止当前运行的java虚拟机（不怎么用） |
| public static long currentTimeMillis( ) | 返回当前系统的时间，毫秒形式 |
// currentTimeMillis方法使用场景：查看程序运行时间public class Test2 {public static void main(String[] args) {//获取程序运行时系统时间：毫秒形式long starTime=System.currentTimeMillis();for (int i = 0; i <1000000 ; i++) {System.out.println(i);}// 获取程序运行后系统时间：毫秒形式long endTime=System.currentTimeMillis();//结束时间-开始时间，因为是毫秒，除1000，变成秒System.out.println(endTime-starTime/1000.0+"秒");}
}
8、Runtime
定义：代表程序所在的运行环境。
特点：Runtime是一个单例类，只有一个对象。
获取对象：通过调用 getRuntime( ) 方法获取
| 常用方法名 | 说明 |
|---|---|
| public static Runtime getRuntime( ) | 返回与当前java应用程序关联的运行时对象 |
| public void exit ( int status ) | 终止当前java虚拟机 |
| public int availableProcessors( ) | 返回java虚拟机处理器数 |
| public long totalMemory( ) | 返回java虚拟机中的内存总数 |
| public long freeMemory( ) | 返回java虚拟机可用内存 |
| public Process exec (String command ) | 启动某个程序，并返回代表程序的对象（参数是程序的路径） |
public class Test2 {//报错要抛异常，Alt+Enterpublic static void main(String[] args) throws IOException, InterruptedException {//调用getRuntime()方法，获取Runtim对象Runtime runtime=Runtime.getRuntime();//获取java环境，处理器数System.out.println(runtime.availableProcessors());//获取java虚拟机中的内存总数System.out.println(runtime.totalMemory());//获取java虚拟机可用内存System.out.println(runtime.freeMemory());//启动某个程序，并返回代表程序的对象（参数是程序的路径）；//注意：路径要变成双斜杠（转义字符）。返回程序对象（会报错，要抛异常）Process process= runtime.exec("L:\\Software\\YuanShen\\Genshin Impact\\launcher.exe");//程序5秒后才向下执行（要报错，要抛异常）Thread.sleep(5000);//销毁程序，关闭打开的程序process.destroy();}
}
9、BigDecimal
作用：用于解决浮点型运算时，出现结果失真的问题。
| 构造器 | 说明 |
|---|---|
| public BIgDecimal ( double val ) 不推荐 | 将 double 转换为 BigDecimal |
| public BigDecimal ( String val ) | 把 String 转成 BigDecimal |
| 常用方法名 | 说明 |
|---|---|
| public static BigDecimal valueOf ( double val ) | 换一个double 为 BigDecimal |
| public BigDecimal add ( BigDecimal b ) | 加法 |
| public BigDecimal subtract ( BigDecimal b ) | 减法 |
| public BigDecimal multiply ( BigDecimal b ) | 乘法 |
| public BigDecimal divide ( BigDecimal b ) | 除法 |
| public BigDecimal divide ( 另一个BigDecimal对象 , 精准几位 , 舍入模式 ) | 除法，可精准控制小数位数 |
| public double doubleValue ( ) | 将BigDecimal 转换为 double |
public class BigdecimalDemo {public static void main(String[] args) {double s1=0.1;double s2=0.2;//通过Bigdecimal 提供的静态方法，将double类型的数据转换为 Bigdecimal 对象(也可以通过构造器传入字符串)BigDecimal a1=BigDecimal.valueOf(s1);BigDecimal a2=BigDecimal.valueOf(s2);//通过add方法进行 加法运算BigDecimal a=a1.add(a2);//通过subtract方法进行 减法运算BigDecimal b=a1.subtract(a2);//通过 mutiply方法进行 乘法运算BigDecimal c=a2.multiply(a1);//通过divide方法，进行除法运算，BigDecimal d=a1.divide(a2);//除法：可以控制小数位数，和四舍五入,如果除不尽，一定要保留小数位，不然要报错BigDecimal a3=BigDecimal.valueOf(0.3);BigDecimal e=a1.divide(a3,2, RoundingMode.HALF_UP);System.out.println(a+","+b+","+c+","+d+","+e);//结果：0.3,-0.1,0.02,0.5,0.33}
}
10、JDK8之前的日期和时间
10.1 Date
JDK8之前的日期和时间
| 构造器 | 说明 |
|---|---|
| public Date( ) | 创建一个Date对象，代表的是系统当前此刻日期时间 |
| public Date( long time ) | 把时间毫秒值转换为，Date对象 |
| 常见方法 | 说明 |
|---|---|
| public long getTime() | 返回从1970年1月1日00:00:00走到此刻 的总的毫秒数 |
| public void steTime ( long time ) | 设置日期对象的时间为当前时间毫秒值对应的时间 |
public class DateDemo {public static void main(String[] args) {//创建日期对象Date date=new Date();System.out.println(date); //输出当前时间对象//获取日期对象的时间毫秒值long d1=date.getTime();System.out.println(d1); //输出当前时间对象的毫秒值//将时间毫秒值转换为时间对象Date date1=new Date(d1);System.out.println(date1); //输出当前时间毫秒值转换成的时间对象//将时间毫秒值转换为日期date1.setTime(d1);System.out.println(date1); //输出当前时间毫秒值转换成的时间对象}
}
10.2 simpleDateFormat
定义：代表简单日期格式化，可以用来把日期对象、时间毫秒值格式化成我们想要的形式。
| 常用构造器 | 说明 |
|---|---|
| public SimpleDateFormat ( String pattern ) | 创建一个简单的时间对象，并封装城建格式 |
| 常用方法 | 说明 |
|---|---|
| public final String format ( Date date ) | 将日期格式化成日期/时间字符串 |
| public final String format ( Object time ) | 将时间毫秒值格式化成日期/时间字符串 |
| public final Date parse ( String date ) | 将字符串时间转换为时间对象 |
时间格式符号： y:年，M:月，d:日，H:小时，m:分钟，s:秒，EEE:星期，a:上午/下午。不能改字母大小写。
public class DateDemo {public static void main(String[] args) {//创建一个时间对象Date data=new Date();//将时间对象转换为时间毫秒值long date2=data.getTime();//定义简单时间格式： y:年，M:月，d:日，H:小时，m:分钟，s:秒，EEE:星期，a:上午/下午//可以自由定义，中间的除了特殊的字母，其他都可以修改如："yyyy年MM月dd日"SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE a");//通过simpleDateFormat提供的方法，可以将时间对象或时间毫秒值转换为简单格式的时间字符串String s1= simpleDateFormat.format(data);String s2=simpleDateFormat.format(date2);System.out.println(s1); //输出当前系统日期时间：2023-10-21 17:22:03 周六 下午System.out.println(s2); //输出当前系统日期时间：2023-10-21 17:22:03 周六 下午//定义一个时间格式的字符串（用户前端选择日期时间时是字符串）String dateStr="2023-10-21 17:22:03";//要保证传入的时间格式的字符串的格式，要和定义的格式保持一致，才行。SimpleDateFormat simpleDateFormat12=new SimpleDateFormat("yyy-MM-dd HH:mm:ss");//通过调用parse方法将字符串转为日期对象(需要抛异常，java防止你传入的时间字符串格式，和你定义的格式不一致)Date data4= simpleDateFormat12.parse(dateStr);System.out.println(data4); //输出：Sat Oct 21 17:22:03 CST 2023}
}
10.3 Calendar
定义：代表的是系统此刻时间对应的日历。
作用：通过它可以单独获取、修改时间中的年、月、日、时、分、秒等。场景：在原来的日期时间上，加一个月。
以前做法：通过将一个月转换为时间毫秒值（1000x60x60x24x30）+当前日期对象的时间毫秒值，再转为日期对象。
| 常用方法名 | 说明 |
|---|---|
| public static Calendar getInstance() | 获取当前日历对象 |
| public int get ( int field ) | 获取日历中的某个信息 |
| public final Date getTime () | 获取当前日期对象 |
| public long getTimeInMillis ( ) | 获取当前时间毫秒值 |
| public void set ( int field , int value ) | 修改日期中的某个信息 |
| public void add( int field , int amout ) | 为某个信息增加/减少指定的值 |
public class CalendarDemo {public static void main(String[] args) {//通过Calendar静态方法获取一个日历对象Calendar now=Calendar.getInstance();//输出当前日历的信息System.out.println(now);//获取当前日期对象Date date=now.getTime();System.out.println(date);//获取当前日期对象的时间毫秒值long datelong=now.getTimeInMillis();System.out.println(datelong);//获取日历中的信息，可以通过：Calendar.常量值，常量值可以通过输出日历对象进行查看//获取年日历中的年或其他信息System.out.println(Calendar.YEAR);//获取日历中的月份：0-11，所以要加1System.out.println(Calendar.MARCH+1);//修改当前日历中的年为2099年，格式：（日历常量,修改值）now.set(Calendar.YEAR,2099);//修改当前日历中的月份为12月，月份是：0-11now.set(Calendar.MARCH,11);//输出被修改后的日历对象信息System.out.println(now);//在日历的年份上加1，因为刚刚修改过，所以年份结果为：2100now.add(Calendar.YEAR,1);//在月份上减6，因为刚刚修改过所以，月份结果为：5，月份：0-11now.add(Calendar.MARCH,-6);//输出，加减后的日历信息System.out.println(now);}
}
11、JDK8开始新增加的日期和时间
11.1 LocalDate、LocalTime、LocalDateTime
分别代表：
①本地日期（年、月、日、星期）
②本地时间（时、分、秒、纳秒）
③代表本地时间、日期（年、月、日、星期、时、分、秒、纳秒）
| 获取对象静态方法名 | 说明 |
|---|---|
| public static LocalDate now( ) | 获取本日期对象 |
| public static LocalTime now( ) | 获取本地时间对象 |
| public static LocalDateTime now( ) | 获取本地日期时间对象 |
//所有输出结果也自己当时的日期时间为参考，写出结果只是可以知道输出的格式是什么样的。
public class LocalDateTimeDemo {public static void main(String[] args) {//1.1、获取本地日期对象（不可变对象）LocalDate ld=LocalDate.now();System.out.println(ld); //当时输出结果：2023-10-22int year=ld.getYear(); //获取年份：2023int mon=ld.getMonthValue(); //获取月份(1-12)：10int day=ld.getDayOfMonth(); //获取当前月份的第几日：22int dayofyear=ld.getDayOfYear(); //获取一年中的第几天：295int dayofweek=ld.getDayOfWeek().getValue(); //获取一周中的第几天：7// 1.2、直接修改某个信息: withYear、withMonth、withDayOfMonth、 withDayOfYear//修改后，会返回一个新的，被修改后的对象。LocalDate ld2=ld.withYear(2099); //修改年份System.out.println(ld2); //输出结果：2099-10-22LocalDate ld3=ld2.withMonth(12); //修改月份System.out.println(ld3); //输出结果：2099-12-22// 1.3、把某个信息加多少: plusYears、plusMonths、plusDays. plusWeeksLocalDate ld4=ld.plusYears(10) //在原来的年份上加：10System.out.println(ld4); //输出结果：2033-10-22//1.4、把某个信息减多少: minusYears、minusMonths、minusDays、minusWeeks LocalDate ld5=ld.minusYears(-10) //在原来的年份上加：-10System.out.println(ld5); //输出结果：2013-10-22// 1.5、获取指定日期的LocalDate对象: public static LocalDate of(int year,int month, int day)LocalDate ld6=LocalDate.of(2999,10,10); //指定一个日期对象System.out.println(ld6); //输出结果：2999-10-10// 1.6、判断2个日期对象，是否相等，在前还是在后: equals isBefore isAfterld.isEqual(ld6); //判断两个日期是否相等，返回结果：falseld.isAfter(ld5); //判断ld是否在ld5后，返回结果：falseld.isBefore(ld5); //判断ld是否在ld5前，返回结果：true/* 下面没有的方法，都是和上面的差不多（1.1，1.2，1.3，1.4，1.5，1.6） */ //2、获取本地时间对象LocalTime lt=LocalTime.now();System.out.println(lt); //当时输出结果：17:30:46.586131500int h=lt.getHour(); //获取小时：17int m=lt.getMinute(); //获取分钟：30int s= lt.getSecond(); //获取秒钟:45int nm=lt.getNano(); //获取纳秒：586131500//3、获取本地时间日期对象LocalDateTime ldt= LocalDateTime.now();System.out.println(ldt); //当时输出结果：2023-10-22T17:35:21.237835ldt.getYear(); //获取年：2023ldt.getMonthValue(); //获取月：10ldt.getDayOfMonth(); //获取日：22ldt.getHour(); //获取时：17ldt.getMinute(); //获取分：35ldt.getSecond(); //获取秒：21ldt.getNano(); //获取纳秒：237835}
}
11.2 ZoneId
代表时区ID
场景：想获取某个国家、某个城市的日期时间。
| ZoneId 时区id，方法名 | 说明 |
|---|---|
| public static Set getAvailableZoneIds( ) | 获取java中所有时区的集合 |
| public static ZoneId systemDefault() | 获取系统默认的时区 |
| public static ZoneId of ( String zoneId ) | 获取指定时区对象 |
| ZonedDateTime 带时区时间的常用方法 | 说明 |
|---|---|
| public static ZonedDateTime now ( ) | 获取系统默认时区的日期时间 |
| public static ZonedDateTime now ( ZoneId zone ) | 获取指定时区的日期时间 |
| getYear、getMonthvalue、getDayOfMonth、getDatOfYear、getDayOfWeek、getHour、getMinute、getSecond、getNano | 获取年、月、日、年的第几天、周、时、分、秒、纳秒 |
| public ZonedDateTime withXxx ( 时间 ) | 修改日期时间系列方法 |
| public ZonedDateTime minusXxx( 时间 ) | 对日期时间算减法系列方法 |
| public ZonedDateTime plusXxx (时间) | 对日期时间算加法系列方法 |
public class ZoneIdDemo {public static void main(String[] args) {// 1、ZoneId的常见方法:// public static ZoneId systemDefault(): 获取系统默认的时区ZoneId zoneId=ZoneId.systemDefault();System.out.println(zoneId); //结果：Asia/ShanghaiString id=zoneId.getId(); //获取系统默认时区System.out.println(id); // 结果：Asia/Shanghai// public static Set<String> getAvailableZoneIds(): 获取Java支持的全部时区IdSet sqList= ZoneId.getAvailableZoneIds();System.out.println(sqList); //输出所有时区的集合// public static ZoneId of(String zoneId) :把某个时区id封装成ZoneId对象。ZoneId zoneId1=ZoneId.of("America/New_York"); //获取一个指定地区的ZoneId对象// 2、ZonedDateTime:带时区的时间。// public static ZonedDateTime now(ZoneId zone): 获取 某个时区的ZonedDateTime对象。ZonedDateTime zdt=ZonedDateTime.now(zoneId1); //获取纽约的时间日期//获取世界标准时间(我们国家和世界标准时间相差8小时)ZonedDateTime now= ZonedDateTime.now(Clock.systemUTC());//获取当前时区的日期时间ZonedDateTime now1= ZonedDateTime.now();}
}
11.3 Instant
作用：时间线上的某个时刻/时间戳
通过获取Instant的对象可以拿到此刻的时间，该时间由两部分组成:从1970-01-01 00:00:00开始走到此刻的总秒数+不够1秒的纳秒数
场景：①做系统性能分析；②用户操作某个功能的的时间点
| 方法名 | 说明 |
|---|---|
| public static Instant now () | 获取当前时间的Instant对象（标准时间） |
| public long getEpochSecond ( ) | 获取从1970-01-01T00：00：00开始记录的秒数 |
| public int getNeno ( ) | 从时间线开始，获取从第二个开始的纳秒数 |
| plusMillis、plusSeconds、plusNanos | 增加时间系列方法 |
| minusMillis 、minusSeconds 、minusNanos | 减少时间系列方法 |
| equals、isBefore、 isAfter | 判断系列的方法 |
public class InstantDemo {public static void main(String[] args) {//获取系统当前Instant对象，输出为当前的日期时间Instant now= Instant.now();System.out.println(now); //2023-10-22T13:22:06.006580400Z//获取时间线到现在的秒数long s=now.getEpochSecond();System.out.println(s); //1697980926//获取不够一秒的纳秒int nm=now.getNano();System.out.println(nm); //6580400}
}
11.4 、DateTimeFormatter
作用：代替SimoleDateFormat（线程不安全），格式化器，用于时间的格式化、解析。
| 方法名 | 说明 |
|---|---|
| public static DateTimeFormatter ofPattern( 时间格式 ) | 获取格式化器对象 |
| public String format( 时间对象 ) | 格式化时间 |
| LocalDateTime方法 | 说明 |
|---|---|
| public String format( DateTimeFromatter formatter ) | 格式化时间 |
| public static LocalDateTime parse ( CharSequence text , DateTimeFormatter formatter ) | 解析时间 |
public class DateTimeFormatterDemo {public static void main(String[] args) {//获取本地时间对象LocalDateTime now=LocalDateTime.now();System.out.println(now); //2023-10-22T21:56:37.240579//创建一个日期时间格式化器对象出来。DateTimeFormatter dtf= DateTimeFormatter.ofPattern("yyyy年MM月dd HH时mm分ss秒");//将时间对象进行格式化String dateTime= dtf.format(now);System.out.println(dateTime); //2023年10月22 21时56分37秒//将时间对象进行格式化(传入格式化器对象)String date2=now.format(dtf);System.out.println(date2); //2023年10月22 21时56分37秒String date3="2099年11月11 11时11分11秒";//将字符串，转换为LocalDateTime对象,传入(时间，格式化器)LocalDateTime date5= LocalDateTime.parse(date3,dtf);System.out.println(date5); //2099-11-11T11:11:11}
}
11.5、Period、Duration
使用场景：
11.5.1 Period
作用：可以用于计算两个LocalDate对象相差的年数、月数、天数。
| 方法名 | 说明 |
|---|---|
| public static Period between ( LocalDate start , LocalDate end ) | 传入2ge日期对象，得到Period对象 |
| public int getYears () | 计算隔几年、并返回 |
| public int getMonths ( ) | 计算隔几个月，并返回 |
| public int getDays ( ) | 计算隔多少天，并返回 |
public class PeriodDemo {public static void main(String[] args) {//获取当前系统日期对象LocalDate date1=LocalDate.now();//将date1对象的年加10，并返回新对象LocalDate date2=date1.plusYears(10);//将两个日期对象传入，获取Period对象Period period= Period.between(date1,date2);int year=period.getYears(); // 间隔年：10//将两个日期对象传入，获取Period对象Period period2= Period.between(date2,date1);int year2=period2.getYears(); //间隔：-10int mon= period.getMonths(); //间隔月：0int day= period.getDays(); //间隔天：0}
}
11.5.2 Duration
作用：可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数;支持LocalTime、LocalDateTime、 Instant等 时间
注意：直接使用toHours、 toMinutes等方法时是获取两个日期时间的相差的总小时、分钟等，要获取，正常的相差天数、小时数、分钟数等，要在方法后加上Part，如：toHoursPart()
| 方法名 | 说明 |
|---|---|
| public static Duration between( 开始时间对象1，结束时间对象2 ) | 传入2个时间对象，得到Duration对象 |
| public long toDays () | 计算间隔多少天，并返回 |
| public long toHours( ) | 计算隔多少小时，并返回 |
| public long toMinutes( ) | 计算隔多少分，并返回 |
| public long toSeconds( ) | 计算隔多少秒，并返回 |
| public long toMillis() | 计算隔多少毫秒，并返回 |
| public long toNanos( ) | 计算隔多少纳秒，并返回 |
| toHoursPart( )、toMinutesPart( )、 toSeconds() | 在使用两个时间倒计时时，可以保证小时、分钟、秒钟的正确性 |
public class DurationDemo {public static void main(String[] args) {//获取当前的日期时间对象LocalDateTime ldt1=LocalDateTime.now();//自定义一个日期时间对象LocalDateTime ldt2=LocalDateTime.of(2099,12,12,14,30,30);//传入2个日期时间对象，并返回Duration对象Duration duration=Duration.between(ldt1,ldt2);duration.toDays(); //间隔天duration.toHours(); //间隔小时（可超过24H）duration.toMinutes(); //间隔分钟（可超过60Min）duration.toSeconds(); //间隔秒钟（可超过60S）duration.toMillis(); //间隔毫秒duration.toNanos(); //间隔纳秒}
}
12、Arrays
作用：用于操作数组的一个工具类。
| 方法名 | 说明 |
|---|---|
| public static String toString( 类型[] arr ) | 将数组转换为字符串 |
| public static int[ ] copyOfRange( 类型[ ] arr , 起始索引 , 结束索引 ) | 拷贝数组（指定范围）包前不包后 |
| public static copyOf ( 类型[ ] arr , int newLength ) | 拷贝数组 |
| public static setAll( double[ ] array , intToDoubleFunction generator ) | 把数组中的原数据改为新数据 |
| public static void sort ( 类型[ ] arr ) | 将数组进行排序(默认升序) |
public class ArrayDemo {public static void main(String[] args) {int[] a={1,4,2,6,7};//将整数型数组转换为字符串String aStr= Arrays.toString(a);System.out.println(aStr); //[1, 4, 2, 6, 7]int[] aCopy=Arrays.copyOfRange(a,1,4); //包前不包后System.out.println(Arrays.toString(aCopy)); // 将数组转换为字符串输出（不然要循环输出）：[4, 2, 6]int[] aCopyOf=Arrays.copyOf(a,3); //指定新数组长度，如果比传入原数组短就截取，长就把长出的部分赋默认值System.out.println(Arrays.toString(aCopyOf)); //将[1, 4, 2]double[] b={10.5,2,5,3};//修改，数组里的值，传入参数为：double类型数组，一个IntToDoubleFunction匿名内部类Arrays.setAll(b, new IntToDoubleFunction(){@Override //重写applyAsDouble方法，value为数组索引，返回值返回到原数组中对应位置。public double applyAsDouble(int value){return b[value]*2;}});System.out.println(Arrays.toString(b)); //输出修改后的数组：[21.0, 4.0, 10.0, 6.0]//修改数组b为升序排列Arrays.sort(b);System.out.println(Arrays.toString(b)); //[4.0, 6.0, 10.0, 21.0]}
}
对对象数组进行排序：
①让该对象的类实现Comparable(比较规则)接口，然后重写compareTo方法，自己来制定比较规则。
②使用下面这个sort方法,创建Comparator 比较器接口的匿名内部类对象，然后自己制定比较规则。
//测试类
public class Test {public static void main(String[] args) {Student[] studens=new Student[3];studens[0]=new Student("小明",10,173.4);studens[1]=new Student("小张",20,168.4);studens[2]=new Student("小康",7,150.8);//方法一：对对象进行按年龄排序（实体类实现：Comparable类）Arrays.sort(studens);System.out.println(Arrays.toString(studens));//输出结果：[Student{name='小康', age=7, height=150.8}, Student{name='小明', age=10, height=173.4}, Student{name='小张', age=20, height=168.4}]//方法二：对对象数组按身高降序排序（重写匿名内部类Comparator）Arrays.sort(studens, new Comparator<Student>() {//约定1:认为左边对象大于右边对象请您返回正整数//约定2:认为左边对象小于右边对象请您返回负整数//约定3:认为左边对象等于右边对象请您一定返回日@Overridepublic int compare(Student o1, Student o2) {// if(o1.getHeight()>o2.getHeight()){
// return -1;
// }else if(o1.getHeight()<o2.getHeight()){
// return 1;
// }
// return 0;//通过java提供的方法，和上面实现结果完全一致return Double.compare(o2.getHeight(),o1.getHeight());}});//输出降序排列的对象数组System.out.println(Arrays.toString(studens));//输出结果：[Student{name='小明', age=10, height=173.4}, Student{name='小张', age=20, height=168.4}, Student{name='小康', age=7, height=150.8}]}
}//学生类
//实体类实现：Comparable<Student> 类，并传入要排序的数据类型
public class Student implements Comparable<Student>{private String name;private int age;private double height;public Student() {}public Student(String name, int age,double height) {this.name = name;this.age = age;this.height=height;}@Overridepublic int compareTo(Student o) {//约定1:认为左边对象大于右边对象请您返回正整数//约定2:认为左边对象小于右边对象请您返回负整数//约定3:认为左边对象等于右边对象请您一定返回日//按照年龄升序排序。//降序排序：反过来减就可以（o.age-this.age）return this.age-o.age;}//重写toString方法，为了输出显示@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", height=" + height +'}';}public int getAge() {return age;}public double getHeight() {return height;}
}
