java学习之路7——常用类

一、Object类

• 超类、基类、左右类的直接或者间接父类，位于继承树的最顶层。
• 任何类，如果没有写extends显示继承某个类，默认都直接继承Object类。否则为间接继承。
• Object类中所定义的方法，时所有对象都具备的方法。
• 0bject类型可以存储任何对象。
  • 作为参数，可以接受任何对象
  • 作为返回值，可以返回任何对象

1、getClass（）方法

• public final Class<?> getClass(){}
• 返回引用中存储的实际对象类型
• 应用：通常用于判断两个引用中实际存储对象类型是否一致。

创建一个类

package com.jjl.usuclass;

public class Student {
    private String name;
    private int age;

    //生成get和set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    //构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

主程序

package com.jjl.usuclass;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("AAA",20);
        Student s2 = new Student("bbb",22);

        //判断s1和s2是不是同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if(class1==class2){
            System.out.println("s1和s2是同一类型");
        }else {
            System.out.println("no");
        }

    }
}

2、hashCode（）方法

• public int hashCode(){}
• 返回该对象的哈希码值
• 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
• 一般情况下相同的对象返回相同哈希码。

package com.jjl.usuclass;

public class Test {
    public static void main(String[] args) {

        //getClass方法
        Student s1 = new Student("AAA",20);
        Student s2 = new Student("bbb",22);

        //判断s1和s2是不是同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if(class1==class2){
            System.out.println("s1和s2是同一类型");
        }else {
            System.out.println("no");
        }

        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

    }
}
输出结果
460141958
1163157884

3、toString方法

• public String toString（）{}
• 返回该对象的字符串。
• 可以根据程序需求覆盖该方法，如：展示对象各个属性值。

@Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

        System.out.println("=============toString===============");
        //toString
        System.out.println(s1.toString());
        System.out.println(s2.toString());
结果：
=============toString===============
Student{name='AAA', age=20}
Student{name='bbb', age=22}

4、equals（）方法

• public boolean equals(Object obj) {}
• 默认实现为(this == obj)，比较两个对象地址是否相同。
• 可进行覆盖,比较两个对象的内容是否相同。

System.out.println("=============equals方法===============");
        //equals方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));
结果：
false

4.1 equals（）方法覆盖步骤

• 比较两个引用是否指向同一个对象
• 判断0bj是否为null。
• 判断两个引用指向的实际对象类型是否一致。
• 强制类型转换。
• 依次比较各个属性值是否相同。

重写equals

public boolean equals(Object obj){
        //1判断两个对象是否是同一个引用
        if(this==obj){
            return true;
        }
        //2判单obj是否null
        if(obj==null){
            return false;
        }
        //3判断是否是同一个类型，instanceof可以判断某对象是否等于某类型
        if(obj instanceof Student){
            //4强制类型转换
            Student s=(Student)obj;
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }

Student s4 = new Student("xiaoming",18);
Student s5 = new Student("xiaoming",18);
System.out.println(s4.equals(s5));

5、finalize（）方法

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
• 垃圾对象:没有有效引用指向此对象时，为垃圾对象。
• 垃圾回收:由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制:JVM的内存耗尽，一次性回收所有垃圾对象。
• 手动回收机制:使用System. gc();通知JVM执行垃圾回收。

重写finalize方法

 @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }

主程序调用

package com.jjl.usuclass;

public class testStudent {
    public static void main(String[] args) {
        new Student("aaa",22);
        new Student("bbb",22);
        new Student("ccc",22);
        new Student("ddd",22);
        new Student("eee",22);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

输出：
eee对象被回收了
ddd对象被回收了
ccc对象被回收了
bbb对象被回收了
aaa对象被回收了
回收垃圾

二、包装类

什么是包装类型？

• 基本数据类型所对应的引用数据类型。
• Object可统一所有数据，包装类的默认值是null。

包装类对应

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

1、类型转换与装箱、拆箱。

• 8种包装类提供不同类型间的转换方式
• Numder父类中提供的6个共性方法。
• valueof（）静态方法。

package com.jjl.usuclass.Package;

public class Demo01 {
    public static void main(String[] args) {
        //类型转换，装箱，基本类型转换成引用类型的过程
        //基本类型
        System.out.println("===================JDK1.5之前的装箱====================");
        int num=18;
        //使用Integer类型创建对象
        Integer integer1 = new Integer(num); //方法一
        Integer integer2 = Integer.valueOf(num); //方法二
        System.out.println(integer1);
        System.out.println(integer2);

        System.out.println("==================JDK1.5之前的拆箱====================");
        //拆箱：引用类型转化为基本类型
        Integer integer3= new Integer(100);
        int num1=integer3.intValue();
        System.out.println(integer3);
        System.out.println(num1);


        System.out.println("==================JDK1.5之后的自动装箱====================");
        //JDK1.5之后，提供了自动装箱和拆箱
        int age=30;
        //自动装箱
        Integer integer4=age;
        System.out.println(integer4);

        System.out.println("==================JDK1.5之后的自动拆箱====================");
        //自动拆箱
        int age2=integer4;
        System.out.println(age2);
    }
}
输出：
===================JDK1.5之前的装箱====================
18
18
==================JDK1.5之前的拆箱====================
100
100
==================JDK1.5之后的自动装箱====================
30
==================JDK1.5之后的自动拆箱====================
30

• parseXXX（）静态方法：

基本类型和字符串之间转换

package com.jjl.usuclass.Package;

public class Demo02 {
    public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1基本类型转成字符串
        System.out.println("=========基本类型数字转字符串==========");
        int n1=255;
        String s1=n1+"";//数字转化为字符串方法一
        String s2=Integer.toString(n1);//数字转化为字符串方法二
        String s3=Integer.toString(n1,16); //表示以十六进制显示
        String s4=Integer.toBinaryString(n1);//二进制
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

        System.out.println("=========字符串转基本类型数字==========");
        String str="150";
        int n2=Integer.parseInt(str);
        System.out.println(n2);

        //boolean字符串形式转成基本类型，“true”---->true   "true---->false
        String str2="true";
        //只要str2是true，那么b1就是true，如果str2是其他值的话，b1就是false
        boolean b1=Boolean.parseBoolean(str2);
        System.out.println(b1);
    }
}

2、integer缓冲区

面试题1：

package com.jjl.usuclass.Package;

public class Demo03 {
    public static void main(String[] args) {
        //面试题
        Integer integer1=new Integer(100);
        Integer integer2=new Integer(100);
        //问：会输出什么？
        System.out.println(integer1==integer2);
        
		Integer integer3=100;//自动装箱
        Integer integer4=100;
        System.out.println(integer3==integer4);

        Integer integer5=200;//自动装箱
        Integer integer6=200;
        System.out.println(integer5==integer6);

        //integer的取值在（-127——128）之间，如果在这个取值之间，则就赋予int的类型的值；
        //如果不在（-127——128）之间，则就会new Integer（）。
    }
}
输出：
false
//解释：引用类型都存放在堆里面，所以比较的是栈空间的地址，而不是对象值。
true
false
//integer的取值在（-127——128）之间，如果在这个取值之间，则就赋予int的类型的值；
//如果不在（-127——128）之间，则就会new Integer（）。

三、String类

• 字符串是常量，创建之后不可改变。
• 字符串字面值存储在字符串池中，可以分享。
• 使用String s = ”hello“创建对象；产生一个对象，字符串池中存储。
• 使用String s = new String(“Holle”)；创建对象，会产生两个对象，堆、池各存储一个。

package com.jjl.usuclass.Package;

public class Demo04 {
    public static void main(String[] args) {
        String name="hello"; //常量存储在字符串池中（常量池）
        //给name再次赋值之后，并没有修改源赋值的数据，而是在字符串池里重新给name添加了一个值，
        // 并将name指向了新的赋值，而原来的赋值还是在，并没有被覆盖，而原来的赋值就会被当初垃圾回收了。
        //（常量创建时候不可变）
        name="zhangsan";

        //当有新的变量名的赋值，在字符串池里面已经有了时，
        //这时name和name2这就指向的是字符串池里面同一个值。（字符串常量的共享）
        String name2 = "zhangsan";

        //字符串的另一种创建方式
        //用new则就是创建的两个对象，分别在字符串池和推里面分别创建一个对象
        String str=new String("java");
    }
}

1、常用方法

• public int length(:返回字符串的长度。
• public char charAt(int index):根据下标获取字符。
• public boolean contains(String str) :判断当前字符串中是否包含str.

package com.jjl.usuclass.Package;

public class Demo05 {
    public static void main(String[] args) {
        //字符串方法的使用
        //length()返回字符串的长度
        //charAt(int index);返回某个位置的字符
        //contains（String str）;判断是否包含某个字符串
        System.out.println("===========length()============");
        String content="java牛逼";
        System.out.println(content.length());
        System.out.println(content.charAt(0));//输出第一个字符
        System.out.println(content.charAt(content.length()-1));//输出最后个字符
        System.out.println(content.contains("java"));//判断content是否包含”java“
        System.out.println(content.contains("你"));//判断content是否包含”你“
    }
}
输出：
6
j
逼
true
false

• public char[] toCharArray()；将字符串转换为数组。
• public int indexOf(String str):查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。
• public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。

package com.jjl.usuclass.Package;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        //toCharArray()；将字符串转换为数组。
        //indexOf():查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。
        //lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。
        String content="认真学习Java";
        System.out.println(Arrays.toString(content.toCharArray()));//将字符串里面的字符变成单个的数组元素
        System.out.println(content.indexOf("a"));//找出字符"a"在字符串中首次出现的下标位置
        System.out.println(content.indexOf("a",6));//从第六个字符开始，找出字符"a"在字符串中首次出现的下标位置
        System.out.println(content.lastIndexOf("a"));//找出字符"a"在字符串中最后一次次出现的下标位置
    }
}
输出：
[认, 真, 学, 习, J, a, v, a]
5
7
7

• public String trim():去掉字符串前后的空格。
• public String toUpperCase() :将小写转成大写。
• public boolean endWith(String str):判断字符串是否以str结尾。

package com.jjl.usuclass.String;

import java.util.Locale;

public class Demo03 {
    public static void main(String[] args) {
        //trim():去掉字符串前后的空格。
        //toUpperCase() :将小写转成大写。toLowerCase：大转小
        //endWith(String str):判断字符串是否以str结尾；startWith（）判断字符串是否以str开始
        String content="    Hello Java    ";
        System.out.println(content.trim());//去掉前后空格
        System.out.println(content.toUpperCase());//转换为大写字母
        System.out.println(content.toLowerCase());//装换为小写字母
        String filename="hello.java";
        System.out.println(filename.endsWith("java"));//是否以”java“结尾
        System.out.println(filename.startsWith("he"));//是否以”he“开头
    }
}
输出：
Hello Java
    HELLO JAVA    
    hello java    
true
true

• public String replace(char oldChar, char newChar);将旧字符串替换成新字符串
• public String[] split(String str):根据str做拆分。

package com.jjl.usuclass.String;

import javax.swing.plaf.synth.SynthOptionPaneUI;

public class Demo04 {
    public static void main(String[] args) {
        // replace(char oldChar, qhar newChar);将旧字符串替换成新字符串
        // split(String str):根据str做拆分。
        String content="Java Hello，Java是最棒的，Java是最好的语言";
        System.out.println(content.replace("Java","python"));//将字符串中的Java，替换为“python”
        String[] arr=content.split("，");//使用逗号将字符串拆分为数组
        System.out.println(arr.length);//输出数组元素个数
        System.out.println(arr[2]);//输出数组中的第二个数
        for (String string : arr){
            System.out.println(string);
        }
        System.out.println("=======使用逗号或者空格拆分=======");
        String[] arr1=content.split("[ ，]");//使用空格或者逗号拆分
        String[] arr2=content.split("[ ，]+");//表示空格和逗号可以出现过个
        for (String string : arr1){
            System.out.println(string);
        }
    }
}
输出：
        python Hello，python是最棒的，python是最好的语言
        3
        Java是最好的语言
        Java Hello
        Java是最棒的
        Java是最好的语言
        Java
        Hello
        Java是最棒的
        Java是最好的语言

• equals比较字符串是否相等
• compare比较字符串大小(比的是ASCII码）

package com.jjl.usuclass.String;

public class Demo05 {
    public static void main(String[] args) {
        //equals比较字符串是否相等
        //compare比较字符串大小(比的是ASCII码）,依次比两个字符串的里的每个字符的ASCII码，
        // 如果第一个字符不一样，则就只比较第一个字符的大小，后面的不在做比较，依次类推。
        String s1="hello";
        String s2="HeLLo";
        System.out.println(s1.equals(s2));//比较字符串是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//比较字符串是否相等(忽略大小写)

        String s3="abc";
        String s4="wer";
        System.out.println(s3.compareTo(s4));//当字符串长度一样时，比ASCII码

        String s5="abc";
        String s6="abcqwer";
        System.out.println(s5.compareTo(s6));//当字符串长度不一样时，比字符串长度
    }
}
输出：
false
true
-22
-4

2、综合练习

需求:

• 知String str = “this is a text”;
  • 1.将str中的单词单独获取出来
  • 2.将str中的text替换为practice
  • 3.在text前面插入一个easy
  • 4.将每个单词的首字母改为大写

package com.jjl.usuclass.String;

public class Demo06 {
    public static void main(String[] args) {
//        -  知String str = "this is a text";
//        - 1.将str中的单词单独获取出来
//        - 2.将str中的text替换为practice
//        - 3.在text前面插入一个easy
//        - 4.将每个单词的首字母改为大写
        String str = "this is a text";

        //1.将str中的单词单独获取出来
       String arr[]= str.split(" ");
       for (String string:arr){
           System.out.println(string);
       }

        //2.将str中的text替换为practice
        System.out.println(str.replace("text","practice"));

       //3.在text前面插入一个easy
        System.out.println(str.replace("text","easy text"));

        //4.将每个单词的首字母改为大写
        for (int i=0;i<arr.length;i++){
            char fist=arr[i].charAt(0); //获取数组每个元素的第一个字符
            char upperfist=Character.toUpperCase(fist);//将字符转换成大写
            String news=upperfist+arr[i].substring(1);//substring（1）表示从第二个字符开始截取
            System.out.print(news+" ");
        }
    }
}

四、可变字符串

• StringBuffer:可变长字符串，JDK1.0提供，运行效率慢、线程安全。
• StringBuilder:可变长字符串，JDK5.0提供，运行效率快、线程不安全。
• 效率比String高，比String节省内存

1、StringBuffer和StringBuilder的常用方法

package com.jjl.usuclass.String;

public class Demo07 {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        //1append()追加
        sb.append("java最好");
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());

        //2 insert（）添加
        sb.insert(0,"java最棒");//在最前面添加(指定位置添加)
        System.out.println(sb.toString());

        //3 replace()替换
        sb.replace(0,5,"hello");//指定位置替换（将第1-5的字符替换为“hello”
        System.out.println(sb.toString());

        //4 delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());

        //清空
        sb.delete(0, sb.length());
        System.out.println(sb.toString());
        System.out.println(sb.length());
    }
}
输出：
java最好
java最好java真香
java最棒java最好java真香
hello棒java最好java真香
棒java最好java真香

0

1、StringBuilder与String的性能比较

比较分别用String和StringBuilder输出从1到9999所消耗的时间。

package com.jjl.usuclass.String;
//验证StringBuilder高于String
public class Demo08 {
    public static void main(String[] args) {
        //string
        long start=System.currentTimeMillis();
        String string="";
        for (int i=0;i<9999;i++){
            string+=i;
        }
        System.out.println(string);
        long end=System.currentTimeMillis();
        System.out.println("用时:"+(end-start));

        //StringBuilder
        long start1=System.currentTimeMillis();
        StringBuilder sb1 = new StringBuilder();
        for (int i=0;i<9999;i++){
            sb1.append(i);
        }
        System.out.println(sb1.toString());
        long end1=System.currentTimeMillis();
        System.out.println("用时:"+(end1-start1));

    }
}
输出：
0123456789101112131415161718192021..............(略)
用时:391
0123456789101112131415161718192021..............(略)
用时:5

五、BigDecimal

看案例

package com.jjl.usuclass.BigDecimal;

public class Demo01 {
    public static void main(String[] args) {
        double d1=1.0;
        double d2=0.9;
        System.out.println(d1-d2);

        double result=(1.4-0.5)/0.9;
        System.out.println(result);
    }
}
输出：
0.09999999999999998
0.9999999999999999

又上面案例可见，用double类型计算可能存在误差，而很多实际应用中需要精确运维，而double是近似值，不在符合要求。需要借助BigDecimal，精确计算浮点数。

• 位置: java.math包中。
• 作用:精确计算浮点数。
• 创建方式:BigDecimal bd=new BigDecimal(“1.0”);
• 方法:

  应用方法	作用
  BigDecimal add(BigDecimal bd)	加
  BigDecimal subtract(BigDecimal bd)	减
  BigDecimal multiply(BigDecimal bd)	乘
  BigDecimal divide(BigDecimal bd)	除

注意：
当计算除法时，如果有无限小数，就需要指定保留小数的位数，和取舍模式，否者程序会报错。

• 除法: divide(BigDecimal bd,int scal, RoundingMode mode)
• 参数scal :指定精确到小数点后几位。
• 参数mode :
  • 指定小数部分的取舍模式，通常采用四舍五入的模式，取值为BigDecimal.ROUND_HALF_UP。

package com.jjl.usuclass.BigDecimal;

import java.math.BigDecimal;

public class Demo02 {
    public static void main(String[] args) {
        BigDecimal bd1=new BigDecimal("1.0");
        BigDecimal bd2=new BigDecimal("0.9");

        //bd1.subtract(bd2)表示bd1减bd2
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);

        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);

        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);

        //除法,计算（1.4-0.5)/0.9
        BigDecimal r4=new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));

        System.out.println(r4);

        //除法,当出现无限小数时
        //计算10/3，保留两位小时，并四舍五入
        BigDecimal r5=new BigDecimal("10")
                .divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);
    }
}
输出：
0.1
1.9
0.90
1
3.33

六、Date

• Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
• 时间单位
  • 1秒=1000毫秒
  • 1毫秒=1000微秒
  • 1微秒=1000纳秒

package com.jjl.usuclass.Date;

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //1创建Date对象
        Date date1=new Date();
        //输出今天的时间
        System.out.println(date1.toString());//打印当前时间，并转化成字符串输出
        System.out.println(date1.toLocaleString());//toLocaleString上面会有横杠，表示方法已经过时，但是能用

        //输出昨天的时间
        Date date2=new Date(date1.getTime()-(60*60*24*1000));//60*60*24*1000表示一天的靠秒数
        System.out.println(date2.toLocaleString());

        //2方法after、before,判断是否在某天之后或者之前
        boolean b1=date1.after(date2);
        boolean b2=date1.before(date2);
        System.out.println(b1);
        System.out.println(b2);

        //比较compareTo();
        int d=date1.compareTo(date2);//比毫秒值,如果date1的毫秒值比date2大，则就是1；相等则是0；小则是-1。
        System.out.println(d);
        int d1=date1.compareTo(date1);
        int d2=date2.compareTo(date1);
        System.out.println(d1);
        System.out.println(d2);

        //比较是否相等
        boolean b3=date1.equals(date2);
        System.out.println(b3);

    }
}
输出：
Tue May 24 10:16:22 CST 2022
2022-5-24 10:16:22
2022-5-23 10:16:22
true
false
1
0
-1
false

七、Calendar

• Calendar提供了获取或设置各种日历字段的方法。
• 构造方法
  • protected Calendar() :由于修饰符是protected，所以无法直接创建该对象。
• 其他方法

  方法名	说明
  static Calendar getInstance()	使用默认时区和区域获取日历
  void set(int year,int month,int date,int hourofday,int minute,int second)	设置日历的年、月、日、时、分、秒。
  int get(int field)	返回给定日历字段的值。字段比如年、月、日等
  void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
  Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
  void add(int field,int amount)	按照日历的规则,给指定字段添加或减少时间量
  long getTimeInMillies()	毫秒为单位返回该日历的时间值

package com.jjl.usuclass.Calendar;

import java.util.Calendar;

public class Demo01 {
    public static void main(String[] args) {
        //1创建Calender对象
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());//获取当前时间
        System.out.println(calendar.getTimeInMillis());//获取1970年到现在的毫秒值

        //2获取时间信息
        //获取年
        int year=calendar.get(Calendar.YEAR);
        //月(这里的月份数是：0-11，所以在输出时需要+1，才符合当前月份)
        int month=calendar.get(calendar.MONTH);
        //日
        int day=calendar.get(calendar.DAY_OF_MONTH);
        //小时
        int hour=calendar.get(Calendar.HOUR_OF_DAY);//24小时
        int hour1=calendar.get(Calendar.HOUR);//12小时
        //分钟
        int minute=calendar.get(calendar.MINUTE);
        //秒
        int second=calendar.get(calendar.SECOND);

        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

        //修改时间
        Calendar calendar2=Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);//将日修改为5号
        System.out.println(calendar2.getTime().toLocaleString());

        //add方法修改时间
        calendar2.add(Calendar.HOUR,1);//增加一个小时
        calendar2.add(Calendar.HOUR,-1);//减少一个小时
        System.out.println(calendar2.getTime().toLocaleString());

        //获取当前月份天数的最大时，或者最小值
        int monthmin=calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        int monthmax=calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println(monthmin);
        System.out.println(monthmax);

    }
}
输出：
2022-5-24 10:57:22
1653361042792
2022年5月24日10:57:22
2022-5-5 10:57:22
2022-5-5 10:57:22
1
31

八、SimpleDateFormat

• SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
• 进行格式化（日期 —> 文本）、解析（文本 —> 日期）。
• 常用的时间模式字母

  字母	日期或时间	示例
  y	年	2019
  M	年中月份	08
  d	月中天数	10
  H	1天中小时数(0-23)	22
  m	分钟	16
  s	秒	59
  S	毫秒	367

package com.jjl.usuclass.SimpleDateFormat;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1创建SimpleDateFormat对象
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年mm月dd日HH:mm:ss");
        //2创建date
        Date date=new Date();
        //格式化date(把时间转换成字符串）
        String str=sdf.format(date);
        System.out.println(str);

        //把字符串转换为date类型，但是字符串必须要按照上面指定的时间格式显示
        Date date2=sdf.parse("1990年05月1日12:12:12");
        System.out.println(date2);

    }
}
输出：
2022年16月24日11:16:50
Mon Jan 01 12:12:12 CST 1990

九、System类

• System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

  方法名	说明
  static void arraycopy(…)	复制数组
  static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
  static void gc()（垃圾一、5）;	建议JVM赶快启动垃圾回收器回收垃圾
  static void exit(int status);	退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm。

package com.jjl.usuclass.System;

public class Demo01 {
    public static void main(String[] args) {
        //arraycopy数组的复制
        // fsrc:源数组
        // srcPos:从那个位置开始复制日
        // dest:目标数组
        // destPos:目标数组的位置
        // length:复制的长度
        int[] arr={20,18,15,8,35,26,45,90};//源数组
        int[] dest=new int[8];//目标数组
        //System.arraycopy(arr,0,dest,0,arr.length);//复制全部
        System.arraycopy(arr,4,dest,4,4);//复制全部

        for (int i=0;i<dest.length;i++){
            System.out.println(dest[i]);
        }

        System.out.println(System.currentTimeMillis());//打印从1970年到现在的毫秒数
        //用途，计时
        long start=System.currentTimeMillis();
        for (int i=0;i<9999999;i++){
            for (int j=0;j<9999999;j++){
                int result=i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时"+(end-start));
		
		System.exit(0);//0正常退出，下面的代码将不会被执行
        System.out.println("程序结束");
    }
}
输出：
0
0
0
0
35
26
45
90
1653363644275
用时11