Java面向对象之equals 方法、hashCode 方法、toString 方法及finalize 方法

最新推荐文章于 2024-04-06 17:47:48 发布

一切随心走_水瓶

最新推荐文章于 2024-04-06 17:47:48 发布

阅读量380

点赞数 2

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/wcg920212/article/details/121567495

版权

java 专栏收录该内容

54 篇文章 2 订阅

订阅专栏

本文详细讲解了Java中的Object类，包括equals方法的比较原理与重写、hashCode的作用与实现、toString方法的定义与定制，以及finalize方法在对象回收过程中的应用。通过实例展示了如何根据对象内容判断相等性和如何优化哈希性能。

摘要由CSDN通过智能技术生成

文章目录

- - 1、Object 类

1、Object 类

1.1、equals 方法

1.1.1、== 和 equals 的对比

== 是一个比较运算符
==：既可以判断基本类型，又可以判断引用类型
==：如果判断基本类型，判断的是值是否相等
==：如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
equals：是Object类中的方法，只能判断引用类型
默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

package Equals01;

public class Equals01 {
    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);  // true
        System.out.println(b == c);  // true

        B bObj = a;
        System.out.println(bObj == c);  // true
        int num1 = 10;
        double num2 = 10.0;
        System.out.println(num1 == num2);  // true, 基本数据类型, 判断值是否相等

        // Jdk 的源码 String 类的 equals
        // 把 Object 的 equals 方法重写了, 变成了比较两个字符串值是否相同
        /*
        public boolean equals (Object anObject){
            if (this == anObject) {  // 如果是同一个对象
                return true;  // 返回 true
            }
            if (anObject instanceof String) {  // 判断类型
                String anotherString = (String) anObject;  // 向下转型
                int n = value.length;
                if (n == anotherString.value.length) {  // 如果长度相同
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {  // 然后一个一个的比较字符
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    }
                    return true;  // 如果两个字符串的所有字符都相等, 则返回 true
                }
            }
            return false;  // 如果比较的不是字符串, 则直接返回 false
        }
        */

        System.out.println("abc".equals("hello"));  // false

        /*
        // 即 Object 的 equals 方法默认就是比较对象地址是否相同
        // 也就是判断两个对象是不是同一个对象
        public boolean equals(Object obj) {
            return (this == obj);
        }
        */

        // 从源码可以看到 Integer 也重写了 Object 的 equals 方法
        // 变成了判断两个值是否相同
        /*
        public boolean equals (Object obj){
            if (obj instanceof Integer) {
                return value == ((Integer) obj).intValue();
            }
            return false;
        }
        */

        Integer integer1 = new Integer(1000);
        Integer integer2 = new Integer(1000);
        System.out.println(integer1 == integer2);  // false
        System.out.println(integer1.equals(integer2));  // true

        String str1 = new String("wcg");
        String str2 = new String("wcg");
        System.out.println(str1 == str2); // false
        System.out.println(str1.equals(str2)); // true
    }
}

class B {
}

class A extends B {
}

1.1.2、如何重写 equals 方法

判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false

package Equals01;

public class EqualsExercise01 {
    public static void main(String[] args) {
        // 应用实例: 判断两个 Person 对象的内容是否相等, 如果两个 Person 对象的各个属性值都一样, 则返回 true, 反之 false
        Person person1 = new Person("张三", 18, '男');
        Person person2 = new Person("张三", 18, '男');
        Person person3 = new Person("李四", 25, '男');

        System.out.println(person1 == person2); // false
        System.out.println(person1.equals(person2));  // true
        System.out.println(person1 == person3);  // false
        System.out.println(person1.equals(person3));  // false
    }
}

class Person {
    private String name;
    private int age;
    private char gender;

    // 重写 Object 的 equals 方法
    public boolean equals(Object obj) {
        // 判断如果比较的两个对象是同一个对象, 则直接返回 true
        if (this == obj) {
            return true;
        }
        // 类型判断
        if (obj instanceof Person) {  // 是 Person, 才比较
            // 进行 向下转型, 因为我需要得到 obj 的 各个属性
            Person p = (Person) obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        // 如果不是 Person, 则直接返回 false
        return false;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

1.2、hashCode 方法

在这里插入图片描述

1.2.1、hashCode 小总结

提高具有哈希结构的容器的效率！
两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
两个引用，如果指向的是不同对象，则哈希值是不一样的
哈希值主要根据地址号来的，不能完全将哈希值等价于地址

1.2.2、代码实现

package HashCode_;

public class HashCode_ {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hashCode()=" + aa.hashCode());  // aa.hashCode()=460141958
        System.out.println("aa2.hashCode()=" + aa2.hashCode());  // aa2.hashCode()=1163157884
        System.out.println("aa3.hashCode()=" + aa3.hashCode());  // aa3.hashCode()=460141958

        System.out.println(aa.equals(aa2));  // false
        System.out.println(aa.equals(aa3));  // true
        System.out.println(aa == aa2);  // false
        System.out.println(aa == aa3);  // true
    }
}

class AA {
}

1.3、toString 方法

1.3.1、定义

默认返回：全类名+@+哈希值的十六进制
子类往往重写 toString 方法，用于返回对象的属性信息
重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式
当直接输出一个对象时，toString 方法会被默认的调用，比如 System.out.println(monster)；就会默认调用
monster.toString() 方法

1.3.2、代码实现

package ToString_;

public class ToString_ {
    public static void main(String[] args) {
        /*
        Object 的 toString() 源码
        (1)getClass().getName() 类的全类名(包名+类名 )
        (2)Integer.toHexString(hashCode()) 将对象的 hashCode 值转成 16 进制字符串
        public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        */
        Monster monster = new Monster("小妖怪", "巡山的", 1000);
        System.out.println(monster.toString() + " hashcode=" + monster.hashCode());

        System.out.println("==当直接输出一个对象时, toString 方法会被默认的调用==");
        System.out.println(monster);  // 等价 monster.toString()

    }
}

class Monster {
    private String name;
    private String job;
    private double sal;

    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }

    // 重写 toString 方法, 输出对象的属性
    // 使用快捷键即可 alt + insert

    @Override
    public String toString() {
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }
}

1.4、finalize 方法

1.4.1、定义

当对象被回收时，系统自动调用该对象的 finalize 方法，子类可以重写该方法，做一些释放资源的操作
什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来
销毁该对象，在销毁该对象前，会先调用 finalize 方法
垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法)，也可以通过 System.gc() 主动触发垃圾回收机制

1.4.2、代码实现

package Finalize_;

public class Finalize_ {
    public static void main(String[] args) {
        Car bmw = new Car("宝马");
        // 这时 car 对象就是一个垃圾, 垃圾回收器就会回收(销毁)对象, 在销毁对象前, 会调用该对象的 finalize 方法
        // 程序员就可以在 finalize 中, 写自己的业务逻辑代码(比如释放资源: 数据库连接, 或者打开文件...)
        // 如果程序员不重写 finalize,那么就会调用 Object 类的 finalize, 即默认处理
        bmw = null;

        System.gc();
        System.out.println("程序退出了");
    }
}

class Car {
    private String name;

    // 属性, 资源
    public Car(String name) {
        this.name = name;
    }

    // 重写 finalize
    @Override
    protected void finalize() throws Throwable {
        System.out.println("正在销毁 汽车" + name);
        System.out.println("释放了某些资源...");
    }
}