Java的几大常用类

一、Object类

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

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

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

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

1. 作为参数，可以接受任何对象
2. 作为返回值，可以返回任何对象

1.getClass() 方法

public final Class<?> getClass(){
}
1
2

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

例如：判断两数据类型是否相同↓↓↓

Student类:

package com.scaaner;
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;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

方法类Demo1：

package com.scaaner;
public class Demo1 {
    public static void main(String[] args) {
        Student s1 = new Student("A",22);
        Student s2 = new Student("B",12);
        //判断s1和s2是否为同一类型
        Class<? extends Student> class1 = s1.getClass();
        Class<? extends Student> class2 = s2.getClass();
        if(class1 == class2){
            System.out.println("s1和s2是同一类型");
        }else{
            System.out.println("s1和s2不是同一类型");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出结果：

2.hashCode()方法

public int hashCode() {
}
1
2

返回该对象的哈希码值。

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

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

同用Student类

3.toString()方法

public String toString(){
}
1
2

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

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

同用Student类

（1）直接调用：

（2） 重写

4.equals()方法

public boolean equals(Object obj){
	return (this == obj);
} 
1
2
3

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

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

（1）姓名和年龄不同，输出为false

（2）姓名和年龄相同，为什么输出还为false？

因为在栈中所占地址不同，即使数据相同，也还是会显示false。

那要怎样才能为true呢？

对equals方法进行重写，比较两个对象的内容是否相同。

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

（3）姓名和年龄相同，输出为true

在Student类中对equals方法进行重写，比较两个对象的内容是否相同。

5.finalize(）方法

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

垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收：有GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc()；通知JVM执行垃圾回收。

在Student类中重写finalize方法：

在测试类中写：

二、包装类

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

基本数据类型对应的包装类：

1.基本类型和包装类型的转换、装箱与拆箱

栈中存放基本数据类型
堆中存放引用数据类型

装箱：栈中的数据放到堆中（基本类型–>引用类型）
拆箱：堆中的对象拿到栈中（引用类型–>基本类型）

具体请看示例↓↓↓

package com.scaaner;
public class Demo1 {
    public static void main(String[] args) {
        //JDK1.5之前
        //类型转换：装箱   基本类型转引用类型过程
        //基本类型
        int num1 = 10;
        //使用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之后   自动装箱  拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱"+"\n"+integer4);
        //自动拆箱
        int age1 = integer4;
        System.out.println("自动拆箱"+"\n"+age1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2.基本类型和字符串的转换

（1）基本类型转字符串

详看注释↓↓↓

（2）字符串转基本类型

详看注释↓↓↓

（3）boolean字符串形式转成基本类型

" true " ----> true
非" true " ----> false

详看注释↓↓↓

注意：

需保证类型兼容，否则抛出NumberFormatException异常。

附加：Integer缓冲区

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

代码↓↓↓

import com.sun.org.apache.xpath.internal.operations.Bool;

public class Demo1 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);   //false
        //为基本类型，所以放进一个数，就存进去占堆中一个空间


        Integer integer3 = 100;  //自动装箱为引用类型
        //即使用Integer integer3 = Integer.valueOf（100）;的方法
        Integer integer4 = 100;
        System.out.println("------------");
        System.out.println(integer3==integer4);//true
        //指的是在堆中的一个（-128~127）之间的空间，100都只指向的是同一个位置


        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println("------------");
        System.out.println(integer5==integer6);  //false
        //在堆中的一个（-128~127）之间的空间，超出这个范围就在堆里开辟个新空间
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

三、String类

1.不变字符串

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

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

方法一：

产生一个对象，字符串池中存储。

String s = “Hello”;

public class Demo1 {
    public static void main(String[] args) {
        String name = "hello";    //"hello"常量存储在字符串池中
        name = "zhangsan";        //并没有修改数据，而是重新开辟了一个空间，将name指向zhangsan
        String name2 = "zhangsan";  //在字符串池中寻找对象  匹配；如果没有则重新开辟新的空间
    }
}

1
2
3
4
5
6
7
8
9

方法二：（浪费空间）

产生两个对象，堆、池各存储一个。

String s = new String("Hello");
1

String的常用方法详见：String的几种常见方法

2.可变长字符串

效率比String高，比String节省内存

（1）StringBuffer

JDK1.0提供，用于多线程，运行效率慢、线程安全。

（2）StringBuilder

JDK5.0提供，用于单线程，运行效率快，线程不安全。

StringBuffer 和 StringBuilder 用法相同。

为什么StringBuffer和StringBuilder比String的效率高？
代码验证↓↓↓

四、BigDecimal类

先看图↓↓↓

double 是属于近似值存储，所以得出结果也是近似值，但误差很小。

就要使用 BigDecimal 来精确计算。

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

加减乘除
add 加
subtract 减
multiply 乘
divide 除

除法比较特殊不能直接用：

divide(BigDecimal bd , int scal , RoundingMode mode)
1

1. 参数scal：指定精确到小数点后几位。
2. 参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式。取值为BigDecimal.ROUND_HALF_UP。

public class Demo1 {
    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);
        System.out.println("-----------------");
        BigDecimal bd1 = new BigDecimal("1.0");  //后边为字符串类型
        BigDecimal bd2 = new BigDecimal("0.9");
        System.out.println(bd1.subtract(bd2));   //不能直接用运算法则   减法
        System.out.println(bd1.add(bd2));    //加法
        System.out.println(bd1.multiply(bd2));  // 乘法
        BigDecimal bd3 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));  //除法
        System.out.println(bd3);
        System.out.println("----------------");
        //BigDecimal bd4 = new BigDecimal("10").divide(new BigDecimal("3")); //除不尽  会报错
        BigDecimal bd4 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//表示四舍五入保留2位小数
        System.out.println(bd4);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

五、Date类

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

时间单位：
1s = 1000 ms
1ms = 1000 μs
1μs = 1000 ns

import java.util.Date;

public class Demo1 {
    public static void main(String[] args) {
        //1.创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        //2.方法   after   before
        boolean b1 = date1.after(date2);
        System.out.println(b1);     //true
        boolean b2 = date1.before(date2);
        System.out.println(b2);      //false
        //比较 相差多少  compareTo();
        System.out.println(date1.compareTo(date2));
        System.out.println(date2.compareTo(date1));
        System.out.println(date1.compareTo(date1));
        //equals
        System.out.println(date1.equals(date2));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出结果↓↓↓：

六、Calendar类

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

构造方法：
protected Calendar() ：由于修饰符是protected ， 所以无法直接创建该对象。

其他方法：

import java.util.Calendar;

public class Demo1 {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();//受保护，不能new
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());  //毫秒
        //2.获取时间信息
        int year = calendar.get(Calendar.YEAR);   //年
        int mouth = calendar.get(Calendar.MONTH); //月
        int day = calendar.get(Calendar.DAY_OF_MONTH);   //日
        int hour = calendar.get(Calendar.HOUR_OF_DAY);   //HOUR 12小时（hour_of_day 24小时）
        int minute = calendar.get(Calendar.MINUTE);   //分钟
        int second = calendar.get(Calendar.SECOND);  //秒
        System.out.println(year + "年" + (mouth+1) + "月"+ day + "日" + hour + ":" + minute + ":" + second);
        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar2.getTime().toLocaleString());
        //4. add方法修改时间
        calendar2.add(Calendar.HOUR,1);  //加1小时
        System.out.println(calendar2.getTime().toLocaleString());
        calendar2.add(Calendar.HOUR,-2);  //减2小时
        System.out.println(calendar2.getTime().toLocaleString());
        //5.获取当前时间的最大/最小值
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

输出结果↓↓↓

七、SimpleDateFormat类

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

进行格式化 （日期 一> 文本）、解析（文本一>日期）。

常用的时间模式字母：

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

public class Demo1 {
    public static void main(String[] args) throws ParseException {
        //1.创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //2.创建Date
        Date date = new Date();
        //格式化date（把日期转为时间字符串）
        String str = sdf.format(date);  //format格式化
        System.out.println(str);
        //解析（把时间字符串转为日期）
        Date date1 = sdf.parse("2022/04/23");
        System.out.println(date1);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

八、System类

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

public class Demo1 {
    public static void main(String[] args){
        //1.arraycopy,数组的复制
        int[] arr = {20,23,17,9,34};
        int[] dest = new int[5];
        System.arraycopy(arr,1,dest,0,4);
        //System.arraycopy(源数组，从哪个位置开始复制，目标数组，目标数组的位置，复制的长度);

        for (int i = 0; i < arr.length; i++) {
            System.out.println(dest[i]);
        }
        //2.currentTimeMillis    获取当前系统时间
        long start = System.currentTimeMillis();
        for (int i = 0; i < 999999999; i++) {
            for (int i1 = 99999; i1 > 0; i1--) {
                int result = i+i1;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+ (end-start)+"ms");

        new Student("A",12);
        new Student("B",2);
        //3.垃圾回收系统   System.gc
        System.gc();
        //4.退出JVM
        System.exit(0);   //已经退出，后续程序不会再执行
        System.out.println("程序结束！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

输出结果↓↓↓

内容比较多！
重在理解！！
感谢ლ(°◕‵ƹ′◕ლ)！！！