Java的equals和hashCode方法浅谈

一、概述

equals和hashCode作为Java基础经常在面试中提到，比如下面几个问题：

equals和==有什么区别？
equals和hashCode有什么关系？
equals和hashCode如何编写？

对于第一个问题不少人只停留在字符串equals比较的是内容，==比较的是内存地址，而对equals的本质极少过问。第二个问题，大多数都知道答案，也有不少记反了，但是更进一步为什么是那样的关系，就不知道了。对于第三个问题，大部分人一上手就把方法签名写错了，就别谈正确的写出实现了。带着这些问题，接下来谈谈自己的一点理解。

二、equals方法

先来看见equals方法的签名，

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

可以看到入参是Object，很多人没有注意到这一点，上来就写错了。equals方法顾名思义就判断对象的相等性，默认实现就是==，那么说到二者的区别，个人理解，equals方法是一种用户定义的“逻辑等”，而==是一种“物理等”，用俗语解释就是，equals判断是否相同，==判断是否一样。

equals方法在编写的时候需要遵循以下原则：

自反性
对称性
传递性
一致性

下面展开说一下，

自反性的意思是，对于一个非null的对象x，x.equals(x)一定为true，这是显而易见的，无须赘述。

对称性，对于非null对象x、y，x.equals(y) == true，当且仅当y.equals(x) == true。来看一个来自《Effective Java》的例子，

// Broken - violates symmetry!
public final class CaseInsensitiveString {
  private final String s;

  public CaseInsensitiveString(String s) {
    this.s = Objects.requireNonNull(s);
  }

  // Broken - violates symmetry!
  @Override public boolean equals(Object o) {
    if (o instanceof CaseInsensitiveString)
      return s.equalsIgnoreCase(
          ((CaseInsensitiveString) o).s);
    if (o instanceof String)  // One-way interoperability!
      return s.equalsIgnoreCase((String) o);
    return false;
  }
  ...  // Remainder omitted
}
CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
String s = "polish";
List<CaseInsensitiveString> list = new ArrayList<>();
list.add(cis);
// true or false
list.contains(s);

在JDK8运行list.contains(s)返回false，但是有的JDK可能会返回true，甚至直接崩溃，所以如果违反了对称性，程序的行为是不可预测的。

传递性，对于非null对象x、y、z，如果x.equals(y) == true且y.equals(z) == true，那么x.equals(z) == true。同样是来自《Effective Java》的一个例子，

public class Point {
  private final int x;
  private final int y;

  public Point(int x, int y) {
    this.x = x;
    this.y = y;
  }

  @Override public boolean equals(Object o) {
    if (!(o instanceof Point))
      return false;
    Point p = (Point)o;
    return p.x == x && p.y == y;
  }

  ...  // Remainder omitted
}

public class ColorPoint extends Point {
  private final Color color;

  public ColorPoint(int x, int y, Color color) {
    super(x, y);
    this.color = color;
  }

  // Broken - violates transitivity!
  @Override public boolean equals(Object o) {
    if (!(o instanceof Point))
      return false;

    // If o is a normal Point, do a color-blind comparison
    if (!(o instanceof ColorPoint))
      return o.equals(this);

    // o is a ColorPoint; do a full comparison
    return super.equals(o) && ((ColorPoint) o).color == color;
  }

  ...  // Remainder omitted
}

ColorPoint p1 = new ColorPoint(1, 2, Color.RED);
Point p2 = new Point(1, 2);
ColorPoint p3 = new ColorPoint(1, 2, Color.BLUE);

显然ColorPoint的equals实现违反了传递性，p1.equals(p2) == p2.equals(p3) != p1.equals(p3)。假如Point有两个子类ColorPoint和SmellPoint，colorPoint.equals(smellPoint)将会导致无限递归，最终导致内存耗尽。引用《Effective Java》的说法，

There is no way to extend an instantiable class and add a value component while preserving the equals contract, unless you’re willing to forgo the benefits of object-oriented abstraction.

这句话的大意是如果你继承扩展一个类，就没法再保持equals的原则了，除非放弃使用继承。放弃继承？这不是让我们因噎废食嘛，咦，别说，还真能放弃继承，那就是组合，因为本文的重点是equals和hashCode就不展开了。

一致性，对于非null对象x、y，多次调用x.equals(y)返回一致。一致性意味着equals方法不要依赖不可靠的变量，这里“可靠”的意思不光意味着“不该变时不变”，还意味着“想获取时能获取到”，比如java.net.URL的equals实现依赖了ip地址，而网络故障时无法获取ip，这是一个不好的实现。

说了那么多，有人可能会说，哎呀这么多原则顾头不顾尾，都要满足，太难了吧，下面列出实现equals的一些tips，照着做实现起来就易如反掌，

使用==判断是否为null或this，如果是前者返回false，后者就返回true。
使用instanceof检测是否是正确的类型，如果不是直接返回false，如果是，强制转换为正确的类型，然后比较与“逻辑等”相关的变量。

三、hashCode方法

hashCode主要用来在Java中哈希数据结构HashMap、HashSet生成哈希值，hashCode的方法签名，

public native int hashCode();

默认实现会将对象的内存地址转化为一个整数，因此只有同一个对象hashCode才一样，即使两个equals返回true的对象hashCode也不一样，如果不进行重写。和equals一样，hashCode也需要满足一些原则：

一致性，和equals相关的变量没有变化，hashCode返回值也不能变化。
两个对象equals返回true，hashCode返回值应该相等。由上面得知，hashCode默认实现不满足这一条件，因此任何类如果实现了equals就必须实现hashCode，确保二者的步调一致，下面来看一个反例，
```
public class Person {
  private int age;
  private String name;

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

  @Override
    public boolean equals(Object obj) {
      if (obj == null) {
        return false;
      }
      if (obj == this) {
        return true;
      }

      if (obj instanceof Person) {
        Person that = (Person) obj;
        return age == that.age && Objects.equals(name, that.name);
      }

      return false;
    }
}

Map<Person, Integer> map = new HashMap<>();
map.put(new Person(10, "小明"), 1);
map.get(new Person(10, "小明"));
```
初学者可能觉得最后一条语句会返回1，事实上返回的是null，为什么会这样呢？明明将数据放进去了，而数据却像被黑洞吞噬一样，要解释得从HashMap的数据结构说起，HashMap是由数组和链表组成的一种组合结构，如下图，往里存放时，hashCode决定数组的下标，而equals用于查找值是否已存在，存在的话替换，否则插入；往外取时，先用hashCode找到对应数组下标，然后用equals挨个比较直到链表的尾部，找到返回相应值，找不到返回null。再回过头看刚才的问题，先放进去一个new Person(10, "小明")，然后取的时候又新建了一个new Person(10, "小明")，由于没有重写hashCode，这两个对象的hashCode是不一样的，存和取的数组下标也就不一样，自然取不出来了。
两个对象equals返回false，hashCode返回值可以相等，但是如果不等的话，可以改进哈希数据结构的性能。这条原则也可以用HashMap的数据结构解释，举一个极端的例子，假如Person所有对象的hashCode都一样，那么HashMap内部数组的下标都一样，数据就会进到同一张链表里，这张链表比正常情况下要长的多，而遍历链表是一项耗时的工作，性能也就下来了。

那么如何写一个好的hashCode呢？

声明一个变量int的变量result，将第一个和equals相关的实例变量的hashCode赋值给它。
然后按照下列规则依次计算剩下的实例变量的hashCode值c。
1. 如果是null，设置一个常数，通常为0
2. 如果是原始类型，使用Type.hashCode(f)，Type为它们的装箱类型
3. 如果是数组，如果每一个元素都是相关的，可以使用Arrays.hashCode；否则将相关元素看作独立的变量计算
使用result = 31 * result + c的形式将每个变量的哈希值组合起来，最后返回result。

参考资料：《Effective Java》