本文探讨的是老掉牙的基础问题，先建个实体类
package com.demo.tools; public class User { private String name; public User(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
测试：
public static void main(String[] args){ User a = new User("A"); User b = new User("A"); System.out.println(a.equals(b)); }
输出 false。明明存的都是A，为啥equal的结果是false呢？不是说【equal比较的是值，==比较的是地址】吗？因为默认创建的类是继承Object的，看一下Object类里面的两个方法：
/** * 返回对象的哈希码值。 * * {@code hashCode}的一般约定为： * 在Java应用程序执行期间对同一对象多次调用{@code hashcode}方法时，只要在对象{@code equals}的比较中使用的信息没有被修改，则该方法必须一致地返回相同的整数。 * 从应用程序的一次执行到同一应用程序的另一次执行，此整数不必保持一致。 * * 如果调用{@code equals（object）}方法，两个对象相等，那么两个对象调用{@code hashcode}方法必须产生相同的整数结果。 * 根据{@link java.lang.object equals（java.lang.object）}方法，如果两个对象不相等，则这两个对象调用{@code hashcode}方法都必须产生不同的整数结果。 * * @return a hash code value for this object. * @see java.lang.Object#equals(java.lang.Object) * @see java.lang.System#identityHashCode */ public native int hashCode(); /** * {@code equals}方法在非空对象引用上实现等价关系： * * 它是自反的：对于任何非空的引用值{@code x}，{@code x.equals（x）}应该返回{@code true}。 * 它是对称的：对于任何非空的引用值{@code x}和{@code y}，{@code x.equals（y）}应该返回{@code true}；反过来也应该一样{@code y.equals（x）}返回{@code true}。 * 它是可传递的：对于任何非空的引用值{@code x}、{@code y}和{@code z}，如果{@code x.equals（y）}返回{@code true}，{@code y.equals（z）}返回{@code true}，则{@code x.equals（z）}应返回{@code true}。 * 它是一致的：对于任何非空的引用值{@code x}和{@code y}，多次调用{@code x.equals（y）}应该一致的返回{@code true}或{@code false}，前提是在{@code equals}比较的对象信息没有被修改。 * 对于任何非空引用值{@code x}，{@code x.equals（null）}应返回{@code false}。 * * * 对于任何非空的引用值{@code x}和{@code y}，当且仅当{@code x}和{@code y}引用同一对象，此方法返回{@code true}【此时{@code x==y}的值是{@code true}】。 * * 注意，通常需要重写{@code hashcode}方法，以便保持{@code hashcode}方法的一般约定，它声明：相等的对象必须有相等的哈希代码。 * * @param obj the reference object with which to compare. * @return {@code true} if this object is the same as the obj * argument; {@code false} otherwise. * @see #hashCode() * @see java.util.HashMap */ public boolean equals(Object obj) { return (this == obj); }
可以看到： 1. 默认的hashcode方法是个本地方法，也就是对象的内存地址。 2. 而equals方法则是直接使用了==操作符，也是比较内存地址。这样看来，equals和hashcode是一样的。
而根据注释所说： 1. 只要equals返回true，那么hashcode一定相等。 2. 只要equals返回false，那么hashcode一定不相等。3. 重写了equals方法，也要重写hashcode方法，因为相等的对象必须有相同的哈希码。
尝试一：仅仅重写equals
package com.demo.tools; public class User { public static void main(String[] args){ User a = new User("A"); User b = new User("A"); System.out.println(a.equals(b)); System.out.println(a == b); System.out.println(a.hashCode() + "," + b.hashCode()); } private String name; public User(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public boolean equals(Object obj) { User user = (User) obj; return this.name.equals(user.name); } }
输出：
可以看到，值比较成功了，可是hashcode不一样，这里的hashcode仍然是内存地址。这就违反了约定。
尝试二：重写equals和hashcode方法
package com.demo.tools; public class User { public static void main(String[] args){ User a = new User("A"); User b = new User("A"); System.out.println(a.equals(b)); System.out.println(a == b); System.out.println(a.hashCode() + "," + b.hashCode()); } private String name; public User(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public boolean equals(Object obj) { User user = (User) obj; return this.name.equals(user.name); } @Override public int hashCode() { return this.name.hashCode(); } }
输出：
可以看到，值和hashcode一致了，地址不一样很正常，因为这是两个对象。
尝试三：hashcode相同，equals就相等吗？
public static void main(String[] args){ User a = new User("Aa"); User b = new User("BB"); System.out.println(a.equals(b)); System.out.println(a == b); System.out.println(a.hashCode() + "," + b.hashCode()); }
输出：
可以看到，两个不同的字符串，hashcode可能一样。
源码一：Map里的equals方法和hashcode方法
public boolean equals(Object o) { // 地址一样，返回true if (o == this) return true; // 不是Map的子类，返回false if (!(o instanceof Map)) return false; Map<?,?> m = (Map<?,?>) o; // 大小不同，返回false if (m.size() != size()) return false; try { // 遍历Map内容，一一比较 Iterator<Map.Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) { Map.Entry<K,V> e = i.next(); K key = e.getKey(); V value = e.getValue(); // HashMap里允许存储null值 if (value == null) { // 对方不存在此key，返回false if (!(m.get(key)==null && m.containsKey(key))) return false; } else { // 都有此key，但是值不一样，返回false if (!value.equals(m.get(key))) return false; } } } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } return true; }
这里能回答一个问题：Map中的对象是自定义的，要不要重写对象的equals方法？
看源码我们能知道，默认Map里的equals方法，在内部仅仅调用了value的equals方法，默认比较的是内存地址。在调用Map的equals方法时：
1. 默认一一比较对象的地址，也就是说，两个Map中每一组比较的对象，都引用同一个地址，那才算两个Map相等。
2. 如果我们业务规定了相等的判定，那么默认的则不符合实际需求，所以要重写value的equals方法，不然调用Map的equals方法可能不符合预期，既然重写了equals，那么也要重写hashcode了。
public int hashCode() { int h = 0; Iterator<Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) h += i.next().hashCode(); return h; }
不难看出，Map的hashcode方法是把内部元素的hashcode加在一起并返回。
源码二：List的equals方法和hashcode方法
public boolean equals(Object o) { // 本身比较，返回true if (o == this) return true; // 非List的子类，返回false if (!(o instanceof List)) return false; ListIterator<E> e1 = listIterator(); ListIterator<?> e2 = ((List<?>) o).listIterator(); // 当两个迭代器的hasNext都为true的时候,进行比较 while (e1.hasNext() && e2.hasNext()) { E o1 = e1.next(); Object o2 = e2.next(); // 这里很巧妙，利用三目运算符完成值的比较 if (!(o1==null ? o2==null : o1.equals(o2))) return false; } // 当任意一方hasNext为true，返回false；当双方都为false，返回true return !(e1.hasNext() || e2.hasNext()); }
基本逻辑和Map的一样，都是遍历元素进行比较。hashcode也是一样。
public int hashCode() { int hashCode = 1; for (E e : this) hashCode = 31*hashCode + (e==null ? 0 : e.hashCode()); return hashCode; }
源码三：String的equals方法和hashcode方法
public boolean equals(Object anObject) { // 地址一样，返回true if (this == anObject) { return true; } // 类型必须是String if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length; // 比较两个String的长度 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; }
hashcode
private final char value[]; private int hash; // Default to 0 public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char val[] = value; // 这里并不是把元素的hashcode加在一起，而是把元素的ASCII码加在一起 for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; } return h; }
总结
不管平时有没有重写过equals和hashcode方法，看了Map和Set的源码就可以知道重写的必要性。因为Set也是基于Map实现的（是一个key不一样，value全一样的Map），所以只用Map举证即可。
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }
首先值的位置是根据hashcode决定的，然后判断值相等的条件是equals为true，hashcode相等。其它都为不相等，有一种情况就是equals为true，hashcode不相等，如果插入Set集合，就不能达到去重的效果：
package com.demo.tools; import java.util.HashSet; import java.util.Objects; import java.util.Set; public class Main { public static void main(String[] args) throws Exception { Set<Foo> set = new HashSet<>(); Foo a = new Foo("A", 12); Foo b = new Foo("A", 13); set.add(a); set.add(b); set.forEach(e -> System.out.println(e.name)); System.out.println(a.equals(b)); System.out.println(a.hashCode() + "," + b.hashCode()); } static class Foo { private String name; private Integer age; public Foo(String name, Integer age) { this.name = name; this.age = age; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Foo foo = (Foo) o; // 这里我们认为name一样，则相等 return Objects.equals(name, foo.name); } } }
equals为true，但是hashcode不一样：
所以，如果重写了equals，一定要重写hashcode，以避免不必要的问题。
小技巧：IDEA里可以自动生成两个方法
快捷键：Alt+Insert
标准equals和hashcode，值得借鉴
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Foo foo = (Foo) o; return Objects.equals(name, foo.name) && Objects.equals(age, foo.age); } @Override public int hashCode() { return Objects.hash(name, age); }