Java常用类（完整版）

其他类

Object类

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

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

Object类中所定义的方法，是所有对象都具备的方法

Object类型可以存储任何对象：

作为参数，可接受任何对象

作为返回值，可接受任何对象

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

    public Student() {

    }

    public Student(String name,int age){
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }

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

    @Override
    public boolean equals(Object obj) {
        // 1. 判断俩个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        // 2. 判断obj是否为null
        if (obj == null){
            return false;
        }
        // 3. 判断是否是同一个类型
        if (obj instanceof Student){
            // 4. 强制类型转换
            Student s = (Student) obj;
            // 5. 比较属性
            if (this.name.equals(s.getName()) && this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
}


// 测试类
public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",25);
        Student s2 = new Student("bbb",35);
    }
}

getClass()方法

语法：
    public final Class<?> getClass(){
    
}

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

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

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

        //运行结果：
        // s1和s2属于同一个类型

hashCode()方法

语法：
    public int hashCode(){
    
}

返回该对象的哈希码值

哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码值

// hashCode方法
        System.out.println(s1.hashCode());  // 460141958
        System.out.println(s2.hashCode());  // 1163157884
        Student s3 = s1;
        System.out.println(s3.hashCode());  // 460141958
        System.out.println("----------------------");

toString()方法

语法：
    public String toString(){
    
}

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

可以根据程序需要覆盖该方法，如：展示对象各个属性值（重写方法）

        // toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println("----------------------");



运行结果：
    Student [name = aaa , age = 25]
	Student [name = bbb , age = 35]

equals()方法

语法：
    public boolean equals(Object obj){
    
}

默认实现为（this == obj），比较俩个对象地址是否相同

可进行覆盖（重写），比较俩个对象的内容是否相同

// equals方法
        System.out.println(s1.equals(s2));  // false
        Student s4 = new Student("小明",18);
        Student s5 = new Student("小明",18);
        System.out.println(s4.equals(s5));  // true 重写方法后


运行结果：
    false
	true

equals()方法覆盖步骤
    1. 比较俩个引用是否指向同一个对象
    2. 判断obj是否为null
    3. 判断俩个引用指向的实际对象类型是否一致
    4. 强制类型转换
    5. 依次比较各个属性值是否相同

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列

垃圾对象：没有有效引用指向此对象，为垃圾对象

垃圾回收：由GC销毁垃圾对象，释放数据存储空间

自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象

手动回收机制：使用 System.gc(); 通知JVM执行垃圾回收

完整代码


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

    public Student() {

    }

    public Student(String name,int age){
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }

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

    @Override
    public boolean equals(Object obj) {
        // 1. 判断俩个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        // 2. 判断obj是否为null
        if (obj == null){
            return false;
        }
        // 3. 判断是否是同一个类型
        if (obj instanceof Student){
            // 4. 强制类型转换
            Student s = (Student) obj;
            // 5. 比较属性
            if (this.name.equals(s.getName()) && this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
}



// 测试类

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",25);
        Student s2 = new Student("bbb",35);
        // getClass方法
        // 判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
        System.out.println("----------------------");

        //运行结果：
        // s1和s2属于同一个类型

        // hashCode方法
        System.out.println(s1.hashCode());  // 460141958
        System.out.println(s2.hashCode());  // 1163157884
        Student s3 = s1;
        System.out.println(s3.hashCode());  // 460141958
        System.out.println("----------------------");

        // toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println("----------------------");

        // equals方法
        System.out.println(s1.equals(s2));  // false
        Student s4 = new Student("小明",18);
        Student s5 = new Student("小明",18);
        System.out.println(s4.equals(s5));  // true 重写方法后

    }
}

包装类

什么是包装类

Java的基本数据类型（如int、char、boolean等）是非对象的，不能直接参与面向对象的操作，也不能直接调用方法。为了解决这个问题，Java提供了对应的包装类。

包装类就是：基本数据类型所对应的引用数据类型

Object 可统一所有数据，包装类的默认值是 null

包装类对应

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

类型转换与装箱、拆箱

8种包装类提供不同类型间的转换方式：
- Number父类中提供的6个共性方法
- parseXXX ( )静态方法
- valueOf ( )静态方法
注意：需要保证类型兼容，否则抛出 NumberFromatException 异常

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

        // 类型转型：    拆箱：引用类型转成基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

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


        System.out.println("=============基本类型和字符串之间转换==============");
        // 基本类型和字符串之间转换
        // 1. 基本类型转换成字符串
        int n1 = 255;
        int n2 = 15;
        // 1-1 使用 +    相连
        String s1 = n1+"";
        String s2 = n2+"";
        // 1-2 使用Integer中的 toString()方法
        String s3 = Integer.toString(n1,16);
        String s4 = Integer.toString(n2,16);
        System.out.println(s1);  // 255
        System.out.println(s2);  // 15
        System.out.println(s3);  // ff
        System.out.println(s4);  // f

        // 2. 字符串转基本类型
        String str = "150";
        // 使用 Integer.parseXXX();
        int n3 = Integer.parseInt(str);
        System.out.println(n3);  // 150

        // boolean 字符串形式转成基本形式。 "true" --> true    非true --> false
        String str2 = "true";
        String str3 = "abcd";
        boolean b1 = Boolean.parseBoolean(str2);
        boolean b2 = Boolean.parseBoolean(str3);
        System.out.println(b1);  // true
        System.out.println(b2);  // false

    }
}

整数缓冲区

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

在实际应用中，对已创建的对象进行复用

// 整数缓冲区
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);  // false

        // 自动装箱  Integer.valueOf
        Integer integer3 = 100;
        Integer integer4 = 100;
        System.out.println(integer3==integer4);  // true

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

integer3 与 integer4 相等是因为：在整数缓冲区范围内（-128~127）

在这里插入图片描述

integer5 与 integer6 不相等是因为：范围（200）已经超出缓冲区范围，变为使用new 关键字

在这里插入图片描述

String 类

定义

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

字符串字面值存储在字符串池中，可以共享

String s = “Hello” ; // 产生一个对象，字符串池中存储

String s = new String (“Hello”) ; // 产生俩个对象，堆、池各存储一个。

如图所示

在这里插入图片描述

在JDK1.7之前运行时常量池逻辑包含字符串常量池存放在方法区, 此时hotspot虚拟机对方法区的实现为永久代
在JDK1.7 字符串常量池被从方法区拿到了堆中, 这里没有提到运行时常量池,也就是说字符串常量池被单独拿到堆,运行时常量池剩下的东西还在方法区, 也就是hotspot中的永久代
在JDK1.8 hotspot移除了永久代用元空间(Metaspace)取而代之, 这时候字符串常量池还在堆, 运行时常量池还在方法区, 只不过方法区的实现从永久代变成了元空间(Metaspace)

String name = "hello";  // "hello" 常量存储在字符串池中
name = "zhangsan";  // "zhangsan" 赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
String name2 = "zhangsan";
System.out.println(name==name2);  // true

// 演示字符串的另一种创建方式， new String();
String str = new String("java");
String str2 = new String("java");  // 在堆的空间新开辟了str2，虽然指向的是同一个数据，但是地址是不一样的
System.out.println(str==str2);  // false  使用 == 比较的是地址
System.out.println(str.equals(str2));  // true  使用 equals 比较的是数据

常用方法

public int length () ; 返回字符串的长度
public char charAt (int index) ; 根据下标获取字符

public boolean contains (String str) ; 判断当前字符串中是否包含str

        // 字符串方法的使用
        // 1. length(); 返回字符串的长度    注意：这里空格也算一个字符串长度
        // 2. charAt(int index); 返回某个位置的字符
        // 3. contains(String str); 判断是否包含某个子字符串
        String s = "Java是世界上最好的编程语言,Java就是最简单的,Java最好";
        System.out.println(s.length());  // 15
        System.out.println(s.charAt(5));  // 世
        System.out.println(s.charAt(s.length()-1));  // 言
        System.out.println(s.contains("java"));  // false
        System.out.println(s.contains("Java"));  // true
        System.out.println(s.contains("JavaScript"));  // false

public char[ ] toCharArray ( ) ; 将字符串转换成数组
public int indexOf (String str) ; 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1

public int lastIndexOf (String str) ; 查找字符串在当前字符串中最后一次出现的下标索引

		// 4. toCharArray(); 返回字符串对应的数组
        // 5. indexOf(); 返回字符串首次出现的位置，如果未找到，返回-1。后面如果＋数字表示：从第几个位置开始查找
        // 6. lastIndexOf(); 返回字符串最后一次出现的位置
        System.out.println(s.toCharArray());  // Java是世界上最好的编程语言,Java就是最简单的,Java最好
        System.out.println(Arrays.toString(s.toCharArray()));  // [J, a, v, a, 是, 世, 界, 上, 最, 好, 的, 编, 程, 语, 言, ,, J, a, v, a, 就, 是, 最, 简, 单, 的, ,, J, a, v, a, 最, 好]
        System.out.println(s.indexOf("Java"));  // 0
        System.out.println(s.indexOf("Java",4));  // 16
        System.out.println(s.lastIndexOf("Java"));  // 27

public String trim () ; 去掉字符串前后的空格
public String toUpperCase () ; 将小写转为大写

public boolean endWith (String str) ; 判断字符串是否以str结尾

		// 7. trim(); 去掉字符串前后的空格
        // 8. toUpperCase(); 把小写转为大写   toLowerCase(); 把大写转为小写
        // 9. endsWith(str); 判断是否以str结尾   startsWith(str); 判断是否以str开始
        String s2 = "     Hello World !   ";
        System.out.println(s2.trim());  // Hello World !
        System.out.println(s2.toUpperCase());  //      HELLO WORLD !
        System.out.println(s2.toLowerCase());  //      hello world !
        String s3 = "hello.java";
        System.out.println(s3.endsWith("va"));  // true
        System.out.println(s3.startsWith("he"));  // true
        System.out.println(s3.startsWith("ll"));  // false

public String replace (char oldChar , char newChar) ; 将旧字符串替换成新字符串

public String[ ] split (String str) ; 根据str做拆分

		String s4 = "java is the best language java";
        String say = "java is the best    programing language,java is good.";
        System.out.println(s4.replace("java","php"));  // php is the best language php
        String[] arr = say.split("[ ,.]+");
        System.out.println(arr.length);  // 9
        for (String string:arr) {
            System.out.println(string);
        }
/*
java
is
the
best
programing
language
java
is
good

 */

补充

补充俩个方法 equals、compareTo(); 比较大小
        String str3 = "hello";
        String str4 = "HELLO";
        System.out.println(str3.equals(str4));  // false
        System.out.println(str3.equalsIgnoreCase(str4));  // true

        String a1 = "abc";  // 97  比较ASCII码
        String a2 = "ayzawe";  // 120
        System.out.println(a1.compareTo(a2));  // -23   比较大小

        String a3 = "abc";  // 3
        String a4 = "abcdefg";  // 7
        System.out.println(a3.compareTo(a4));  // -4    比较长度 3-7

测试

已知 String str = “this is a text”;

将 str 中的单词单独获取出来
将 str 中的text替换为 practice
在 text 前面插入一个 easy
将每个单词的首字母改为大写

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

        String str = "this is a text";
        // 1. 将 str 中的单词单独获取出来
        String[] arr =str.split(" ");
        // System.out.println(arr);
        for (String s:arr) {
            System.out.println(s);
        }
        System.out.println("----------------");
        // 2. 将 str 中的text替换为 practice
        String str2 = str.replace("text","practice");
        System.out.println(str2);
        System.out.println("----------------");
        // 3. 在 text 前面插入一个 easy
        String str3 = str.replace("text","easy text");
        System.out.println(str3);
        System.out.println("----------------");
        // 4. 将每个单词的首字母改为大写
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            // 把第一个字符转为大写
            char upperfirst = Character.toUpperCase(first);
            //System.out.println(upperfirst);  // 把所有首字母大写 遍历
            String str4 = upperfirst + arr[i].substring(1);
            System.out.println(str4);
        }

    }
}

运行结果：
1.
this
is
a
text
2.
this is a practice
3.
this is a easy text
4.
This
Is
A
Text

可变字符串

StringBuffer：可变长字符串，JDK 1.0 提供，运行效率慢、线程安全

StringBuilder：可变长字符串，JDK 5.0 提供，运行效率快、线程不安全

StringBuffer 和 StringBuilder 的使用与String的区别：

   1. 效率比String高
1. 效率比String高

        StringBuffer sb1 = new StringBuffer();
        StringBuilder sb2 = new StringBuilder();
        // 1. append();     追加
        sb1.append("java ");
        System.out.println(sb1.toString());
        sb1.append("javascript ");
        System.out.println(sb1.toString());
        sb1.append("c++ ");
        System.out.println(sb1.toString());
        System.out.println("---------------------");
        // 2. insert();     添加
        sb1.insert(0,"我要学");
        sb1.insert(sb1.length(),"做一个高级程序员");
        System.out.println(sb1.toString());
        System.out.println("---------------------");
        // 3. replace();    替换
        sb1.replace(0,3,"hello ");
        System.out.println(sb1.toString());
        System.out.println("---------------------");
        // 4. delete();     删除
        sb1.delete(0,3);
        System.out.println(sb1.toString());
        System.out.println("--------------------------");
        // 清空
        sb1.delete(0,sb1.length());
        System.out.println(sb1.toString());
        System.out.println("------------------------------==");

运行结果：
java
java javascript
java javascript c++
---------------------
我要学java javascript c++ 做一个高级程序员
---------------------
hello java javascript c++ 做一个高级程序员
---------------------
lo java javascript c++ 做一个高级程序员
--------------------------

------------------------------==

package OOP.Class_6;

public class Demo03 {
    public static void main(String[] args) {
        double num1 = 0.9;
        double num2 = 0.8;
        System.out.println(num1 - num2);//0.09999999999999998

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

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

下面是代码演示：

public static void main(String[] args) {
        // 思考：
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);  // 0.09999999999999998

        double result = (1.4-0.5)/0.9;
        System.out.println(result);  // 0.9999999999999999
//        double res = (d1*d2);
//        System.out.println(res);  // 0.9
        // 这些结果都丢失了精度
        // 在很多实际应用中需要精确计算，而double是近似值存储，不在符合要求，需要借助 BigDecimal 进行精确计算
        // BigDecimal   大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        // 减法   subtract
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);  // 0.1
        // 加法   add
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);  // 1.9
        // 乘法   multiply
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);  // 0.90
        // 除法   divide
        BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(r4);  // 1
        // BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"));
        // System.out.println(r5);  // ArithmeticException
        BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_UP);
        System.out.println(r5);  // 6.67  // " 2,BigDecimal.ROUND_UP " 保留俩位小数 向上取

    }

Date类

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

时间单位：

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

创建一个今天的此时此刻

// 今天 此时此刻(这是我当时打代码的时间)
        Date date1 = new Date();
        System.out.println(date1.toString());  // Thu Dec 12 15:06:35 CST 2024
        System.out.println(date1.toLocaleString());  // 2024-12-12 15:07:14     toLocaleString 已过时

昨天

 // 昨天 此时此刻(今天的时间-一天的毫秒数)
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));  // (60秒 * 60分 * 24时 * 1000毫秒)
        System.out.println(date2.toLocaleString());  // 2024-12-11 15:09:31

方法：

after与before

        boolean b1 = date1.after(date2);
        boolean b2 = date1.before(date2);
        System.out.println(b1);  // true
        System.out.println(b2);  // false

比较 compareTo();

        int d = date1.compareTo(date2);
        int d1 = date1.compareTo(date1);
        int d2= date2.compareTo(date1);
        System.out.println(d);  // 1  date1 > date2
        System.out.println(d1);  // 0  date1 = date2
        System.out.println(d2);  // -1 date1 < date2

是否相等 equals

        boolean b3 = date1.equals(date2);
        System.out.println(b3);  // false

Calendar类

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

构造方法：

protected Calendar(); 由于修饰符是protected ，所以无法直接创建该对象

其他方法：

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

        // 1. 创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());  // 2024-12-12 15:35:53
        System.out.println(calendar.getTimeInMillis());  // 1733988983773   1970年距今毫秒数

获取时间信息

// 2. 获取时间信息
        // 获取 年
        int year = calendar.get(Calendar.YEAR);  // 也可以直接输 1
        System.out.println(year);  // 2024
        // 获取 月     0-11 相当于 1-12
        int month = calendar.get(Calendar.MONTH);  // 也可以直接输 2
        System.out.println(month);  // 11   相当于12月
        // 获取 日
        int date = calendar.get(Calendar.DAY_OF_MONTH);  // DATE  或   5
        System.out.println(date);  // 12
        // 获取 时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);  // HOUR_OF_DAY 是24小时制，HOUR 是12小时制
        System.out.println(hour);  // 15
        // 获取 分
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println(minute);  // 44
        // 获取 秒
        int secod = calendar.get(Calendar.SECOND);
        System.out.println(secod);  // 35
        System.out.println(year+"年"+(month+1)+"月"+date+"日 "+hour+"时"+minute+"分"+secod+"秒");  // 2024年12月12日 15时51分46秒

修改时间

        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,11);
        System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 15:53:53

add方法修改时间

        calendar2.add(Calendar.HOUR,-1);
        System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 14:55:17

补充方法

        calendar2.add(Calendar.MONTH,1);
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);  // 31
        System.out.println(min);  // 1

完整代码：

package com.object.Calendar;

import java.util.Calendar;

public class Demo01 {

    public static void main(String[] args) {
        // 1. 创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());  // 2024-12-12 15:35:53
        System.out.println(calendar.getTimeInMillis());  // 1733988983773   1970年距今毫秒数
        // 2. 获取时间信息
        // 获取 年
        int year = calendar.get(Calendar.YEAR);  // 也可以直接输 1
        System.out.println(year);  // 2024
        // 获取 月     0-11 相当于 1-12
        int month = calendar.get(Calendar.MONTH);  // 也可以直接输 2
        System.out.println(month);  // 11   相当于12月
        // 获取 日
        int date = calendar.get(Calendar.DAY_OF_MONTH);  // DATE  或   5
        System.out.println(date);  // 12
        // 获取 时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);  // HOUR_OF_DAY 是24小时制，HOUR 是12小时制
        System.out.println(hour);  // 15
        // 获取 分
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println(minute);  // 44
        // 获取 秒
        int secod = calendar.get(Calendar.SECOND);
        System.out.println(secod);  // 35
        System.out.println(year+"年"+(month+1)+"月"+date+"日 "+hour+"时"+minute+"分"+secod+"秒");  // 2024年12月12日 15时51分46秒
        // 3. 修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,11);
        System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 15:53:53
        // 4. add方法修改时间
        calendar2.add(Calendar.HOUR,-1);
        System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 14:55:17
        // 5. 补充方法
        calendar2.add(Calendar.MONTH,1);
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);  // 31
        System.out.println(min);  // 1

    }
}

SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类

进行格式化（日期 -> 文本）、解析(文本 -> 日期)

常用的时间模式字母

字母	日期或时间	示例
y	年	2024
M	月	12
d	日/天	12
H	小时（0-23）	19
m	分钟	13
s	秒	59
S	毫秒	357

package com.object.SimpleDateFormat;

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

public class Demo01 {

    public static void main(String[] args) throws Exception{
        // 1. 创建SimpleDateFormat对象  y 年 M 月
        // SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        // 2. 创建Date
        Date date = new Date();
        // 3. 格式化date(把日期转成字符串)
        String str = sdf.format(date);
        System.out.println(str);  // 2024年12月12日 16:50:18
        // 4. 解析 (把字符串转成日期)
        Date date2 = sdf.parse("2018年12月12日");
        System.out.println(date2);  // Wed Dec 12 00:00:00 CST 2018
    }
}

System类

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

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

代码验证

package com.object.System;

public class Demo01 {
    public static void main(String[] args) {
        // arraycopy    数组的复制
        // src 原数组
        // srcPos 从哪个位置开始复制
        // dest 目标数组
        // destPos 目标数组的位置
        // length 复制的长度
        int[] arr = {22,4,69,52,33,95,10,71,43};
        int[] dest = new int[9];
        System.arraycopy(arr,1,dest,0,5);
        for (int i = 0; i < dest.length; i++) {
            System.out.print(dest[i]+" ");  // 4 69 52 33 95 0 0 0 0
        }

        //  currentTimeMillis 从1970 到现在的毫秒数
        System.out.print("\n");
        System.out.println(System.currentTimeMillis());  // 1733998980366

        long start = System.currentTimeMillis();
        for (int i = 0; i < 99999; i++) {
            for (int j = 0; j < 99999; j++) {
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+ (end-start));  // 用时：0  // 我这里设置的数小，电脑性能高的可以往大设

    }
}

总结

内部类

在一个类的内部再定义一个完整的类
成员内部类、静态内部类、局部内部类、匿名内部类

Object类

所有类的直接或间接父类，可存储任何对象

包装类

基本数据类型所对应的引用数据类型，可以使Object统一所有数据

String类

字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享

BigDecimal类

可以精确计算浮点数

Date

特定时间

Calendar

日历

SimpleDateFormat

格式化时间

System

系统类