equlas和==的区别、集合中关于重写equals()方法和hashcode()方法的总结

在总结之前我们先来了解一下equals和==的区别：

 

== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

1、比较的是操作符两端的操作数是否是同一个对象。
2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：
int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。

equals：

　　equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

　　String s="abce"是一种非常特殊的形式,和new 有本质的区别。它是java中唯一不需要new 就可以产生对象的途径。以String s="abce";形式赋值在java中叫直接量,它是在常量池中而不是象new一样放在压缩堆中。这种形式的字符串，在JVM内部发生字符串拘留，即当声明这样的一个字符串后，JVM会在常量池中先查找有有没有一个值为"abcd"的对象,如果有,就会把它赋给当前引用.即原来那个引用和现在这个引用指点向了同一对象,如果没有,则在常量池中新创建一个"abcd",下一次如果有String s1 = "abcd";又会将s1指向"abcd"这个对象,即以这形式声明的字符串,只要值相等,任何多个引用都指向同一对象.
　　而String s = new String("abcd");和其它任何对象一样.每调用一次就产生一个对象，只要它们调用。

　　也可以这么理解: String str = "hello"; 先在内存中找是不是有"hello"这个对象,如果有，就让str指向那个"hello".如果内存里没有"hello"，就创建一个新的对象保存"hello". String str=new String ("hello") 就是不管内存里是不是已经有"hello"这个对象，都新建一个对象保存"hello"。

equals和==的区别

equals方法最初是在所有类的基类Object中进行定义的，源码是

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

String类对equals的重写如下：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
    }

以上内容参考自博客：https://www.cnblogs.com/zjc950516/p/7877511.html

了解了equals和==的区别之后，我们再来讨论一下关于重写equals()和hashcode()。请先观察一下代码：

package com.it666.exercise5;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

class Person{
    private String name;
    private Integer age;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

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

public class Demo1 {
    public static void main(String[] args) {
        Person p1 = new Person("mazhao",20);
        Person p2 = new Person("mazhao",20);
        System.out.println("p1的值是：" + p1);
        System.out.println("p2的值是：" + p2);
        Boolean flag1 = (p1.equals(p2));
        Boolean flag2 = (p1 == p2);
        System.out.println(flag1);
        System.out.println(flag2);

 
    }
}

运行结果

p1的值是：Person{name='mazhao', age=20}
p2的值是：Person{name='mazhao', age=20}
true
false

在我们学习了equals和==的区别之后就可以清楚的发现，两种不同的运算可以得到不同的结果，因为equals方法比较的是内容，在Person类中我们又重写了hashcode()和equals()，所以p1和p2的equals运算得到的是true；但是==比较的是地址，因此会得到false。但是问题来了，为什么重写了equals()和hashcode()就可以进行比较内容呢？我们可以观察一下IDEA自动生成的hashcode()方法和equals()方法（我这里用的编译器用的是IDEA默认的hashcode()和equals()生成方式，不同的编译器生成的方式可能不一样）：

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

事实上，equals()方法和hashcode()方法是有执行顺序的，我们会首先执行hashcode()方法，如果两个对象的hashcode()方法的返回值一致，那么再进行equals()方法进行比较，也许你会问，既然hashcode()可以进行比较为什么还用使用到equals()方法呢？因为我们两个对象进行内容比较的时候，是在equals()里面进行比较的，比如如上代码中Person类的name和age是否一致，如果一致，那么说明这两个对象的内容完全一致，equals比较则返回true。而且equals()方法里面的比较是比较复杂的，如果两个对象的hashcode不一样也用equals()方法进行，就会使得程序的效率很低，很明显这不是我们想得到的。

关于集合中重写hashcode()和equals()方法

我们都知道Set集合是不允许出现重复元素的，那么它是怎么比较两个对象的呢？没错就是我们上面说的重写equals()和hashcode()方法。当我们不重写的时候，观察一下代码和运行结果：

package com.it666.exercise5;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

class Person{
    private String name;
    private Integer age;

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



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

public class Demo1 {
    public static void main(String[] args) {
        Person p1 = new Person("mazhao",20);
        Person p2 = new Person("mazhao",20);
        System.out.println("p1的值是：" + p1);
        System.out.println("p2的值是：" + p2);
        Boolean flag1 = (p1.equals(p2));
        Boolean flag2 = (p1 == p2);
        System.out.println(flag1);
        System.out.println(flag2);

        Set<Person> set = new HashSet<Person>();
        set.add(p1);
        set.add(p2);
        System.out.println(set);
    }
}

运行结果:

p1的值是：Person{name='mazhao', age=20}
p2的值是：Person{name='mazhao', age=20}
false
false
[Person{name='mazhao', age=20}, Person{name='mazhao', age=20}]

我们可以发现set集合将p1和p2对象都添加到了集合里面。

那么在我们重写hashcode()和equals()之后：

package com.it666.exercise5;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

class Person{
    private String name;
    private Integer age;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

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

public class Demo1 {
    public static void main(String[] args) {
        Person p1 = new Person("mazhao",20);
        Person p2 = new Person("mazhao",20);
        System.out.println("p1的值是：" + p1);
        System.out.println("p2的值是：" + p2);
        Boolean flag1 = (p1.equals(p2));
        Boolean flag2 = (p1 == p2);
        System.out.println(flag1);
        System.out.println(flag2);

        Set<Person> set = new HashSet<Person>();
        set.add(p1);
        set.add(p2);
        System.out.println(set);
    }
}

运行结果：

p1的值是：Person{name='mazhao', age=20}
p2的值是：Person{name='mazhao', age=20}
true
false
[Person{name='mazhao', age=20}]

可以发现，在我们重写了equals()方法和hashcode()方法之后，set集合将两个对象视为相同，只添加了一个对象到集合里面，证实了前面的说法：set集合是根据对象的equals()方法和hashcode()方法来进行判断两个对象是否一样的！