常用类

Object 类

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

getClass() 方法

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

GetClass

package GetClass;

public class GetClassTest {
}

GetClassTest

package GetClass;

public class GetClassTest {
    public static void main(String[] args) {
        GetClass getClass01 = new GetClass();
        GetClass getClass02 = new GetClass();
        Class getClass01Class = getClass01.getClass();
        Class getClass02Class = getClass02.getClass();
        if (getClass01Class == getClass02Class){
            System.out.println("是同一个 Class");
        }else {
            System.out.println("不是同一个 Class");
        }
    }
}

获得输出

是同一个 Class

hashCode() 方法

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

HashCode

package hashCode;

public class HashCodeTest {
}

HashCodeTest

package hashCode;

public class HashCodeTest {
    public static void main(String[] args) {
        hashCode hashCode01 = new hashCode();
        hashCode hashCode02 = new hashCode();
        System.out.println(hashCode01.hashCode());
        System.out.println(hashCode02.hashCode());
        //这个时候如果将实例化后的对象赋值给 hashCode03 ，则会获得和 hashCode01
        //同样的值，因为赋值将对象的地址传递给了 hashCode03
        hashCode hashCode03 = hashCode01;
        System.out.println(hashCode03.hashCode());
    }
}

获得输出

1324119927
990368553
1324119927

toString() 方法

public String toString()
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值

ToString

package toString;

public class ToString {
}

ToStringTest

package toString;

public class ToStringTest {
    public static void main(String[] args) {
        toString toString01 = new toString();
        toString toString02 = new toString();
        System.out.println(toString01.toString());
        System.out.println(toString02.toString());
    }
}

会获得输出

toString.toString@4eec7777
toString.toString@3b07d329

同样可以通过重写 toString 方法

ToString

package toString;

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

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String toString(){
        return name + ":" + age;
    }
}

ToStringTest

package toString;

public class ToStringTest {
    public static void main(String[] args) {
        toString toString01 = new toString("小红",16);
        toString toString02 = new toString("小明",14);
        System.out.println(toString01.toString());
        System.out.println(toString02.toString());
    }
}

获得输出

小红:16
小明:14

equals() 方法

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

Equals

package equals;

public class Equals {
    private String name;
    private int age;
    public Equals(String name,int age){
        this.name = name;
        this.age = age;
    }
}

EqualsTest

package equals;

public class EqualsTest {
    public static void main(String[] args) {
        Equals equals01 = new Equals("小马",22);
        Equals equals02 = new Equals("小王",44);
        Equals equals03 = new Equals("小王",44);
        System.out.println(equals01.equals(equals02));
        System.out.println(equals02.equals(equals03));
    }
}

获得输出

false
false

同样可以通过方法重写来实现比较值是否相等

Equals

package equals;

public class Equals {
    private String name;
    private int age;
    public Equals(String name,int age){
        this.name = name;
        this.age = age;
    }

    public boolean equals(Object obj){
        /*
        1. 比较两个引用是否指向同一个对象
        2. 判断 obj 是否为 null
        3. 判断两个引用指向的实际对象类型是否一致
        4. 强制类型转换
        5. 依次比较各个属性值否时相同
         */
        //1. 比较两个引用是否指向同一个对象
        if(this.hashCode() == obj.hashCode()){
            return true;
        }
        //2. 判断 obj 是否为 null
        if (obj == null){
            return false;
        }
        //3. 判断两个引用指向的实际对象类型是否一致
        if (obj instanceof Equals){
            //4. 强制类型转换
            Equals e = (Equals)obj;
            //5. 依次比较各个属性值否时相同
            if (this.name.equals(e.name) && this.age == e.age){
                return true;
            }
        }
        return false;
    }
}

EqualsTest

package equals;

public class EqualsTest {
    public static void main(String[] args) {
        Equals equals01 = new Equals("小马",22);
        Equals equals02 = new Equals("小王",44);
        Equals equals03 = new Equals("小王",44);
        System.out.println(equals01.equals(equals02));
        System.out.println(equals02.equals(equals03));
    }
}

获得输出

false
true

finalize() 方法

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

Finalize

package finalize;

public class Finalize {

    private String name;
    private int age;

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

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

FinalizeTest

package finalize;

public class FinalizeTest {
    public static void main(String[] args) {
        new Finalize("小红",16);
        new Finalize("小明",14);
        new Finalize("小马",22);
        new Finalize("小王",44);
        new Finalize("小宋",25);
        System.gc();
        System.out.println("回收完毕");
    }
}

获得输出

回收完毕

因为目前 finalize 方法已经被弃用，所以无法重写/使用 finalize 方法

什么是包装类

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

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

类型转换与装箱、拆箱

装箱：把基本类型转换为引用类型
拆箱：把引用类型转换为基本类型

Integer 转换

int 类型

BoxingUnBoxing

package BoxingUnBoxing;

public class BoxingUnBoxing {
    public static void main(String[] args) {
        int num01 = 10;
        //装箱：将基本类型转换为引用类型
        Integer integer01 = new Integer(num01);
        Integer integer02 = Integer.valueOf(num01);
        System.out.println(integer01);
        System.out.println(integer02);
        //拆箱：将引用类型转换为基本类型
        int num02 = integer02.intValue();
        int num03 = integer01.intValue();
        System.out.println(num02);
        System.out.println(num03);
    }
}

获得输出

1.5版本之后，更新自动转换

自动转换

BoxingUnBoxing

package BoxingUnBoxing;

public class BoxingUnBoxing {
    public static void main(String[] args) {
        int num01 = 10;
        //自动装箱
        Integer integer01 = num01;
        System.out.println(integer01);
        //自动拆箱
        int num02 = integer01;
        System.out.println(num02);
    }
}

获得输出

10
10

String 类型

BoxingUnBoxing

package BoxingUnBoxing;

public class BoxingUnBoxingTest {
    public static void main(String[] args) {
        int num01 = 15;
        //装箱：将基本类型转换为引用类型

        //String 类型
        //1.1 使用 + 转换
        String stringNum01_01 = num01 + "";
        //1.2 使用 Integer 中的 toString() 方法
        String stringNum01_02 = Integer.toString(num01);
        //如果需要使用特定进制的转换，则可以使用 toString 重载之后的方法
        String stringNum01_03 = Integer.toString(num01,16);

        System.out.println(stringNum01_01);
        System.out.println(stringNum01_02);
        System.out.println(stringNum01_03);

        //拆箱：将引用类型转换为基本类型

        //String 类型
        //1.1 使用 Integer.parsexxx() 方法
        int intString02_01 = Integer.parseInt(stringNum01_02);
        System.out.println(intString02_01);
        //但是 parseInt 方法中传入的参数不能出现非数字的字符
        //int intString02_02 = Integer.parseInt(stringNum01_02 + "a");
        //System.out.println(intString02_02);
        //会出现 NumberFormatException 异常
    }
}

获得输出

boolean 类型

boolean字符串 类型转换成 boolean 类型，如果 boolean字符串 类型的值为 true 则转换之后的值为 true ；如果 boolean字符串 类型的值不为 true 则转换后的值均为 false

package BoxingUnBoxing;

public class BoxingUnBoxingTest {
    public static void main(String[] args) {
        //装箱：将基本类型转换为引用类型
        //boolean 类型
        String stringBoolean01 = "true";
        String stringBoolean02 = "ture";
        String stringBoolean03 = "false";
        boolean booleanString01 = Boolean.parseBoolean(stringBoolean01);
        boolean booleanString02 = Boolean.parseBoolean(stringBoolean02);
        boolean booleanString03 = Boolean.parseBoolean(stringBoolean03);
        System.out.println(booleanString01);
        System.out.println(booleanString02);
        System.out.println(booleanString03);
    }
}

获得输出

true
false
false

整数缓冲区

Java 预先创建了 256 个常用的整数包装类型对象

package IntBuffer;

public class IntBuffer {
    public static void main(String[] args) {
        Integer integer01 = new Integer(100);
        Integer integer02 = new Integer(100);
        System.out.println(integer01 == integer02);

        Integer integer03 = 100;
        Integer integer04 = 100;
        System.out.println(integer03 == integer04);

        Integer integer05 = 200;
        Integer integer06 = 200;
        System.out.println(integer05 == integer06);
    }
}

获得输出

false
true
false

因为 integer01 和 integer02 分别指向两个数值相同的不同对象，而 == 比较的是引用类型的引用地址，所以会获得 false

因为 integer03 和 integer04 的值在 -128~127 的整数缓冲区中，所以 integer03 和 integer04 的引用值直接指向的是整数缓冲区中的 100 ，而 == 比较的是引用类型的引用地址，所以会获得 true

因为 integer05 和 integer06 的值不在 -128~127 的整数缓冲区中，所以 integer05 和 integer06 的引用值分别指向两个值相同但地址不同的新对象，而 == 比较的是引用类型的引用地址，所以会获得 false

String 类

字符串是常量，创建之后不可改变

不可更改并非指字符串类型的数据值不可更改，而是实例化之后，字符串引用所指向的地址的值无法更改；一般字符串更改自身的值时是创建新的实例并将字符串引用到新的实例上
字符串字面值存储在字符串池中，可以共享

在 JDK7.0 之前，字符串的常量池在方法区中，而 JDK7.0 之后，字符串的常量池被移到了堆中

可以共享是因为字符串被实例化之后，其他字符串可以引用字符串常量池中实例化的常量

直接赋值

package StringType;

public class StringClass {
    public static void main(String[] args) {
        String name01 = "小明";//小明 常量存储在字符串池中
        int name01HashCode01 = name01.hashCode();
        name01 = "小红";//小红 赋值给 name01时，并没有修改数据，而时重新开辟一个空间
        int name01HashCode02 = name01.hashCode();
        String name02 = "小明";
        int name02HashCode03 = name02.hashCode();//因为 小明 存储在字符串池中，当给 name02 赋值时，会直接指向字符串池中的 小明
        String name03 = "小红";
        int name03HashCode04 = name03.hashCode();//因为 小红 存储在字符串池中，当给 name03 赋值时，会直接指向字符串池中的 小红
        System.out.println(name01HashCode01);
        System.out.println(name01HashCode02);
        System.out.println(name02HashCode03);
        System.out.println(name03HashCode04);
        System.out.println(name01 == name03);
    }
}

获得输出

new 实例化

与直接赋值不同的是

String a = "Hello"

产生一个对象，在字符串池中存储，而 a 直接引用该对象的地址
String a = new String("Hello")

产生两个对象，在 堆 、池 中各存储一个，字符串的数值存储在 字符串池 中，而 堆 中存在一个引用 字符串池 中字符串数值对象地址的引用，而字符串则引用 堆 中的引用

package StringType;

public class StringClass {
    public static void main(String[] args) {
        //new 实例化赋值
        String name04 = new String("小明");
        String name05 = new String("小明");
        int name04HashCode01 = name04.hashCode();
        int name05HashCode01 = name05.hashCode();
        System.out.println(name04 == name05);
    }
}

获得输出

false

String 常用方法

length 返回字符串长度

package StringType;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        System.out.println(text.length());
    }
}

获得输出

charAt 返回某个位置的字符

package StringType;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        System.out.println(text.charAt(4));
    }
}

获得输出

contains 判断该字符串中是否存在某段字符串

package StringType;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        System.out.println(text.contains("ming"));
        System.out.println(text.contains("minh"));
    }
}

获得输出

true
false

toCharArray 将字符串转换为数组

package StringType;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        for (char c : text.toCharArray()) {
            System.out.println(c);
        }
    }
}

获得输出

x
i
a
o
m
i
n
g

indexOf 查找某字符串首次出现在字符串的下标；如果存在则返回下标，不存在返回-1

package StringType;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        System.out.println(text.indexOf("i"));
    }
}

获得输出

因为下标从 0 开始，所以获得输出 1

lastIndexOf 查找字符串在当前字符串中最后一次出现的下标

package StringType;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        System.out.println(text.lastIndexOf("i"));
    }
}

获得输出

trim 去掉字符串前后的空格

package StringType;

import java.util.Locale;

public class StringMethod {
    public static void main(String[] args) {
        String text = "  xiaoming  ";
        System.out.println(text);
        System.out.println(text.trim());
    }
}

获得输出

  xiaoming  
xiaoming

toUpperCase 将小写转成大写

package StringType;

import java.util.Locale;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaomingAA";
        System.out.println(text.toUpperCase());
    }
}

获得输出

XIAOMINGAA

toLowerCase 将大写转成小写

package StringType;

import java.util.Locale;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaomingAA";
        System.out.println(text.toLowerCase(Locale.ROOT));
    }
}

获得输出

xiaomingaa

endWith 判断字符串是否以某段字符串结尾

package StringType;

import java.util.Locale;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaomingAA";
        System.out.println(text.endsWith("aa"));
        System.out.println(text.toLowerCase(Locale.ROOT).endsWith("aa"));
    }
}

获得输出

false
true

endWith 方法区分大小写，因为原字符串是 AA 结尾，所以第一次输出会获得 false ，而第二次原字符已经被全部转成小写，所以第二次判断获得了 true

replace 将旧字符串换成新字符串

package StringType;

import java.util.Locale;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        System.out.println(text.replace("ming", "hong"));
        System.out.println(text);
    }
}

获得输出

xiaohong
xiaoming

第二次输出 text 获得 xiaoming 是因为 replace 只替换字符串，而不改变原本的字符串；在没有给 text 重新赋值的情况下，text 不会因为 replace 的替换而改变自身值的引用。

split 根据传入的字符串参数来拆分某个字符串

package StringType;

import java.util.Locale;

public class StringMethod {
    public static void main(String[] args) {
        String text = "xiaoming";
        for (String o : text.split("i")) {
            System.out.println(o);
        }
    }
}

获得输出

x
aom
ng

split 会根据传入的参数拆分字符串，并返回一个数组；拆分之后的字符串不包含用于拆分的字符串

案例

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

package StringType;

import java.util.Locale;

public class StringTest {
    public static void main(String[] args) {
        /*
        已知 String str = "this is a text";
        将 str中的单词单独获取
        将 str 中的 text 替换为 practice
        在 text 前面插入一个 easy
        将每个单词的首字母改为大写
         */
        String str = "this is a text";
        String [] stringArray = str.split(" ");
        str = str.replace("text","practice");
        str = str.replace("practice", "easy practice");
        String str02 = "";
        for (String s : str.split(" ")) {
            s = s.substring(0,1).toUpperCase(Locale.ROOT) + s.substring(1);
            str02 = str02 + s + " ";
        }
        System.out.println(str02);
    }
}

可变字符串

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

和 String 相比

效率比 String 高
比 Sring 节省内存

append 追加内容

package StringType;

public class StringBuffer_StringBuilder {
    public static void main(String[] args) {
        StringBuffer stringBuffer01 = new StringBuffer();
        stringBuffer01.append("小宋是小马最好的朋友");
        System.out.println(stringBuffer01);
        stringBuffer01.append("小王也想当小马的朋友");
        System.out.println(stringBuffer01);
    }
}

获得输出

小宋是小马最好的朋友
小宋是小马最好的朋友小王也想当小马的朋友

insert 添加内容

package StringType;

public class StringBuffer_StringBuilder {
    public static void main(String[] args) {
        StringBuffer stringBuffer01 = new StringBuffer();
        stringBuffer01.insert(0,"小马想要和小宋交朋友");
        System.out.println(stringBuffer01);
        stringBuffer01.insert(stringBuffer01.length(),"小马不想和小王交朋友");
        System.out.println(stringBuffer01);
    }
}

需要传入两个参数，第一个参数确认添加内容的位置下标，第二个参数为添加的内容

获得输出

小马想要和小宋交朋友
小马想要和小宋交朋友小马不想和小王交朋友

insert 替换内容

package StringType;

public class StringBuffer_StringBuilder {
    public static void main(String[] args) {
        StringBuffer stringBuffer01 = new StringBuffer();
        stringBuffer01.insert(0,"小马想要和小宋交朋友");
        System.out.println(stringBuffer01);
        stringBuffer01.insert(stringBuffer01.length(),"小马不想和小王交朋友");
        System.out.println(stringBuffer01);
        stringBuffer01.replace(0,2,"小魏");
        System.out.println(stringBuffer01);
    }
}

需要传入三个参数，前两个参数为需要替换的字符下标，第三个参数为替换的内容。

替换的字符的下标含头不含尾，也就是说，如果想要替换 0~1 下标的字符，则需要传入 0,2

获得输出

小马想要和小宋交朋友
小马想要和小宋交朋友小马不想和小王交朋友
小魏想要和小宋交朋友小马不想和小王交朋友

delete 删除内容

package StringType;

public class StringBuffer_StringBuilder {
    public static void main(String[] args) {
        StringBuffer stringBuffer01 = new StringBuffer();
        stringBuffer01.insert(0,"小马想要和小宋交朋友");
        System.out.println(stringBuffer01);
        stringBuffer01.insert(stringBuffer01.length(),"小马不想和小王交朋友");
        System.out.println(stringBuffer01);
        stringBuffer01.delete(0,stringBuffer01.indexOf("交朋友")+3);
        System.out.println(stringBuffer01);
    }
}

需要传入两个参数，同样含头不含尾

获得输出

小马想要和小宋交朋友
小马想要和小宋交朋友小马不想和小王交朋友
小马不想和小王交朋友

StringBuilder 效率比 String 效率高的测试案例

StringBuilder 效率比 StringBuffer 和 String 高

package StringType;

public class StringBuffer_StringBuilder {
    public static void main(String[] args) {
        long stringStartTime = System.currentTimeMillis();
        String string = "";
        for (int i = 0; i < 999999; i++) {
            string+=i;
        }
        long stringEndTime = System.currentTimeMillis();
        System.out.println(stringEndTime-stringStartTime);
        long stringBuilderStartTime = System.currentTimeMillis();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 999999; i++) {
            stringBuilder.append(i);
        }
        long stringBuilderEndTime = System.currentTimeMillis();
        System.out.println(stringBuilderEndTime-stringBuilderStartTime);
    }
}

获得输出

406593
19

BigDecimal

示例

public class BigDecimal {
    public static void main(String[] args) {
        double money01 = 1.0;
        double money02 = 0.9;
        System.out.println(money01-money02);
    }
}

获得输出

0.09999999999999998

正常逻辑下 1.0-0.9=0.1 但是 double 的存储是近似值存储，无法精准运算。

subtract 减法

package BigDecimal;

public class BigDecimal {
    public static void main(String[] args) {
        java.math.BigDecimal money03 = new java.math.BigDecimal("1.0");
        java.math.BigDecimal money04 = new java.math.BigDecimal("0.9");
        System.out.println(money03.subtract(money04));
    }
}

如果可以，尽量使用 String 方式传入参数给 BigDecimal ，避免产生精度问题

获得输出

0.1

add 加法

package BigDecimal;

public class BigDecimal {
    public static void main(String[] args) {
        java.math.BigDecimal money03 = new java.math.BigDecimal("1.0");
        java.math.BigDecimal money04 = new java.math.BigDecimal("0.9");
        System.out.println(money03.add(money04));
    }
}

获得输出

1.9

multiply 乘法

package BigDecimal;

public class BigDecimal {
    public static void main(String[] args) {
        java.math.BigDecimal money03 = new java.math.BigDecimal("1.0");
        java.math.BigDecimal money04 = new java.math.BigDecimal("0.9");
        System.out.println(money03.multiply(money04));
    }
}

获得输出

0.90

divide

package BigDecimal;

public class BigDecimal {
    public static void main(String[] args) {
        java.math.BigDecimal money03 = new java.math.BigDecimal("1.0");
        java.math.BigDecimal money04 = new java.math.BigDecimal("0.9");
        System.out.println(money03.multiply(
                new java.math.BigDecimal("0.9"))
                .divide(money04));
    }
}

获得输出

1.0

如果遇见除法结果过长会导致报错

Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
    at java.base/java.math.BigDecimal.divide(BigDecimal.java:1766)

需要通过传入参数来舍去小数点后的数

package BigDecimal;

public class BigDecimal {
    public static void main(String[] args) {
        java.math.BigDecimal money03 = new java.math.BigDecimal("1.0");
        java.math.BigDecimal money04 = new java.math.BigDecimal("0.9");
        System.out.println(money03.divide(money04,3, java.math.BigDecimal.ROUND_HALF_UP));
    }
}

获得输出

1.111

四舍五入之后只取小数点后 3 位

Date

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

toString 和 toLocaleString

package DateClass;

public class Date {
    public static void main(String[] args) {
        java.util.Date date01 = new java.util.Date();
        System.out.println(date01.toString());
        System.out.println(date01.toLocaleString());
    }
}

toString 的方式输出不符合国人的使用习惯

toLocaleString 根据本机输出日期格式

获得输出

Tue Dec 06 12:10:20 CST 2022
2022年12月6日 下午12:10:20

getTime 计算从 1970.1.1 以来，由此 Date 表示的毫秒数

package DateClass;

public class Date {
    public static void main(String[] args) {
        java.util.Date date01 = new java.util.Date();
        System.out.println(date01.getTime());
        //获取今天的时间并换成 long 型长数据之后减去一天的毫秒数 可以获得昨天的时间
        java.util.Date date02 = new java.util.Date(date01.getTime()-(60*60*24*1000));
        System.out.println(date02.toLocaleString());
    }
}

获得输出

1670300438321
2022年12月5日 下午12:20:38

after 测试此日期是否在指定日期之后

package DateClass;

public class Date {
    public static void main(String[] args) {
        java.util.Date date01 = new java.util.Date();
        java.util.Date date02 = new java.util.Date(date01.getTime()-(60*60*24*1000));
        System.out.println(date01.after(date02));
    }
}

获得输出

true

before 测试此日期是否在指定日期之前

package DateClass;

public class Date {
    public static void main(String[] args) {
        java.util.Date date01 = new java.util.Date();
        java.util.Date date02 = new java.util.Date(date01.getTime()-(60*60*24*1000));
        System.out.println(date01.before(date02));
    }
}

获得输出

false

compareTo

package DateClass;

public class Date {
    public static void main(String[] args) {
        java.util.Date date01 = new java.util.Date();
        java.util.Date date02 = new java.util.Date(date01.getTime()-(60*60*24*1000));
        java.util.Date date03 = new java.util.Date(date01.getTime()-(60*60*24*1000*10));
        //后一天比较前一天 返回 1
        System.out.println(date01.compareTo(date02));
        System.out.println(date01.compareTo(date03));
        //当天比较当天 返回 0
        System.out.println(date01.compareTo(date01));
        //前一天比较后一天 返回 -1
        System.out.println(date02.compareTo(date01));
        System.out.println(date03.compareTo(date01));
    }
}

compareTo 方法返回的值只有 1 、0 、-1

获得输出

equals

package DateClass;

public class Date {
    public static void main(String[] args) {
        java.util.Date date01 = new java.util.Date();
        java.util.Date date02 = new java.util.Date(date01.getTime()-(60*60*24*1000));
        System.out.println(date01.equals(date01));
        System.out.println(date01.equals(date02));
    }
}

获得输出

true
false

Calendar

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

创建对象

package CalendarMethod;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //创建对象
        Calendar calendar01 = Calendar.getInstance();
    }
}

获取时间

package CalendarMethod;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //创建对象
        Calendar calendar01 = Calendar.getInstance();

        //获取时间
        System.out.println(calendar01.toString());
        System.out.println(calendar01.getTime().toString());
        System.out.println(calendar01.getTime().toLocaleString());
    }
}

因为 Calendar 方法包含的参数很多，所以需要使用 getTime 方法获取时间

获得输出

java.util.GregorianCalendar[time=1670313300152,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=11,WEEK_OF_YEAR=50,WEEK_OF_MONTH=2,DAY_OF_MONTH=6,DAY_OF_YEAR=340,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=3,HOUR_OF_DAY=15,MINUTE=55,SECOND=0,MILLISECOND=152,ZONE_OFFSET=28800000,DST_OFFSET=0]
Tue Dec 06 15:55:00 CST 2022
2022年12月6日 下午3:55:00

获取时间信息

package CalendarMethod;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //创建对象
        Calendar calendar01 = Calendar.getInstance();

        //获取时间
        System.out.println(calendar01.toString());
        System.out.println(calendar01.getTime().toString());
        System.out.println(calendar01.getTime().toLocaleString());

        //获取时间信息
        //年
        int year = calendar01.get(Calendar.YEAR);
        //月
        int month01 = calendar01.get(Calendar.MONTH);
        int month02 = calendar01.get(Calendar.MONTH) + 1;
        //日
        int day = calendar01.get(Calendar.DAY_OF_MONTH);
        //时
        int hour = calendar01.get(Calendar.HOUR_OF_DAY);
        //分
        int minute = calendar01.get(Calendar.MINUTE);
        //秒
        int second = calendar01.get(Calendar.SECOND);
        System.out.println("当前时间为: " +
                year + "年" + month01 + "月" + day + "日" +
                hour + "时" + minute + "分" + second + "秒");
        System.out.println("当前时间为: " +
                year + "年" + month02 + "月" + day + "日" +
                hour + "时" + minute + "分" + second + "秒");
    }
}

与国人常用的月份计算不同的是，国外的月份计算是从 0~11 计算，也就是会比当前月份少一个月

Calendar 的 get 方法需要传入一个 int 类型的参数，可以自己写入数值，也可以直接使用 Calendar 提供的常量。

获得输出

当前时间为: 2022年11月6日16时8分47秒
当前时间为: 2022年12月6日16时8分47秒

set 修改时间

package CalendarMethod;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //修改时间
        Calendar calendar02 = Calendar.getInstance();
        calendar02.set(Calendar.DAY_OF_MONTH,1);
        System.out.println(calendar02.getTime().toLocaleString());
    }
}

获得输出

2022年12月1日 下午6:36:45

add 添加时间

package CalendarMethod;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //add 添加时间
        System.out.println(calendar02.getTime().toLocaleString());
        calendar02.add(Calendar.HOUR_OF_DAY,10);
        calendar02.add(Calendar.MONTH,-1);
        System.out.println(calendar02.getTime().toLocaleString());
    }
}

参数传入正数是为添加，传入负数时为减去

获得输出

2022年12月1日 下午6:41:03
2022年11月2日 上午4:41:03

获取当前时间最大最小值

package CalendarMethod;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar calendar03 = Calendar.getInstance();
        System.out.println(calendar03.getActualMaximum(Calendar.DAY_OF_MONTH));
        System.out.println(calendar03.getActualMinimum(Calendar.DAY_OF_MONTH));
    }
}

获得输出

31
1

SimpleDateFormat

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

字母时间或日期

y 年

M 年中月份

d 月中天数

H 1天中小时数

m 分钟

s 秒

S 毫秒

字母	时间或日期
y	年
M	年中月份
d	月中天数
H	1天中小时数
m	分钟
s	秒
S	毫秒

format 格式化

package SimpleDateFormatMethod;

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        //创建 SimpleDateFormat 对象
        SimpleDateFormat simpleDateFormat01 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //创建 Date
        Date date01 = new Date();
        //格式化 date
        String dateString = simpleDateFormat01.format(date01);
        System.out.println(dateString);
    }
}

获得输出

2022-12-06 19:40:36

parse 解析

package SimpleDateFormatMethod;

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws Exception {
        //创建 SimpleDateFormat 对象
        SimpleDateFormat simpleDateFormat01 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //解析
        Date date02 = simpleDateFormat01.parse("2020-01-01 00:00:00");
        System.out.println(date02.toLocaleString());
    }
}

因为格式问题会出现异常，需要抛出异常

获得输出

2020年1月1日 上午12:00:00

System

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

arraycopy 数组的复制

package SystemClass;

public class SystemDemo {
    public static void main(String[] args) {
        //数组的复制
        //需要传入五个参数
        //源数组 复制的下标 目标数组 目标数组的下标 复制的长度
        int [] intArrayCopy01 = {10,20,0,15,6,8,30,35};
        int [] intArrayCopy02 = new int[8];
        for (int i : intArrayCopy01) {
            System.out.println(i);
        }
        System.out.println("======Array01======");
        for (int i : intArrayCopy02) {
            System.out.println(i);
        }
        System.out.println("======Array02======");
        System.arraycopy(intArrayCopy01,0,intArrayCopy02,0,intArrayCopy01.length);
        for (int i : intArrayCopy02) {
            System.out.println(i);
        }
    }
}

获得输出

10
20
0
15
6
8
30
35
======Array01======
0
0
0
0
0
0
0
0
======Array02======
10
20
0
15
6
8
30
35

currentTimeMillis 获取当前时间

可以用来计时代码所执行花费的时间

package SystemClass;

public class SystemDemo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int int01 = 0;
        for (int i = 0; i < 99999; i++) {
            for (int j = 0; j < 99999; j++) {
                int01 = i+j;
            }
        }
        System.out.println(int01);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

获得输出

199996
4

gc 告知 JVM 回收垃圾

SystemDemo

package SystemClass;

import java.lang.ref.Cleaner;

public class SystemDemo {
    public static void main(String[] args) {
        GcDemo gcDemo01 = new GcDemo("01",01);
        GcDemo gcDemo02 = new GcDemo("02",02);
        GcDemo gcDemo03 = new GcDemo("03",03);
        GcDemo gcDemo04 = new GcDemo("04",04);
        GcDemo gcDemo05 = new GcDemo("05",05);
        GcDemo gcDemo06 = new GcDemo("06",06);
        gcDemo01 = null;
        gcDemo02 = null;
        gcDemo03 = null;
        gcDemo04 = null;
        gcDemo05 = null;
        gcDemo06 = null;
        gcDemo07 = null;
        System.gc();
        System.gc();

    }
}

GcDemo

package SystemClass;

import java.lang.ref.Cleaner;

public class GcDemo {
    private String name;
    private int ID;

    public GcDemo(String name, int ID) {
        this.name = name;
        this.ID = ID;
    }

    public GcDemo() {
    }

    public String getName() {
        return name;
    }

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

    public int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

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

    @Override
    protected void finalize() throws Throwable {
        System.out.println("垃圾回收了：");
    }
}

获得输出

垃圾回收了：
垃圾回收了：
垃圾回收了：
垃圾回收了：
垃圾回收了：
垃圾回收了：

本来我尝试调用 name 和 ID 来区分回收的实例。但是之后发现一旦调用 name 和 ID 则实例不会被回收，并且即使不调用 name 和 ID 实例也概率性被回收。

我运行了几次，每次获得的输出数量都不同。

exit 退出JVM

package SystemClass;

import java.lang.ref.Cleaner;

public class SystemDemo {
    public static void main(String[] args) {
        System.exit(0);
        System.out.println("程序退出了");
    }
}

exit 传入的参数为 0 时代表正常退出，非0 表示异常退出

获得输出

JVM 结束后的代码不再执行