hashCode()和equal()方法

可以看到Obejct类中的源码如下，可以看到equals()方法的默认实现是判断两个对象的内存地址是否相同来决定返回结果。

1
2
3
4
  public native int hashCode();
public boolean equals(Object obj) {
      return (this == obj);
  }

网上很多博客说hashCode的默认实现是返回内存地址，其实不对，以OpenJDK为例，hashCode的默认计算方法有5种，有返回随机数的，有返回内存地址，具体采用哪一种计算方法取决于运行时库和JVM的具体实现。(可以理解Object类hashCode默认实现是对所有对象返回的值都不一样。)

感兴趣的朋友可以看看这篇博客

Java的Object.hashCode()的返回值到底是不是对象内存地址？

hashCode()方法的作用有哪些？

  • 对对象做散列

    为了将一组键值对均匀得存储在一个数组中，HashMap对key的hashCode进行计算得到一个hash值，用hash对数组长度取模，得到数组下标，将键值对存储在数组下标对应的链表下。

  • 快速判断对象是否不相等

    因为两个对象hashCode相等，调用equal()方法的结果不一定为true，

    因为两个对象调用equal()方法相等，hashCode一定相等。

    所以hashCode不相等可以作为两个对象不相等的快速判断条件。

    在往HashMap中添加一个键值对时，计算得到数组下标后，会遍历数组下标下存储的链表中，拿key的hashCode与每个节点的hashCode进行比较，相等时，才调用equal()方法进行继续调用，节约时间。（在一些类的equal()方法的自定义实现中也会对hashCode进行判断）。

假如只重写hashCode()方法（结果：HashMap可以存在两个内存地址不相同，但是相等的对象，无法保证去重）

此时equal()方法的实现是默认实现，也就是当两个对象的内存地址相等时，equal()方法才返回true，假设两个键值对，它们的key类型都是TestObject，的值都是test，但是由于是使用new String()创建而成的字符串对象，key1和key2的内存地址不相等，所以key1==key2的结果会是false，TestObject的equals()方法默认实现是判断两个对象的内存地址，所以 key1.equals(key2)也会是false， 所以两个键值对可以重复地添加到hashMap中去。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class TestObject {
    Integer a;
    public TestObject(Integer a) {
        this.a = a;
    }
    @Override
    public int hashCode() {
        return a;
    }

    public static void main(String[] args) {
        TestObject key1 = new TestObject(1);
        TestObject key2 = new TestObject(1);
        System.out.println("key1的hashCode为"+ key1 +"key2的hashCode为" + key2);
        System.out.println("key1.equals(key2)的结果为"+(key1.equals(key2)));

        HashMap<TestObject,String> map = new HashMap<TestObject,String>();
        map.put(key1,"value1");
        map.put(key2,"value2");
        System.out.println("HashMap是"+map.toString());
		}
}

输出结果：

1
2
3
4
5
6
7
8
key1的hashCode为com.test.TestObject@1
key2的hashCode为com.test.TestObject@1

key1.equals(key2)的结果为false
  
HashMap是
{com.test.TestObject@1=value1, 
com.test.TestObject@1=value2}

假如只重写equals()方法（结果：相同的对象hashCode不同，从而映射到不同下标下，HashMap无法保证去重）

假设只equals()方法，hashCode方法会是默认实现，具体的计算方法取决于JVM，可能会导致两个相等的对象，它们的hashCode却不相同，从而计算得到的数组下标不相同，存储到hashMap中不同数组下标下的链表中，也会导致HashMap中存在重复元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class TestObject {
    Integer a;
    public TestObject(Integer a) {
        this.a = a;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        TestObject that = (TestObject) o;
        return Objects.equals(a, that.a);
    }

    public static void main(String[] args) {
        TestObject key1 = new TestObject(1);
        TestObject key2 = new TestObject(1);
        System.out.println("key1的hashCode为"+ key1 +"key2的hashCode为" + key2);
        System.out.println("key1.equals(key2)的结果为"+(key1.equals(key2)));

        HashMap<TestObject,String> map = new HashMap<TestObject,String>();
        map.put(key1,"value1");
        map.put(key2,"value2");
        System.out.println("HashMap是"+map.toString());
		}
}

输出结果如下：

1
2
3
4
5
6
7
key1的hashCode为1288141870 
key2的hashCode为2054881392

key1.equals(key2)的结果为true

HashMap是
{com.test.TestObject@4cc77c2e=value1, com.test.TestObject@7a7b0070=value2}