目录

equals（）方法是做什么的？

实战场景

contains底层逻辑判断

内存图

重写equals方法

总结

我们在java程序中调用自带的equals方法时，你是否会有这样的疑问：明明我比较的数据都一样啊，为什么会返回false呢？有些人可能还会疑问，怎么有时候返回true？有时候返回false呢？这是为什么呢？其实是和Java底层人家写的equals方法逻辑有关系

equals（）方法是做什么的？

英语角度：

计算机角度：比较多个值是否相等

实战场景

先来看段代码我们脑海中有个场景吧！

User类

package StringEquals;

public class User {
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }
}

主函数

package StringEquals;
import java.util.ArrayList;
import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        //实例化一个集合对象
        Collection c = new ArrayList();
        
        //实例化一个叫唐三的对象
        User tangsan1 = new User("唐三");
        
        //再次实例化一个叫唐三的对象
        User tangsan2 = new User("唐三");
        
        //把第一个tangsan1对象添加到集合中
        c.add(tangsan1);
        
        //判断集合中是否包含叫唐三的对象
        System.out.println(c.contains(tangsan2)); 
    }
}

客户端输出结果

此时是不是就疑惑了，明明tangsan1和tangsan2这两个变量所指向的对象都叫唐三啊，集合中也有叫唐三的这个对象，那为什么在判断集合是否包含叫唐三的对象时返回false呢？这是为什么？ 我们先来看看Java中底层定义的contains方法是如何进行逻辑判断的，如下图。

contains底层逻辑判断

通过进入到contains方法底层，发现在进行逻辑判断的时候会调用equals方法进行比较。我们通过debug单步调试进入到equals底层之后发现，如下图：

this==obj，这里实际上比较的是tangsan1和tangsan2这两个对象的内存地址，因为实例化时分别new了两个不同的User对象，所有tangsan1和tangsan2这两个变量实际上所存储的地址空间不同、指向的对象也不同。

内存图

我们在来画一张这个程序的内存图，看看每一个变量和对象再内存中是如何划分的，如下图：

看出来有什么不同了吗？虽然在代码中tangsan1和tangsan2这两个变量所指向的对象都叫唐三，但是他们分别所指向的对象不同，这两个对象所指向的地址也不同。

重写equals方法

有些人可能就问了，我只想判断两个对象里面的数据是否相同，如何做？重写equals方法，代码如下：

User类

package StringEquals;

public class User {
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    //重写equals方法，比较连个对象里面的数据是否一致
    public boolean equals(Object o) {
        if (o == null || !(o instanceof User)) return false;
        if (o == this) return true;
        User u = (User) o;
        return u.name.equals(this.name);
    }
}

主函数

package StringEquals;
import java.util.ArrayList;
import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        //实例化一个集合对象
        Collection c = new ArrayList();
        
        //实例化一个叫唐三的对象
        User tangsan1 = new User("唐三");
        
        //再次实例化一个叫唐三的对象
        User tangsan2 = new User("唐三");
        
        //把第一个tangsan1对象添加到集合中
        c.add(tangsan1);
        
        //判断集合中是否包含叫唐三的对象
        System.out.println(c.contains(tangsan2)); 
    }
}

客户端输出结果

这里我们重写了equals方法，之后在调用equals方法的时候，程序就会调用我们自己写的这个重写之后的equals方法，程序就会认为tangsan1也叫唐三，tangsan2也叫唐三，他们名字相同就是同一个人。

总结

• 不重写：调用Objcet的equals方法，判断的是内存地址是否一致
• 重写：调用自定义的equals方法，判断是内容是否一致
• 存放在一个集合中的类型，一定要重写equals方法

一、重写equals方法

【Java比较学习】重写equals方法的安全写法

1、重写equals方法的两种方式

这里提供两个比较常见的equals重写方法：
● 用instanceof实现重写equals方法
● 用getClass实现重写equals方法

先说结论，getClass()比instanceof更安全。接下来就是我们自己要来实现equals方法了。

2、场景描述

假设有此场景：
在已经创建好的长方形类中重写Object类中的equals方法为当长方形的长和宽相等时，返回TRUE，同时重写hashCode方法，重写toString方法为显示长方形的长宽信息。并测试类。

package com.test10_04;

import java.util.Objects;

class Rectangle {
    private double length;
    private double wide;

    public Rectangle() {
        //空实现
    }
    public Rectangle(double length, double wide) {
        setLength(length);
        setWide(wide);
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        assert length > 0.0 : "您的输入有误，长方形的长不能小于0";
        this.length = length;
    }

    public double getWide() {
        return wide;
    }

    public void setWide(double wide) {
        assert wide > 0.0 : "您的输入有误，长方形的宽不能小于0";
        this.wide = wide;
    }

    public double area() {
        return this.length * this.wide;

    }
    public double circumference() {
        return 2 * (this.wide + this.length);
    }

    public boolean equals(Object obj) {
        if (this == obj) { //判断一下如果是同一个对象直接返回true，提高效率
            return true;
        }
        if (obj == null || obj.getClass() != this.getClass()) { //如果传进来的对象为null或者二者为不同类，直接返回false
            return false;
        }
        //也可以以下方法：
//        if (obj == null || !(obj instanceof Rectangle)) { //如果传进来的对象为null或者二者为不同类，直接返回false
//            return false;
//        }
        Rectangle rectangle = (Rectangle) obj; //向下转型
        //比较长宽是否相等，注意：浮点数的比较不能简单地用==，会有精度的误差，用Math.abs或者Double.compare
        return Double.compare(rectangle.length, length) == 0 && Double.compare(rectangle.wide, wide) == 0;
    }

    public int hashCode() { //重写equals的同时也要重写hashCode，因为同一对象的hashCode永远相等
        return Objects.hash(length, wide); //调用Objects类，这是Object类的子类
    }

    public String toString() {
        return "Rectangle{" + "length=" + length + ", wide=" + wide + '}';
    }
}

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

        Rectangle rectangle1 = new Rectangle(3.0, 2.0);
        Rectangle rectangle2 = new Rectangle(3.0, 2.0);
        
        System.out.println(rectangle1.equals(rectangle2));
        System.out.println("rectangle1哈希码:" + rectangle1.hashCode() +
                "\nrectangle2哈希码:" + rectangle2.hashCode());
        System.out.println("toString打印信息：" + rectangle1.toString());
    }
}

3、getClass和instanceof优缺点

具体实现思路在代码中讲的很清楚了，我们这里重点分析一下getClass和instanceof两种实现方法的优缺点：

将代码逻辑简化一下：
我们就重点看这段简单的代码

//getClass()版本
public class Student {
	private String name;
	
    public void setName(String name) {
        this.name = name;
    }
	@Override
	public boolean equals(Object object){
		if (object == this)
			return true;
		// 使用getClass()判断对象是否属于该类
		if (object == null || object.getClass() != getClass())
			return false;
		Student student = (Student)object;
		return name != null && name.equals(student.name);
}

事实上两种方案都是有效的，区别就是getClass()限制了对象只能是同一个类，而instanceof却允许对象是同一个类或其子类，这样equals方法就变成了父类与子类也可进行equals操作了，这时候如果子类重定义了equals方法，那么就可能变成父类对象equlas子类对象为true，但是子类对象equlas父类对象就为false了，如下所示:

class GoodStudent extends Student {

    @Override
    public boolean equals(Object object) {
        return false;
    }

    public static void main(String[] args) {
        GoodStudent son = new GoodStudent();
        Student father = new Student();

        son.setName("test");
        father.setName("test");

		// 当使用instance of时
        System.out.println(son.equals(father)); // 这里为false
        System.out.println(father.equals(son)); // 这里为true

		// 当使用getClass()时
        System.out.println(son.equals(father)); // 这里为false
        System.out.println(father.equals(son)); // 这里为false	
    }
}

注意看这里用的是getClass()

返回值两个都是false，符合我们的预期，（连类都不一样那肯定得为false啊）

而换成instanceof试试看咯：

运行结果：一个为true一个为false，很明显出现问题了。

这里的原因如下：
instanceof的语法是这样的：
当一个对象为一个类的实例时，结果才为true。但它还有一个特点就是，如果当这个对象是其子类的实例时，结果也会为true。这便导致了上述的bug。也就是说当比较的两个对象，他们的类是父子关系时，instanceof可能会出现问题。需要深究的小伙伴可以自己去了解一哈，所以在这里建议在实现重写equals方法时，尽量使用getClass来实现。
在重写equals方法的同时需要重写hashCode方法，具体原因可能后续会讲到~~

4、instanceof和getClass总结

区别就是getClass()限制了对象只能是同一个类，而instanceof却允许对象是同一个类或其子类，

5、instanceof实战

public class GenericTest01 {
    public static void main(String[] args) {
        // 使用JDK5之后的泛型机制
        // 使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据。
        // 用泛型来指定集合中存储的数据类型。
        List<Animal> myList = new ArrayList<Animal>();

        // 指定List集合中只能存储Animal，那么存储String就编译报错了。
        // 这样用了泛型之后，集合中元素的数据类型更加统一了。
        //myList.add("abc");

        Cat c = new Cat();
        Bird b = new Bird();

        myList.add(c);
        myList.add(b);

        // 获取迭代器
        // 这个表示迭代器迭代的是Animal类型。
        Iterator<Animal> it = myList.iterator();
        while(it.hasNext()){
            // 使用泛型之后，每一次迭代返回的数据都是Animal类型。
            //Animal a = it.next();
            // 这里不需要进行强制类型转换了。直接调用。
            //a.move();

            // 调用子类型特有的方法还是需要向下转换的！
            Animal a = it.next();
            if(a instanceof Cat) {
                Cat x = (Cat)a;
                x.catchMouse();
            }
            if(a instanceof Bird) {
                Bird y = (Bird)a;
                y.fly();
            }
        }
    }
}

class Animal {
    // 父类自带方法
    public void move(){
        System.out.println("动物在移动！");
    }
}

class Cat extends Animal {
    // 特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠！");
    }
}

class Bird extends Animal {
    // 特有方法
    public void fly(){
        System.out.println("鸟儿在飞翔！");
    }
}

目录

1、equals方法

2、hashcode方法

3、hash算法

4、重写equals方法

5、重写HashCode方法

在每个类中，重写equals方法的时侯，一定要重写hashcode方法。

Object类中的equals方法，底层是通过==来进行比较，所以比较的是对象的内存地址

1、equals方法

​

2、hashcode方法

Java中的hashCode方法就是根据一定的规则与对象相关信息（例如对象的存储地址，对象的字段等）映射成一个数组，这个数值就被称为散列值 

3、hash算法

就是将hashcode的得到的随机数（散列值），映射成固定长度的值

Java中规定：

（1）如果两个对象通过equals方法比较是相等的，那么它们的hashCode方法结果值也是相等的。

（2）如果两个对象通过equals方法比较是不相等的，那么它们的hashCode方法结果值不一定不相等。

很多情况下，我们比较对象并不需要比较对象的地址，而是只要是同一个类的不同对象，成员属性值相同，我们就认为是同一个对象

 上图所示，没有重写equals方法的情况下，这里的比较返回的是false（因为比较的是堆中的内存地址）。

4、重写equals方法

但是两个对象是同一个类，而且成员变量的值都是相同，所以我们可以认为是同一个对象，为了达到这个效果，就必须重写equals方法，让他们比较的是类的类型和成员变量的值

这里发现equals比较的是对象的成员变量的值了，并不是比较的内存地址，但是两个对象的hashcode还是不相同，这就会导致如下问题

 HashSet有一个特性就是不能允许相同的值的存在，我们car1和car2对于我们来说就是同一个对象（同类型，同值），那么为什么会存在这个问题呢？

我们知道HashSet底层是通过HashMap来实现的，HashMap的key就是我们存入HashSet中的值，而value是一个固定值（并不需要去管），而HashMap的底层是通过数组+链表+红黑树（>=1.8)，hashmap底层在计算数组下标位置就是使用的hashcode去实现的hash算法，所以如果hashcode的值不同，计算出来的数字下标位置就有可能不同，所以就将car1和car2放在了不同的数组的位置，所以并不会进行覆盖（正常情况下如果hashcode相同，得到相同的数组下标位置，还需要进行equals来比较是否是同一个元素），所以这就导致Hashset不能起到去重的作用

所以这里也是我们需要重写HashCode方法的原因

5、重写HashCode方法

 这里可以看到，重写HashCode方法之后，两个实例对象的hashcode的值也就是相同的，HashSet也就能起到了去重的效果

所以Java中规定，一般重写equals方法就要重写HashCode方法，也是为了保证在不同场景下使用不会出错