Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层

任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承

• Object类中所定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象
  • 作为参数，可接受任何对象
  • 作为返回值，可返回任何对象

getClass() 方法

• public final Class<?> getClass(){}

• 返回引用中存储的实际对象类型

• 应用：通常用于判断两个引用中实际存储对象类型是否一致

【演示】

package com.commonclass.object.demo01;

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
package com.commonclass.object.demo01;

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

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 20);
        Teacher t1 = new Teacher("王五", 28);
        Class c1 = s1.getClass();// getClass()返回Class类型
        Class c2 = s2.getClass();
        Class c3 = t1.getClass();
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        // 判断s1和s2是不是同类型
        if (c1 == c2){
            System.out.println("s1和s2是同类型");
        } else{
            System.out.println("s1和s2不是同类型");
        }
        // 判断s1和t1是不是同类型
        if (c1 == c3){
            System.out.println("s1和t1是同类型");
        } else{
            System.out.println("s1和t1不是同类型");
        }
    }
}
执行结果：
class com.commonclass.object.demo01.Student
class com.commonclass.object.demo01.Student
class com.commonclass.object.demo01.Teacher
s1和s2是同类型
s1和t1不是同类型

hashCode()方法

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

【演示】

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 20);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s2;// 相同对象返回相同哈希码
        System.out.println(s3.hashCode());
    }
}
输出结果：
1163157884
1956725890
1956725890

toString()方法

• public String toSring(){}

• 返回该对象的字符串表示（表现形式）

• 可以根据程序需求重写该方法，如：展示对象各个属性值

【演示】

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        System.out.println(s1.toString());
    }
}
执行结果：
Student{name='张三', age=18} 

若Student类中未重写toString方法，则输出com.commonclass.object.demo02.Student@4554617c// @4554617c为哈希值

equals()方法

• public boolean equals(Object obj){}

• 默认实现为(this == obj), 比较两个对象地址是否相同

• 可进行覆盖，比较两个对象的内容是否相同

请注意，无论何时覆盖该方法，通常需要覆盖hashCode方法，以便维护hashCode方法的通用合同，该方法规定相等的对象必须具有相等的哈希码。

重写equals方法步骤

1. 比较两个引用是否指向同一个对象
2. 判断obj是否为null
3. 判断两个引用指向的实际对象类型是否一致
4. 强制类型转换
5. 依次比较各个属性值是否相同

【演示】

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override// 重写equals方法
    public boolean equals(Object o) {
        if (this == o) {// 1.比较两个引用是否执行同一个对象
            return true;
        }
        if (o != null) {// 2.判断obj是否为null
            return true;
        }
        if (getClass() == o.getClass()){// 3.判断两个引用指向的实际对象类型是否一致
            return true;
        }
        if (o instanceof Student){
            Student student = (Student) o;// 4.强制类型转换
            if (this.age == student.getAge() && this.name.equals(student.getName())){// 5.依次比较各个属性值是否相同
                return true;
            }
        }

        return false;
    }

    @Override// 重写hashCode方法
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("张三", 18);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s1.equals(s2));
    }
}
执行结果：
24022538
24022538
true

【注意】若Student类中未重写equals方法和hashCode方法，则输出1163157884 1956725890
false，s1和s2的哈希码不同，尽管s1和s2传递的参数相同，但是其地址不同，所以要让它们的equals方法返回为true（引用的是相同的对象），则必须重写其equals方法及hashCode方法。

finalize() 方法

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

【演示】

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 20);
        new Student("李四", 18);// 垃圾对象：没有有效引用指向此对象
        System.gc();
        System.out.println("回收垃圾");
    }
}
执行结果：
李四对象被回收了
回收垃圾

包装类

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

装箱(基本数据类型–>引用类型)

除以上方法还有各包装类的valueOf( )方法。例如Integer integer = Integer.valueOf(1)；

拆箱(引用类型–>基本数据类型)

Number父类中提供的6个共性方法

包装类Byte,Double,Flaot,Integer,Long,Short均是Number的子类

【演示】

public class Test {
    public static void main(String[] args) {
        /* 装箱 基本数据类型-->引用类型 */
        int num1 = 10;// 基本数据类型
        Integer integer1 = new Integer(num1);// 使用Integer类创建对象
        Integer integer2 = Integer.valueOf(num1);
        /* 拆箱 引用类型-->基本数据类型)*/
        int num2 = integer1.intValue();

        /*
        jdk1.5之后提供自动装箱和拆箱
        但是其原理仍是上述的方法
         */
        // 自动装箱
        Integer integer3 = 8;// Integer integer3 = = Integer.valueOf(8);
        // 自动拆箱
        int num3 = integer3;
    }
}

字符串与基本类型之间的转换

基本数据类型转换为字符串类型
1.使用”+”
2.使用各包装类中的toString()方法

字符串类型转化为基本数据类型
1.使用×××.parse×××()方法

boolean字符串转换为基本数据类型：”true”—->true,非”true”—->false

【演示】

public class Test02 {
    public static void main(String[] args) {
        /* 基本数据类型转换为字符串类型 */
        int a = 255;
        String str1 = a + "";// 使用"+"
        String str2 = Integer.toString(a);// 使用Integer中的toString方法
        // 注:Integer.toString方法的重载可以将int型数据转化为所设置的进制数据的字符串形式
        String str3 = Integer.toString(a, 16);// 100的16进制字符串形式
        
        /* 字符串类型转化为基本数据类型 */
        String str4 = "888";
        int b = Integer.parseInt(str4);// 使用Integer中的parseInt方法
        String str5 = "fe";
        int c = Integer.parseInt(str5, 16);// 使用Integer中的重载parseInt方法（fe为16进制的数据，转换为int型数据为255）
        String str6 = "true";
        String str7 = "te";
        boolean flag1 = Boolean.parseBoolean(str6);
        boolean flag2 = Boolean.parseBoolean(str7);// "te"不是"true",即为false
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(b);
        System.out.println(c);
        System.out.println(flag1);
        System.out.println(flag2);
    }
}
输出结果：
255
255
ff
888
254
true
false

注意：需保证类型兼容，否则抛出NumberFormatException异常

整数缓冲区

• Java预先创建了256个常用的整数包装类型对象
• 在实际应用当中，对已创建的对象进行复用

【Integer中valueOf方法源码】

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
// 只要i在[-128,127]这个范围内，就直接对已创建的对象进行复用
// 只要i在[-128,127]这个范围外，才new Integer(i)

【演示】

public class Test03 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);// flase 因为是用的new的对象
        Integer integer3 = 100;// 自动装箱:Integer integer3 = Integer.valueOf(100);
        Integer integer4 = 100;// 100∈[-128,127],该包装类型对象已预先创建
        System.out.println(integer3 == integer4);// true 因为Java预先创建了256个常用的整数包装类型对象，直接调用
        Integer integer5 = Integer.valueOf(200);
        Integer integer6 = Integer.valueOf(200);// 200∉[-128,127],该包装类型对象需重新创建，即new
        System.out.println(integer5 == integer6);// flase 因为是用的new的对象
    }
}

String 类

• 字符串是常量，创建之后不可改变
• 字符串字面值存储在字符串池中，可以共享
• String s = "Hello";产生一个对象，字符串池中存储
• String s = new String("Hello"); 产生两个对象，堆、池各一个

【演示】

public class Test01 {
    public static void main(String[] args) {
        String name1 = "hello";
        name1 = "张三";
        String name2 = "张三";
        String str1 = new String("Java");
        String str2 = new String("Java");
        System.out.println(str1 == str2);// false 因为其引用的对象不同
        System.out.println(str1.equals(str2));// true
    }
}

【内存分析】

常用方法

【演示】

public class Test02 {
    public static void main(String[] args) {
        /*
        1. length(); 返回字符串长度
        2. charAt(int index); 返回某个位置的字符
        3. contains(String str); 判断是否包含某个字符串
         */
        String str1 = "java是最好的语言";
        System.out.println(str1.length());// 返回该字符串的长度
        System.out.println(str1.charAt(0));// 返回该字符串第一位的字符
        System.out.println(str1.charAt(str1.length() - 1));// 返回该字符串最后一位的字符
        System.out.println(str1.contains("java"));// 判断该字符串中是否包含"java"
    }
}
执行结果：
10
j
言
true

import java.util.Arrays;

public class Test03 {
    public static void main(String[] args) {
        /*
        4. toCharArray(); 返回字符串对应数组
        5. indexOf(); 返回字符串首次出现的位置
        6. lastIndexOf(); 返回字符串最后一次出现的位置
         */
        String str = "java是最好的语言java也是最简单的语言java";
        System.out.println(str.toCharArray());// 返回该字符串的对应数组
        System.out.println(Arrays.toString(str.toCharArray()));// 返回该字符串的对应数组内容的字符串表示形式
        System.out.println(str.indexOf("java"));// 返回"java"在该字符串首次出现的位置
        System.out.println(str.indexOf("java", 4));// 返回"java"在该字符串从索引4开始首次出现的位置
        System.out.println(str.lastIndexOf("java"));// 返回"java"在该字符串最后出现的位置
    }
}
执行结果：
java是最好的语言java也是最简单的语言java
[j, a, v, a, 是, 最, 好, 的, 语, 言, j, a, v, a, 也, 是, 最, 简, 单, 的, 语, 言, j, a, v, a]
0
10
22

public class Test04 {
    public static void main(String[] args) {
        /*
        7. trim(); //去掉字符串前后空格
        8. toUpperCase();将字符串中的字母小写转换为大写 toLowerCase(); 将字符串中的字母大写转换为小写
        9. endWith(str); 判断是否以str结尾 startWith(str);  判断是否以str开头
         */
        String str = " My name is ZhangSan ";
        System.out.println(str.trim());// 去掉该字符串前后空格
        System.out.println(str.toUpperCase());// 将该字符串中的字母小写转换为大写
        System.out.println(str.toLowerCase());// 将该字符串中的字母大写转换为小写
        System.out.println(str.endsWith(" "));// 判断该字符串是否以" "结尾
        System.out.println(str.startsWith(" "));// 判断该字符串是否以" "开头
    }
}
执行结果：
My name is ZhangSan
 MY NAME IS ZHANGSAN 
 my name is zhangsan 
true
true

public class Test05 {
    public static void main(String[] args) {
        /*
        10. replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
        11. split(); 对字符串拆分
         */
        String str1 = "java是最好的语言java也是最简单的语言";
        System.out.println(str1.replace("java", "php"));// 用"php"替换该字符串中的"java"
        String str2 = "java is the best language";
        String[] array1 = str2.split(" ");// 以" "对该字符串拆分
        for (String i : array1){
            System.out.println(i);
        }
        String str3 = "java,is the,best language";
        String[] array2 = str2.split("[ ,]");// 以" "或者","对该字符串拆分
        for (String j : array2){
            System.out.println(j);
        }
        String str4 = "java,,,is   the,,best language";
        String[] array3 = str3.split("[ ,]+");// 以多个" "或者多个","对该字符串拆分 
        for (String k : array3){
            System.out.println(k);
        }
    }
}
执行结果：
php是最好的语言php也是最简单的语言
java
is
the
best
language
java
is
the
best
language
java
is
the
best
language

public class Test06 {
    public static void main(String[] args) {
        /*
        12. equals();比较两个字符串的内容是否相等
            equalsIgnoreCase();忽略字母大小写比较两个字符串内容
        13. compareTo();按字典顺序比较两个字符串
            compareToIgnoreCase();忽略字母大小写按字典顺序比较两个字符串
            两字符串不同时比较字符字典序的ascii码,两字符串相同时比较长度 返回差值
         */
        String str1 = "hello";
        String str2 = "HELLO";
        String str3 = "hello world";
        System.out.println(str1.equals(str2));// 比较str1和str2字符串内容是否相同
        System.out.println(str1.equalsIgnoreCase(str2));// 忽略字母大小写比较str1和str2字符串内容是否相同
        System.out.println(str1.compareTo(str2));// h的ASCII码值为104，H的ASCII码值为72,返回差值104-72= 32
        System.out.println(str1.compareTo(str3));// str1与str3的前半部分相同，则比较两字符串的长度，返回差值5-11=-6
        System.out.println(str1.compareToIgnoreCase(str2));// 忽略字母大小写，str1与str2字符串内容相同，则比较两字符串长度，返回差值5-5=0
    }
}
执行结果：
false
true
32
-6
0

string类方法练习

需求：

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

补充方法：public String substring(int beginIndex)

返回一个字符串，该字符串是此字符串的子字符串。 子字符串以指定索引处的字符开头，并扩展到该字符串的末尾。beginIndex – 开始索引（含）

例子：”unhappy”.substring(2) returns “happy”
“Harbison”.substring(3) returns “bison”
“emptiness”.substring(9) returns “” (an empty string)

public class Practice {
    public static void main(String[] args) {
        String str = "this is a text";
        /* 将str中的单词单独获取 */
        String[] array = str.split(" ");
        for (String s : array) {
            System.out.println(s);
        }
        /* 将str中的text替换成practice */
        String str2 = str.replace("text", "practice");
        System.out.println(str2);
        /* 在text前面插入一个easy */
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);
        /* 将每个单词的首字母改为大写 */
        String str4 = "";
        for (int i = 0; i < array.length; i++) {
            char s = array[i].charAt(0);// 返回array[i]的首字母
            char sUpper = Character.toUpperCase(s);// 将array[i]的首字母转换为大写
            String strFirstUpper = sUpper + array[i].substring(1);// 将大写的首字母与余下字母串拼接起来
            //System.out.println(strFirstUpper);
            str4 += strFirstUpper + " ";
        }
        System.out.println(str4);
    }
}
执行结果：
this
is
a
text
this is a practice
this is a easy text
This Is A Text 

可变字符串

• StringBuffer : 可变长字符串，JDK1.0提供，运行效率慢、线程安全
• StringBuilder : 可变长字符串、JDK5.0提供，运行效率快、线程不安全

效率都比String高且节省内存

StringBuffer&StringBuilder常用方法

以下方法StringBuffer 和 StringBuilder 用法一致

【演示】

public class Demo01 {
    public static void main(String[] args) {
        /*
        StringBuffer 和 StringBuilder 用法一致
         */
        StringBuffer str1 = new StringBuffer();
        // StringBuilder str1 = new StringBuilder();
        str1.append("Java");
        System.out.println(str1);// Java
        str1.append("是最好的语言");// 在"Java"后追加"是最好的语言"
        System.out.println(str1);// Java是最好的语言
        str1.insert(0, "我觉得");// 在第一个位置插入"我觉得"
        System.out.println(str1);// 我觉得Java是最好的语言
        str1.replace(0, 3, "他认为");// 用"他认为"替换[0, 3)的内容
        System.out.println(str1);// 他认为ava是最好的语言
        str1.delete(0, 3);// 删除[0, 3)的内容
        System.out.println(str1);// Java是最好的语言
        // str1.delete(0, str1.length());删除str1中所有的内容
        str1.reverse();// 反转str1中的内容
        System.out.println(str1);// 言语的好最是avaJ
    }
}

【StringBuffer、StringBuilder效率都比String高】

public class Demo02 {
    public static void main(String[] args) {
        long start1 = System.currentTimeMillis();// String开始时间
        String str1 = "";
        for (int i = 0; i < 99999; i++) {
            str1 += i;
        }
        long end1 = System.currentTimeMillis();// String结束时间
        System.out.println("String用时"+(end1 - start1));
        long start2 = System.currentTimeMillis();// StringBuffer()开始时间
        StringBuffer str2 = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            str2.append(i);
        }
        long end2 = System.currentTimeMillis();// StringBuffer()结束时间
        System.out.println("StringBuffer用时"+(end2 - start2)); 
    }
}
执行结果：
String用时20291
StringBuffer用时3

public class Demo03 {
    public static void main(String[] args) {
        long start2 = System.currentTimeMillis();// StringBuffer()开始时间
        StringBuffer str2 = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            str2.append(i);
        }
        long end2 = System.currentTimeMillis();// StringBuffer()结束时间
        System.out.println("StringBuffer用时"+(end2 - start2));
        long start3 = System.currentTimeMillis();// StringBuilder开始时间
        StringBuilder str3 = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            str3.append(i);
        }
        long end3 = System.currentTimeMillis();// StringBuilder结束时间
        System.out.println("StringBuilder用时"+(end3 - start3));
    }
}
执行结果：
StringBuffer用时13
StringBuilder用时5

BigDecimal 类

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

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

import java.math.BigDecimal;

public class Demo01 {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");// 需用字符串
        BigDecimal bd2 = new BigDecimal("0.9");
        BigDecimal result1 = bd1.add(bd2);// 加法
        System.out.println("1.0+0.9="+result1);
        BigDecimal result2 = bd1.subtract(bd2);// 减法
        System.out.println("1.0-0.9="+result2);
        BigDecimal result3 = bd1.multiply(bd2);// 乘法
        System.out.println("1.0*0.9="+result3);
        BigDecimal result4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println("(1.4-0.5)/0.9="+result4);
        // 除法扩展
        BigDecimal result5 = bd1.divide(bd2, 4, BigDecimal.ROUND_HALF_UP);// 保留4位小数（采用四舍五入）
        System.out.println("1.0/0.9="+result5);
    }
}
执行结果：
1.0+0.9=1.9
1.0-0.9=0.1
1.0*0.9=0.90
(1.4-0.5)/0.9=1
1.0/0.9=1.1111

Date 类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。java.util.Date

时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

构造方法：

• public Date()分配一个 Date对象并对其进行初始化，以便它表示分配的时间，测量到最近的毫秒
• public Date(long date)分配一个 Date对象，并将其初始化为表示从标准基准时间（称为“时代”）即1970年1月1日00:00:00 GMT起的指定毫秒数

【演示】

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        Date today = new Date();// 今天的日期
        System.out.println(today.toString());// toString()方法
        Date yesterday = new Date(today.getTime() - (24*60*60*1000));// 昨天的日期，getTime()方法,(24*60*60*1000)是一天有多少毫秒
        System.out.println(yesterday.toString());
        /*
        after()方法
        before()方法
         */
        boolean flag1 = today.after(yesterday);// today的日期是否在yesterday的日期之后
        System.out.println(flag1);
        boolean flag2 = today.before(yesterday);// today的日期是否在yesterday的日期之前
        System.out.println(flag2);
        /*
        compareTo()方法
        equals()方法
         */
        int a = today.compareTo(yesterday);// today日期在yesterday之前，返回1
        System.out.println(a);
        boolean flag3 = today.equals(yesterday);// 比较today和yesterday日期是否相等
        System.out.println(flag3);
    }
}
执行结果：
Mon Feb 01 12:21:12 CST 2021
Sun Jan 31 12:21:12 CST 2021
true
false
1
false

Calendar类

• Calendar提供了获取或设置各种日历字段的方法

• 构造方法 protected Calendar(); 由于是protected 所以无法直接创建

  通过Calendar calendar = Calendar.getInstance();创建对象

set()方法,get()方法,setTime()方法,getTime()方法

/* set()方法,get()方法,setTime()方法,getTime()方法 */
import java.util.Calendar;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        Calendar calendar1 = Calendar.getInstance();// 通过调用getInstance()创建对象
        Calendar calendar2 = Calendar.getInstance();
        //calendar2.setTime();
        System.out.println(calendar1.getTime());// getTime()方法
        /*
        获取时间信息：年，月，日，时，分，秒
        其中月份0-11,0代表1月，11代表12月
        其中日可以用Calendar.DAY_OF_MONTH，亦可用Calendar.DATE
        其中时：Calendar.HOUR_OF_DAY代表24小时格式，Calendar.HOUR代表12小时格式
         */
        int year = calendar1.get(Calendar.YEAR);// 获取年
        int month = calendar1.get(Calendar.MONTH);// 获取月
        int day = calendar1.get(Calendar.DAY_OF_MONTH);// 获取日
        int hour = calendar1.get(Calendar.HOUR_OF_DAY);// 获取时
        int minute = calendar1.get(Calendar.MINUTE);// 获取分
        int second = calendar1.get(Calendar.SECOND);// 获取秒
        System.out.println("获取的时间："+year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
        /*
        设置时间：年，月，日，时，分，秒
         */
        calendar2.set(Calendar.YEAR, 2022);//设置年
        calendar2.set(Calendar.MONTH, 5);// 设置月
        calendar2.set(Calendar.DAY_OF_MONTH, 23);// 设置日
        //calendar2.set( 2022, 5, 23);整体设置年月日
        calendar2.set(Calendar.HOUR_OF_DAY, 18);// 设置时
        calendar2.set(Calendar.MINUTE, 45);// 设置分
        calendar2.set(Calendar.SECOND, 5);// 设置秒
        //calendar2.set( 2022, 5, 23, 18, 45,1);整体设置年月日时分秒
        Date date = calendar2.getTime();// getTime()返回一个date表示此日历的时间
        calendar2.setTime(date);// setTime()用给定的date设置此日历时间
        System.out.println("设置的时间："+calendar2.getTime());
    }
}
执行结果：
Mon Feb 01 13:32:17 CST 2021
获取的时间：2021年2月1日13:32:17
设置的时间：Thu Jun 23 18:45:05 CST 2022

add()方法，getTimeInMillis()方法，getActualMaximum（）方法，getActualMinimum（）方法

/* add()方法，getTimeInMillis()方法，
getActualMaximum（）方法，getActualMinimum（）方法
*/
import java.util.Calendar;

public class Demo02 {
    public static void main(String[] args) {
        Calendar calendar1 = Calendar.getInstance();
        System.out.println("初始时间："+calendar1.getTime());
        calendar1.add(Calendar.DAY_OF_MONTH, 2);// 日加2
        calendar1.add(Calendar.HOUR_OF_DAY, -5);// 时减5
        System.out.println("修改后的时间："+calendar1.getTime());
        long x = calendar1.getTimeInMillis();// 返回当前时间为UTC的毫秒数
        System.out.println("当前时间为UTC的毫秒数="+x);
        int max = calendar1.getActualMaximum(Calendar.MONTH);// 月份的最大值为11(月份的范围是[0, 11]),11代表的就是12月
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);// 日的最小值为1
        System.out.println(max);
        System.out.println(min);
    }
}
执行结果：
初始时间：Mon Feb 01 14:01:55 CST 2021
修改后的时间：Wed Feb 03 09:01:55 CST 2021
当前时间为UTC的毫秒数=1612314115797
11
1

SimpleDateFormat类

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

format()方法和parse方法

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

public class Demo {
    public static void main(String[] args) throws Exception{
        /*
        格式化日期文本（日期-->字符串）
         */
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/DD HH:mm:ss:SS");// 创建对象
        Date date1 = new Date();// 创建date
        String str1 = sdf1.format(date1);// 格式化date1，将日期转换为字符串
        System.out.println(str1);
        /*
        解析文本日期（字符串-->日期）
         */
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/DD");// 创建对象
        String str2 = "2050/08/12";// 这里字符串的日期格式必须与上面sdf2设置的格式一致，否则会抛出异常
        Date date2 = sdf2.parse(str2);// 解析str2，将字符串转换为日期
        System.out.println(date2);
    }
}
执行结果：
2021/02/32 14:35:31:489
Wed Jan 12 00:00:00 CST 2050

特别说明：原因就是parse是一个带throws 一场的函数，所以如果不在上一级函数也指明抛出异常，或者对parse函数的操作不放在try catch快中，编译就会出错

System类

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

public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)

• src – 源数组

• srcPos – 源数组中的起始位置

• dest – 目标数组

• destPos – 目的地数据中的起始位置

• length – 要复制的数组元素的数量

arraycopy()方法

public class Demo {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5, 6};// 创建源数组
        int[] array2 = new int[4];// 定义一个目标数组
        System.arraycopy(array1, 1, array2, 0, 3);// 从数组array1中从第1个元素开始复制3个数到数组array2中
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }
}
执行结果：
2
3
4
0

currentTimeMillis()

public class Demo02 {
    public static void main(String[] args) {
        long now = System.currentTimeMillis();// 当前时间
        System.out.println(now);
        /*
        扩展：利用System.currentTimeMillis()计时
         */
        long start = System.currentTimeMillis();// StringBuffer()开始时间
        StringBuffer str = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            str.append(i);
        }
        long end = System.currentTimeMillis();// StringBuffer()结束时间
        System.out.println("StringBuffer用时："+(end - start));
    }
}
执行结果：
1612165446765
StringBuffer用时：11

gc()方法

gc()方法参照本文Object类中的finalize()方法

exit()方法

public class Demo03 {
    public static void main(String[] args) {
        int a = 100;
        System.out.println(a);
        System.exit(0);// 正常退出退出jvm
        System.out.println("**java**");// "**java**"不会被打印
    }
}
执行结果：
100