【Java中的equal方法_解析与==的区别_如何重写（override）该方法】

== 的使用方法

== 实际上是一个关系运算符

1. == 既可以判断基本类型，又可以判断引用类型。

==两侧是基本数据类型时，判断值是否相等。

==两侧是引用数据类型时，判断地址是否相等

public class Test{
    public static void main(String[] args) {
        //基本数据类型int
        int a = 10;
        //引用类型int[]
        int[] arr1 = new int[10];
        int[] arr2 = arr1;
        int[] arr3 = new int[10];

        //简单比较10==10
        System.out.println(a == 10);//true
        //引用类型，比较地址
        //由于arr2并没有new，仅仅是arr1的简单拷贝（arr1赋给arr2），所以arr2的地址和arr1相同
        //arr3new了，相当于开辟了新的地址，所以与arr1地址不同
        System.out.println(arr1 == arr2);//true
        System.out.println(arr1 == arr3);//false
    }
}

equals方法的使用

简单介绍

equals 是Object类中的方法，只能判断引用类型。

在jdk1.8的文档中的介绍（可忽略不看）

默认判断

jdk的源码

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

可以看出，它也仅仅是运用 == 比较两者是否指向同一个地址，也就是说若该类中没有重写equals，equals就等同于 ==

jdk重写equals

让我们先看看jdk中，对Integer，String，Double 中对equals的重写

Integer

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

Double

    public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

String

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return 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;
            }
        }
        return false;
    }

可以看出Integer和Double都是先判断是否是它们的子类，然后在转换比较（利用== 进行值比较）

String先比较是否是同一地址（利用 == 进行址比较），然后将字符串的每个字符挨个比较（利用 == 进行值比较 ）

重写自定义类中的equals

来看下面的一段代码

class Person {
    String name;
    int age;

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

public class Test{
    public static void main(String[] args) {
        Person person1 = new Person("张三", 18);
        Person person2 = new Person("李四", 20);

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

由于Person是我们自己写的一个类，在我们没有进行重写equals之前，都默认使用Object的equals进行比较，也就是比较地址，所以该值为false。

重写equals，让其使用age比较

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
	//重写
    public boolean equals(Object o) {
        //判断两者是否指向同一对象，是自然相等
        if (this == o)
            return true;
        //判断是否是同一类
        if (o == null || getClass() != o.getClass())
            return false;
        Person person = (Person) o;
        //年龄
        return age == person.age;
        //名字
        //return Objects.equals(name, person.name);
        //年龄和名字
        //return age == person.age && Objects.equals(name, person.name);
    }


}

public class Test{
    public static void main(String[] args) {
        Person person1 = new Person("张三", 20);
        Person person2 = new Person("李四", 20);
		//通过年龄比较
        System.out.println(person1.equals(person2));//true
    }
}

尾言

梦想永在凌云意，意气风发。 代码筑就万世基，积沙镇海。

诸君加油(ง •_•)ง