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%10

        int 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 + "}";
    }

    @Override
    protected 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 + "}";
    }

    @Override
    protected 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.01000000000000000020816681711721685132943093776702880859375
        BigDecimal bd2=new BigDecimal(0.09);//0.0899999999999999966693309261245303787291049957275390625
        System.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.01
        System.out.println(bd4);//0.09
        System.out.println(bd5);//0.10

        //通过静态方法获取对象
        BigDecimal bd6=BigDecimal.valueOf(10);
        BigDecimal bd7=BigDecimal.valueOf(10);
        System.out.println(bd6);  //10
        System.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位任意数字，最后一位可以是数字也可以是大写或小写的x

        String 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));  //true
        System.out.println("ABc".matches(regex));  //true
        System.out.println("aBc".matches(regex));  //true

        String regex2="a(?i)bc";
        System.out.println("aBC".matches(regex2));  //true
        System.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小崽子

        //判断字符串是否满足正则表达式的规则  返回boolean
        String 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，在底层记录子串的起始索引和结束索引+1
        boolean b=m.find();

        //方法底层会根据find方法记录的索引进行字符串截取
        //subString（起始索引，结束索引）；包头不包尾  因此find方法会将 结束索引+1
        //会把截取的子串进行返回
        String s1=m.group();
        System.out.println(s1); //Java

        //第二次调用find时会继续读取后面的内容
        //进行同样操作： 记录子串的起始索引和结束索引+1
        b=m.find();
        s1=m.group();
        System.out.println(s1); //Java8

        b=m.find();
        s1=m.group();
        System.out.println(s1); //Java11

        b=m.find();
        s1=m.group();
        System.out.println(s1); //Java17

        b=m.find();
        s1=m.group();
        System.out.println(s1); //Java17

        b=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;
        //获取正则表达式的对象 pattern
        String 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));  //true
        System.out.println("a123b".matches(regex1));  //false
        System.out.println("-------------------");

        //需求2： 判断一个字符串的开始部分和结束部分是否一致，可以有多个字符
        //例子： abc123abc  bbb456bbb  &!@abcd&!@  反例：abc123abd
        String regex2="(.+).+\\1";
        System.out.println("&!@abcd&!@".matches(regex2)); //true
        System.out.println("abc123abd".matches(regex2)); //false
        System.out.println("-------------------");

        //需求3： 判断一个字符串的开始部分和结束部分是否一致？开始部分每个字符也需要一致
        //例子： aaa123aaa  bbb456bbb  111789111  &&abc&&  abc123abC

        //(.)：把首字母看作一组， \\1 把首字母拿出来再次使用    
        //*：作用于\\1或者\\2时，表示后面重复的内容出现0或多次
        String regex3="((.)\\2*).+\\1";
        System.out.println("aaa123aaa".matches(regex3));  //true
        System.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的Java
        String str="Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，"+
                "因为这是两个长期支持的版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        //需求1
        String 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 

        //需求2
        regex1="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 

        //需求3
        regex1="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) {
        //创建simpleDateFormat
        SimpleDateFormat 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~11
        int 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); //false
        result=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);  //P23Y10M25D
        System.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.3157038S
        System.out.println(duration.toDays()+" "+duration.toHours()+" "+duration.toMinutes()+" "+duration.toSeconds());
        //8730 209537 12572275 754336518
        System.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)); //false

        Integer integer3=Integer.valueOf(127);
        Integer integer4=Integer.valueOf("127");
        System.out.println(integer4==integer3);  //true

        Integer integer5=Integer.valueOf(128);
        Integer integer6=Integer.valueOf(128);
        System.out.println(integer5==integer6); //false
    }
}