JAVA学习日记（十一）常用API

一、Math

//开平方根
public static double sqrt(double a);  //返回结果
//开立方根
public static double cbrt(double a);

水题：

public class Main {public static void main(String[] args) {//统计一共有多少个水仙花数 :  abc=a^3+b^3+c^3=abc// a=abc/100%10// b=abc/10%10// c=abc%10int count=0;for(int i=100;i<1000;i++){if(Math.pow(i/100%10,3)+Math.pow(i/10%10,3)+Math.pow(i%10,3)==i){count++;System.out.println(i);}}System.out.println(count);count=0;//证明没有两位数的自幂数      统计 四叶玫瑰数   五角星数for(int i=10;i<100;i++){if(Math.pow(i%10,2)+Math.pow(i/10%10,2)==i){count++;System.out.println(i);}}System.out.println(count);count=0;for(int i=1000;i<10000;i++){if(Math.pow(i%10,4)+Math.pow(i/10%10,4)+Math.pow(i/100%10,4)+Math.pow(i/1000%10,4)==i){count++;System.out.println(i);}}System.out.println(count);count=0;for(int i=10000;i<100000;i++){if(Math.pow(i%10,5)+Math.pow(i/10%10,5)+Math.pow(i/100%10,5)+Math.pow(i/1000%10,5)+Math.pow(i/10000%10,5)==i){count++;System.out.println(i);}}System.out.println(count);}}

二、System

时间原点为：1970年1月1日 0:0:0 ，我国在东八区，有8小时时差：8：0：0

public static void exit(int status)//0表示正常结束虚拟机 其他数表示非正常结束

public static void arraycopy();
//两个参数数组如果为基本数据类型，则必须类型一致
//如果是引用数据类型，子类型可以拷贝进父类型数组。
//数组长度要符合

三、Runtime

四、Object

（一）ToString

默认情况下，Object类中的ToString方法是返回地址值。

（二）Equals

如果不对Object类中的方法进行重写，则比较的是地址值。

（三）Clone

把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。

Clone方法是用protected修饰，只有本类才能直接调用，因此其他类要使用Clone方法需要对其进行重写，除此以外该类还需实现一个接口：Cloneable，该接口没有任何抽象方法，因此是一个标记性接口，表示此接口一旦被实现，当前类的对象就可以被克隆。

public class User implements Cloneable {private String name;private String id;private String gender;public User() {}public User(String name, String id, String gender) {this.name = name;this.id = id;this.gender = gender;}public String toString() {return "User{name = " + name + ", id = " + id + ", gender = " + gender + "}";}@Overrideprotected Object clone() throws CloneNotSupportedException {//调用父类里的Clone方法//等于java帮我们新建一个对象，并将克隆后的对象返回return super.clone();}
}

public class Main {public static void main(String[] args) throws CloneNotSupportedException {User user=new User("jinluhao","0001","nan");User user2=new User();user2=(User)user.clone();System.out.println(user2.toString());System.out.println(user.toString());}}

（四）两种克隆方式：①浅克隆/浅拷贝（默认） ②深克隆/深拷贝（重写）

①：克隆时，对于基本数据会直接把真实数据拷贝，对于引用数据类型，则是将地址值拷贝。

②：克隆时，对于基本数据类型会直接把真实数据拷贝，对于引用数据类型，会重新创建一个同样的引用数据类型，再将原有数据拷贝进新的引用数据类型中。

验证浅克隆：

public class Main {public static void main(String[] args) throws CloneNotSupportedException {User user=new User("jinluhao","0001","nan");User user2=new User();user2=(User)user.clone();for(int i=0;i<user.getData().length;i++){System.out.print(user.getData()[i]+" ");}System.out.println();for(int i=0;i<user2.getData().length;i++){System.out.print(user2.getData()[i]+" ");}System.out.println();int[] data=user.getData();data[0]=100;user2.setData(data);for(int i=0;i<user2.getData().length;i++){System.out.print(user2.getData()[i]+" ");}System.out.println();for(int i=0;i<user.getData().length;i++){System.out.print(user.getData()[i]+" ");}}
}

深克隆验证：

public class User implements Cloneable {private String name;private String id;private String gender;private int[] data=new int[5];public User() {}public User(String name, String id, String gender) {this.name = name;this.id = id;this.gender = gender;}public void setData(int[] array){this.data=array;}public int[] getData(){return this.data;}public String toString() {return "User{name = " + name + ", id = " + id + ", gender = " + gender + "}";}@Overrideprotected Object clone() throws CloneNotSupportedException {//调用父类里的Clone方法//等于java帮我们新建一个对象，并将克隆后的对象返回//深克隆修改:新建一个同样的引用数据类型再克隆int[] data=new int[this.getData().length];for(int i=0;i<this.getData().length;i++){data[i]=this.getData()[i];}//父类调用的方法返回的是Object类  需要进行强制类型转换User user=(User)super.clone();user.setData(data);return user;}
}

public class Main {public static void main(String[] args) throws CloneNotSupportedException {int[] data=new int[]{1,2,3,4,5};User user=new User("jinluhao","0001","nan");User user2=new User();user.setData(data);user2=(User)user.clone();for(int i=0;i<user.getData().length;i++){System.out.print(user.getData()[i]+" ");}System.out.println();for(int i=0;i<user2.getData().length;i++){System.out.print(user2.getData()[i]+" ");}System.out.println();data=user2.getData();data[0]=1000;user2.setData(data);for(int i=0;i<user2.getData().length;i++){System.out.print(user2.getData()[i]+" ");}System.out.println();for(int i=0;i<user.getData().length;i++){System.out.print(user.getData()[i]+" ");}}
}

五、Objects

是一个工具类，提供了一些方法去完成一些功能。

六、BigInteger

表示范围比long都大（整数）

import java.math.BigInteger;
import java.util.Random;public class Main {public static void main(String[] args) throws CloneNotSupportedException {BigInteger a=new BigInteger(4, new Random());//字符串val中必须是整数BigInteger b=new BigInteger("1234");//radix为val的对应进制//val必须为整数BigInteger c=new BigInteger("101010",2);}
}

七、BigDecimal

用于小数的精确计算，表示很大的小数。

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;public class Main {public static void main(String[] args) throws CloneNotSupportedException {//传递double类小数创建对象//有可能不精确，不建议使用BigDecimal bd1=new BigDecimal(0.01);//0.01000000000000000020816681711721685132943093776702880859375BigDecimal bd2=new BigDecimal(0.09);//0.0899999999999999966693309261245303787291049957275390625System.out.println(bd1);System.out.println(bd2);//通过传递字符串创建对象BigDecimal bd3=new BigDecimal("0.01");BigDecimal bd4=new BigDecimal("0.09");BigDecimal bd5=bd3.add(bd4);System.out.println(bd3);//0.01System.out.println(bd4);//0.09System.out.println(bd5);//0.10//通过静态方法获取对象BigDecimal bd6=BigDecimal.valueOf(10);BigDecimal bd7=BigDecimal.valueOf(10);System.out.println(bd6);  //10System.out.println(bd6==bd7); //true//若想要创建的对象表示的数字不大，没有超出double的范围，建议使用第三种静态方法获取对象，//超出double范围则建议使用传递字符串创建//静态方法中已经创建了0~10整数的BigDecimal对象，若传递的是0~10的整数，则直接返回已经创建好的对象。}
}

若两数除不尽则只能使用最后一种除法，否则会报错。

舍入模式：

存储逻辑：

通过数组存储每一个数字/小数点/负号对应的ASCII码值进行存储

八、正则表达式

可以校验字符串是否满足一定的规则，并用来校验数据格式的合法性。

例：假如要求验证一个qq号码是否正确

规则：6位及20位之内，0不能是开头，必须全为数字。

使用正则表达式。

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;public class Main {public static void main(String[] args) throws CloneNotSupportedException {//假如要求验证一个qq号码是否正确//规则：6位及20位之内，0不能是开头，必须全为数字。// 使用正则表达式。String qq="16161616";System.out.println(qq.matches("[1-9]\\d{5,19}"));}
}

API文档：Pattern

插件：any-rule

代码示例：

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;public class Main {public static void main(String[] args) throws CloneNotSupportedException {//假如要求验证用户名是否满足要求//要求：大小写字母，数字，下划线，一共4-16位String number1="jinluhao121262";String regex1="\\w{4,16}";System.out.println(number1.matches(regex1));//验证身份证是否满足要求//18位，前17位任意数字，最后一位可以是数字也可以是大写或小写的xString number2="320584203323125812";String regex2="[1-9]\\d{16}(\\d|w|W)";//String regex2="[1-9]\\d{16}[\\dwW]";  System.out.println(number2.matches(regex2));}
}

忽略大小写：

public class Main {public static void main(String[] args) throws CloneNotSupportedException {String regex="(?i)abc";System.out.println("abc".matches(regex));  //trueSystem.out.println("ABc".matches(regex));  //trueSystem.out.println("aBc".matches(regex));  //trueString regex2="a(?i)bc";System.out.println("aBC".matches(regex2));  //trueSystem.out.println("AbC".matches(regex2));  //false}
}

身份证严格校验：

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;public class Main {public static void main(String[] args) throws CloneNotSupportedException {//身份证号码 严格校验//前6位：第一位不能为0   后面5位为数字//年的前半段： 18  19  20//年的后半段： 00~99//月份： 01~09  10 11 12//日期： 01~31//后面四位：任意数字出现3次，最后一位可以为数字或者大写或小写的x//先按正确数据进行拆分//对每一部分规律编写正则表达式//将所有正则表达式拼接String regex="[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[(?i)x\\d]";System.out.println("320584200012123012".matches(regex));}
}

正则表达式在字符串方法中的使用：

例子：

public class Main {public static void main(String[] args) {//需求，将两个名字中间的字母串替换为vs   返回替换后的字符串String str="小东西asdasdasdgxzlck老东西aslkdjalskd小崽子";String regex="[a-zA-Z]+";String newstr="vs";str=str.replaceAll(regex,newstr);System.out.println(str);  //小东西vs老东西vs小崽子//判断字符串是否满足正则表达式的规则  返回booleanString str1="asjdlasd";System.out.println(str1.matches(regex));  //true//按正则表达式的规则切割字符  返回的是字符串数组String[] arr=str.split(regex);for(int i=0;i<arr.length;i++){System.out.print(arr[i]+" ");//小东西 老东西 小崽子}}
}

九、爬虫

通过正则表达式设置规则，爬取满足规则的数据。

示例代码：

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Main {public static void main(String[] args) throws CloneNotSupportedException {//Pattern：表示正则表达式//Matcher：文本匹配器，按照正则表达式的规则去读取字符串，从头开始读取//在大串中寻找符合匹配规则的子串String str="Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，"+"因为这是两个长期支持的版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";//获取正则表达式的对象Pattern p=Pattern.compile("Java\\d{0,2}");//获取文本匹配器的对象//m：文本匹配器的对象//str：大串//p：规则//m要在str中寻找符合p规则的子串Matcher m=p.matcher(str);//拿着文本匹配器从头读取，寻找是否有满足规则的子串//如果没有，方法返回false//如果有，返回true，在底层记录子串的起始索引和结束索引+1boolean b=m.find();//方法底层会根据find方法记录的索引进行字符串截取//subString（起始索引，结束索引）；包头不包尾  因此find方法会将 结束索引+1//会把截取的子串进行返回String s1=m.group();System.out.println(s1); //Java//第二次调用find时会继续读取后面的内容//进行同样操作： 记录子串的起始索引和结束索引+1b=m.find();s1=m.group();System.out.println(s1); //Java8b=m.find();s1=m.group();System.out.println(s1); //Java11b=m.find();s1=m.group();System.out.println(s1); //Java17b=m.find();s1=m.group();System.out.println(s1); //Java17b=m.find();s1=m.group();System.out.println(s1); //报错： No match found}
}

循环改进：

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Main {public static void main(String[] args) throws CloneNotSupportedException {//Pattern：表示正则表达式//Matcher：文本匹配器，按照正则表达式的规则去读取字符串，从头开始读取//在大串中寻找符合匹配规则的子串String str="Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，"+"因为这是两个长期支持的版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";//获取正则表达式的对象Pattern p=Pattern.compile("Java\\d{0,2}");Matcher m=p.matcher(str);while(m.find()){String s1=m.group();System.out.println(s1); //Java}}
}

爬取网络数据（无规则）：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;public class Main {public static void main(String[] args) throws CloneNotSupportedException, IOException {//创建URL对象URL url=new URL("https://mbd.baidu.com/newspage/data/landingsuper?context=%7B%22nid%22%3A%22news_9556566747732783179%22%7D&n_type=-1&p_from=-1");//连接网络URLConnection conn=url.openConnection();//创建对象去读取网络中的数据BufferedReader br=new BufferedReader(new InputStreamReader(conn.getInputStream()));String line;while((line=br.readLine())!=null){System.out.println(line);}}
}

（带有规则）：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Main {public static void main(String[] args) throws CloneNotSupportedException, IOException {//创建URL对象URL url=new URL("https://mbd.baidu.com/newspage/data/landingsuper?context=%7B%22nid%22%3A%22news_9556566747732783179%22%7D&n_type=-1&p_from=-1");//连接网络URLConnection conn=url.openConnection();//创建对象去读取网络中的数据BufferedReader br=new BufferedReader(new InputStreamReader(conn.getInputStream()));String line;//获取正则表达式的对象 patternString regex=""; //正则表达式Pattern pattern =Pattern.compile(regex);while((line=br.readLine())!=null){//拿着文本匹配器的对象matcher按照pattern的规则去读取当前的这一行信息Matcher matcher=pattern.matcher(line);while(matcher.find()) {System.out.println(matcher.group());}}br.close();}
}

贪婪爬取（Java中默认方式）：

在爬取数据时尽可能多的获取数据。

非贪婪获取(在正则表达式中的数量词 + * 后加上 ? 则是非贪婪获取）：

在爬取数据时尽可能少获取数据。

分组：

分组：（）就是分组

捕获分组：

捕获分组就是把这一组的数据捕获出来，再用一次。

组号从1开始，连续不间断，以左括号为基准，最左边的是第一组。

后续还要继续使用本组的数据。

正则表达式内部使用： \ \组号

正则表达式外部使用： $ 组号

正则表达式内部使用示例代码： \\1 \\2 数字代表第几组

import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Main {public static void main(String[] args) {//需求1：判断一个字符的开始字符和结束字符是否一致？只考虑一个字符//举例： a123a b456b 17891 &avc&  反例 a123b//   \\1表示调用第一个组里的正则表达式String regex1="(.).+\\1";System.out.println("a123a".matches(regex1));  //trueSystem.out.println("a123b".matches(regex1));  //falseSystem.out.println("-------------------");//需求2： 判断一个字符串的开始部分和结束部分是否一致，可以有多个字符//例子： abc123abc  bbb456bbb  &!@abcd&!@  反例：abc123abdString regex2="(.+).+\\1";System.out.println("&!@abcd&!@".matches(regex2)); //trueSystem.out.println("abc123abd".matches(regex2)); //falseSystem.out.println("-------------------");//需求3： 判断一个字符串的开始部分和结束部分是否一致？开始部分每个字符也需要一致//例子： aaa123aaa  bbb456bbb  111789111  &&abc&&  abc123abC//(.)：把首字母看作一组， \\1 把首字母拿出来再次使用    //*：作用于\\1或者\\2时，表示后面重复的内容出现0或多次String regex3="((.)\\2*).+\\1";System.out.println("aaa123aaa".matches(regex3));  //trueSystem.out.println("abc123abC".matches(regex3));  //false}
}

正则表达式外部使用示例代码： $组号

public class Main {public static void main(String[] args) {//替换口吃内容： 我要学学编编编编程程程程程程程程程//结果：我要学编程String str="我要学学编编编编程程程程程程程程程";//正则表达式：(.)\\1+  代表把重复内容中的第一个字符看作一组  //$1代表将重复内容替换为组里的内容String result=str.replaceAll("(.)\\1+","$1");System.out.println(result);  //我要学编程}
}

非捕获分组：

仅仅是把数据括起来，不占用组号

import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Main {public static void main(String[] args) {//需求1：爬取版本号为8 11 17的Java  但不显示版本号//需求2：爬取内容同上  显示版本号//需求3：爬取除了JavaXX xx为8 11 17的JavaString str="Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，"+"因为这是两个长期支持的版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";//需求1String regex1="Java(?=8|11|17)";Pattern p1= Pattern.compile(regex1);Matcher m1=p1.matcher(str);while(m1.find()){System.out.print(m1.group()+" ");}System.out.println();  //Java Java Java Java //需求2regex1="Java(?:8|11|17)";p1= Pattern.compile(regex1);m1=p1.matcher(str);while(m1.find()){System.out.print(m1.group()+" ");}System.out.println();  //Java8 Java11 Java17 Java17 //需求3regex1="Java(?!8|11|17)";p1= Pattern.compile(regex1);m1=p1.matcher(str);while(m1.find()){System.out.print(m1.group()+" ");}System.out.println();  //Java }
}

十、JDK7时间类

1秒=1000毫秒 1毫秒=1000微秒 1微秒=1000纳秒

中国时间=世界时间+8小时

Data类：

JDK的一个JavaBean类，描述时间，精到毫秒。

利用空参构造创建对象，默认表示系统当前时间。

利用有参构造创建对象，表示指定时间。

import java.util.Date;
public class Main {public static void main(String[] args) {//空参构造  返回当前时间Date d=new Date();System.out.println(d);  //Wed Nov 06 14:10:38 CST 2024//带参构造  返回指定时间Date d1=new Date(0L); //long类型：尾巴+L  0L：表示从时间原点开始过了0毫秒System.out.println(d1);//Thu Jan 01 08:00:00 CST 1970 东八区+8小时// setTime  修改时间d1.setTime(1000L);       //增加1000毫秒System.out.println(d1);  //Thu Jan 01 08:00:01 CST 1970//getTime  获取当前时间的毫秒值long time=d1.getTime();System.out.println(time);   //1000}
}

SimpleDateFormat类：

作用：

格式化：可以把时间变为自己喜欢的类型。例子：2023年10月2日

解析：把字符串表示的时间变为Date对象。

例：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.logging.SimpleFormatter;public class Main {public static void main(String[] args) {//创建simpleDateFormatSimpleDateFormat sdf=new SimpleDateFormat();Date d1=new Date(0L);String str=sdf.format(d1);System.out.println(str);  //1970/1/1 08:00//带参构造SimpleDateFormat sdf1=new SimpleDateFormat("y年咯M月咯D日咯 H时m分s秒 E星期咯 ");String str1=sdf1.format(d1);System.out.println(str1); //1970年咯1月咯1日咯 8时0分0秒 周四星期咯 }
}

SimpleDateForma API：

解析示例代码：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.logging.SimpleFormatter;public class Main {public static void main(String[] args) throws ParseException {//解析字符串为Date对象时 指定格式必须与字符串中的时间格式一致SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String str="2039-3-28 12:29:12";Date str1=sdf1.parse(str);System.out.println(str1); //Mon Mar 28 12:29:12 CST 2039  解析结果}
}

Calendar类：

代表了系统当前时间的日历对象，可以单独修改、获取时间中的年，月，日

Calendar时一个抽象类，不能直接创建对象。

import java.text.ParseException;import java.util.Calendar;
import java.util.Date;public class Main {public static void main(String[] args) throws ParseException {//获取日历Calendar对象//Calendar是一个抽象类，不能直接new，需要通过一个静态方法获取子类对象//根据系统的不同时区获取不同的日历对象，并且把时间的纪元、年、月、日、秒等数据存入一个数组//数组索引：0：纪元   1：年   2：月   3：一年中的第几周   4：一个月中的第几周  5:一个月中的第几天（日期）……//月份：范围0~11，如果获取的值为0，实际上是1月//星期：默认星期日是一周中的第一天//数组值对应的星期   1(星期日) 2(星期一) 3(星期二) ....7(星期六)// 1（星期日） 2（星期一） …… 7（星期六）Calendar calendar=Calendar.getInstance();//修改日历中的时间Date day1=new Date(0L);calendar.setTime(day1);//修改某个字段信息calendar.set(Calendar.YEAR,2000);calendar.set(Calendar.MONTH,6);  // 11对应12月 若高于11，如12 则会变为2001 1月//为某个字段减少/增加指定的量calendar.add(Calendar.MONTH,1); //增加一个月  7+1=8  传递的是正数则+  负数则—//获取日期中的某个字段信息int year=calendar.get(1);//月份值需要+1  1~12月：0~11int month=calendar.get(2)+1;int day=calendar.get(5);int week=calendar.get(Calendar.DAY_OF_WEEK);System.out.println(week);System.out.println(year+" "+month+" "+day+" "+getweek(week)); //1970 1 1}public static String getweek(int index){//数组值对应的星期   1(星期日) 2(星期一) 3(星期二) ....7(星期六)String[] arr=new String[]{"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};return arr[index];}
}

十一、JDK8时间相关类

特点： JDK8的时间日期对象都是不可变的，避免了JDK7中可能发生的多线程问题。

ZoneId：

import java.text.ParseException;
import java.time.ZoneId;
import java.util.Set;public class Main {public static void main(String[] args) throws ParseException {//获取所有的时区名称Set<String> zoneIds = ZoneId.getAvailableZoneIds();System.out.println(zoneIds);System.out.println(zoneIds.size());//603//2.获取系统的默认时区ZoneId zoneId=ZoneId.systemDefault();System.out.println(zoneId);//Asia/Shanghai//获取指定的时区ZoneId zoneId1=ZoneId.of("Etc/GMT+9");System.out.println(zoneId1);}
}

Instant时间戳：

import java.sql.Date;
import java.sql.SQLOutput;
import java.text.ParseException;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;public class Main {public static void main(String[] args) throws ParseException {//获取当前时间的Instant对象 (标准时间)Instant instant1=Instant.now();System.out.println(instant1); //2024-11-06T08:54:46.857428800Z//根据（秒/毫秒/纳秒）获取Instant对象Instant instant2=Instant.ofEpochMilli(0L); //毫秒值System.out.println(instant2);Instant instant3=Instant.ofEpochSecond(1l); //秒System.out.println(instant3);Instant instant4=Instant.ofEpochSecond(1L,1000000000L);System.out.println(instant4);//指定时区,返回带时区的时间类：ZoneDate    (方法不是静态的，需要用对象调用）ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));System.out.println(time);  //2024-11-06T16:54:46.861895500+08:00[Asia/Shanghai]//isXXX判断//isBefore ：判断调用者代表的时间是否在参数表述时间的前面//isAfter ：判断调用者代表的时间是否在参数表述时间的后面boolean result=instant2.isAfter(instant4);System.out.println(result); //falseresult=instant2.isBefore(instant4);System.out.println(result); //true//以当前时间为原点 减少/增加 时间Instant instant5=Instant.ofEpochMilli(3000L);System.out.println(instant5);//JDK8中的时间类不能被改变，因此需要重新创建instant对象来接收新的时间Instant instant6=instant5.minusSeconds(1);System.out.println(instant6);}
}

ZoneDateTime：


import java.text.ParseException;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;public class Main {public static void main(String[] args) throws ParseException {//获取对象ZonedDateTime zonedDateTime=ZonedDateTime.now();System.out.println(zonedDateTime);//2024-11-06T17:04:49.098445900+08:00[Asia/Shanghai]//获取指定时间的ZonedDateTime对象（直接赋值）ZonedDateTime zonedDateTime1=ZonedDateTime.of(2024,11,6,17,05,12,0,ZoneId.of("Asia/Shanghai"));System.out.println(zonedDateTime1);//2024-11-06T17:05:12+08:00[Asia/Shanghai]//通过Instant+时区方式指定时间Instant instant=Instant.now();ZoneId zoneId=ZoneId.of("Asia/Shanghai");ZonedDateTime zonedDateTime2=ZonedDateTime.ofInstant(instant,zoneId);System.out.println(zonedDateTime2);//2024-11-06T17:11:34.149958700+08:00[Asia/Shanghai]//wtihXxx 修改时间系列的方法ZonedDateTime time2=zonedDateTime2.withYear(2028);System.out.println(time2);//2028-11-06T17:13:29.150712100+08:00[Asia/Shanghai]//增加/减少 时间ZonedDateTime time3=time2.plusYears(4);System.out.println(time3);  //2032-11-06T17:14:31.484051500+08:00[Asia/Shanghai]ZonedDateTime time4=time2.minusYears(4);System.out.println(time4);  //2024-11-06T17:15:01.372179100+08:00[Asia/Shanghai]}
}

DateTimeFormatter：

用于时间的格式化和解析


import java.text.ParseException;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;public class Main {public static void main(String[] args) throws ParseException {//获取时间对象ZonedDateTime time= Instant.now().atZone(ZoneId.of("Asia/Shanghai"));//解析/格式化DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy~MM~dd HH:mm:ss EE a");//格式化System.out.println(dateTimeFormatter.format(time));//2024~11~06 17:26:05 周三 下午}
}

LocalDate、LocalTime、LocalDateTime：

Duration、Period、ChronoUnit：


import java.text.ParseException;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;public class Main {public static void main(String[] args) throws ParseException {LocalDate today=LocalDate.now();System.out.println(today);LocalDate birthday=LocalDate.of(2000,12,12);Period period=Period.between(birthday,today);System.out.println(period);  //P23Y10M25DSystem.out.println(period.getYears()+" "+period.getMonths()+" "+period.getDays()+" ");//23年 10月 25天System.out.println(period.toTotalMonths()); //286个月LocalDateTime birthday1=LocalDateTime.of(2000,12,12,0,0,0);LocalDateTime today1=LocalDateTime.now();Duration duration=Duration.between(birthday1,today1);System.out.println(duration);  //PT209537H55M18.3157038SSystem.out.println(duration.toDays()+" "+duration.toHours()+" "+duration.toMinutes()+" "+duration.toSeconds());//8730 209537 12572275 754336518System.out.println(duration.toMillis()+" "+duration.toNanos());//754336518315 754336518315703800}
}

这个API不知咋回事没有

十二、包装类

用一个对象，把数据给包起来。

包装类：基本数据对应的引用对象。

静态方法创建时，在int：-128~127之间已经提前创建好了Integer对象存在数组中，在范围内会直接赋值因此地址值一样。

import java.text.ParseException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.ChronoPeriod;
import java.time.chrono.Chronology;public class Main {public static void main(String[] args) {Integer integer1=new Integer("12");Integer integer2=new Integer("12");System.out.println((integer2 == integer1)); //falseInteger integer3=Integer.valueOf(127);Integer integer4=Integer.valueOf("127");System.out.println(integer4==integer3);  //trueInteger integer5=Integer.valueOf(128);Integer integer6=Integer.valueOf(128);System.out.println(integer5==integer6); //false}
}