本文为原创文章，如需转载请注明出处，谢谢!
概述
本文将围绕以下五点进行说明
1.equals() 和 == 的作用以及应用
2.hashCode() 的作用及应用
3.hashCode() 和 equals() 的联系
4.HashSet 和 HashMap 的特性
5.Hash 冲突是什么以及如何解决
一、equals() 和 == 的区别
废话不多说，先举个栗子！
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1.equals(str2));
System.out.println(str1 == str2);
许多 Java 基础笔试题中都会出现类似的题目，其实就是在考察是否理解 equals() 和 == 的本质区别。我们先把结论说一下：
1. equals() 方法比较的是两个对象是否相等。
2. == 分为两种情况
- 比较对象，比较的是对象在内存中的空间地址是否相等
- 比较基本类型，比较的是值是否相等
解释完原理后，相信上面的题解答就易如反掌了，str1,str2 均为 String 对象。equals() 比较对象，== 比较内存地址，那么问题来了，String 的 equals()方法是怎么比较对象是否相等的呢？那我们就来看看源码吧
public boolean equals(Object anObject) {
if (this == anObject) { //对象的空间地址相同，说白了就是一个对象！
return true;
}
if (anObject instanceof String) { //地址不同，而且对象是 String
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
//这里首先看两个 String 长度是否相同，如果不同就不等
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) { //然后逐一比对字符
if (v1[i] != v2[i])
return false;
i++;
}// 所有字符都相等，OK ,String对象就相等了
return true;
}
}
return false;
}
经过源码（真理）的一番解释，我们明白了 String 的 equals()的比较逻辑，所以第一个打印为 true。第二个打印比较的是 str1 和 str2 两个引用指向 new 的对象的地址，明显不同，所以为 false。
补充：上面我们分析了 String 的 equals() 方法，那么平时我们使用自定义对象时，equals 又有什么作用呢？我们都知道 Java 中所有的类都继承自 Object，所以我们需要看一下 Object 的 equals() 做了什么。
public boolean equals(Object obj) {
return (this == obj);
}
可以看到 equals() 实际上就是用 == 来比较两个对象是否相等。所以我们可以得出如下结论：
- 如果不重写 equals() ，则 equals() 和 == 效果相同，比较的都是对象内存地址是否相同
- 重写 equals() ，则根据 equals 内的逻辑判断两个对象是否相同
二、equals() 和 hashCode() 的关系
可能一说到 hashCode() 方法，就能开始背课文了：
1、如果两个对象相等（equals() 返回 true），那么它们的 hashCode()一定要相同；
2、如果两个对象hashCode()相等，它们并不一定相等（equals() 不一定返回 true）。
这课文的结论肯定没错，但他们的应用场景究竟是什么呢？我们什么时候会同时用到 equals()和 hashCode() 呢？
在回答这两个问题前，我们先要认清 hashCode()方法的作用是什么，来看下面的解释。
hashCode()，返回对象的哈希码，作用是根据哈希码确定对象在散列表中的位置（单独创建对象或创建数组类型对象时 hashCode() 无作用)。
上面的解释已经很清晰了，那么问题来了，散列表又是啥？再来看看散列表的解释。
散列表本质是数组存储，通过 key-value 的形式存储数据，所以当取 value 的时候，实际上取数组某个位置的元素，并且以 key 的 hashCode 作为 value 在数组中的位置。
我们平时用的 HashSet、HashMap 都是散列表结构，接着我们就以这两个集合为例，详细分析一下 hashCode 在其中的作用。
我们先在此小节简单的说一下 HashSet。面试题常会问，List 和 Set 的区别是什么，又可以背课文了：
1.List 是按 add 顺序存储，且元素可以重复，元素有索引，可以根据元素位置进行 get。
2.Set 存储元素无序，元素不可重复，没有 get 方法，只能通过迭代器获取元素。
我们来逐一解释一下 Set 的特性：
-
元素无序：上文已经说散列表其实是数组结构，元素的位置是hashCode 决定的，所以元素的顺序我们无法确定。
-
元素不可重复：这个特性其实由 HashMap 决定，what？你没看错，就是 HashMap，我们看一下 HashSet 的 add 方法就明白了。
private transient HashMap<E,Object> map; // Dummy value to associate with an Object in the backing Map private static final Object PRESENT = new Object(); public boolean add(E e) { return map.put(e, PRESENT)==null; }我们看到其实 Set 中的元素就是 HashMap 中的 KeySet 中的元素，而每个 Key 对应的 Value 都是一个新的 Object 对象，我们又知道 HashMap 中不允许 key 值重复，所以 Set 中的元素也不会重复，至于原理我们在后面一节单讲 HashMap 的时候再说。
-
没有 get：元素位置本身是由元素的 hashCode 决定，而我们无法事先获取 hashCode 然后再去获取元素，这是一个不可逆的过程。
说了这么多好像有些偏离本节题目了！不好意思，哈哈，马上回到正轨！那么本节开始时背的课文到底说的是什么情况呢，看看我发现的几个好栗子吧！
以下内容均出自 http://www.cnblogs.com/skywang12345/p/3324958.html
1 import java.util.*;
2 import java.lang.Comparable;
3
4 /**
5 * @desc 比较equals() 返回true 以及 返回false时， hashCode()的值。
6 *
7 * @author skywang
8 * @emai kuiwu-wang@163.com
9 */
10 public class ConflictHashCodeTest1{
11
12 public static void main(String[] args) {
13 // 新建Person对象，
14 Person p1 = new Person("eee", 100);
15 Person p2 = new Person("eee", 100);
16 Person p3 = new Person("aaa", 200);
17
18 // 新建HashSet对象
19 HashSet set = new HashSet();
20 set.add(p1);
21 set.add(p2);
22 set.add(p3);
23
24 // 比较p1 和 p2， 并打印它们的hashCode()
25 System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
26 // 打印set
27 System.out.printf("set:%s\n", set);
28 }
29
30 /**
31 * @desc Person类。
32 */
33 private static class Person {
34 int age;
35 String name;
36
37 public Person(String name, int age) {
38 this.name = name;
39 this.age = age;
40 }
41
42 public String toString() {
43 return "("+name + ", " +age+")";
44 }
45
46 /**
47 * @desc 覆盖equals方法
48 */
49 @Override
50 public boolean equals(Object obj){
51 if(obj == null){
52 return false;
53 }
54
55 //如果是同一个对象返回true，反之返回false
56 if(this == obj){
57 return true;
58 }
59
60 //判断是否类型相同
61 if(this.getClass() != obj.getClass()){
62 return false;
63 }
64
65 Person person = (Person)obj;
66 return name.equals(person.name) && age==person.age;
67 }
68 }
69 }
运行结果
p1.equals(p2) : true; p1(1169863946) p2(1690552137)
set:[(eee, 100), (eee, 100), (aaa, 200)]
我们重写了Person的equals()。但是，很奇怪的发现：HashSet中仍然有重复元素：p1 和 p2。为什么会出现这种情况呢？这是因为虽然p1 和 p2的内容相等，但是它们的hashCode()不等；所以，HashSet在添加p1和p2的时候，认为它们不相等。
接下来我们同时重写 equals 和 hashCode。
1 import java.util.*;
2 import java.lang.Comparable;
3
4 /**
5 * @desc 比较equals() 返回true 以及 返回false时， hashCode()的值。
6 *
7 * @author skywang
8 * @emai kuiwu-wang@163.com
9 */
10 public class ConflictHashCodeTest2{
11
12 public static void main(String[] args) {
13 // 新建Person对象，
14 Person p1 = new Person("eee", 100);
15 Person p2 = new Person("eee", 100);
16 Person p3 = new Person("aaa", 200);
17 Person p4 = new Person("EEE", 100);
18
19 // 新建HashSet对象
20 HashSet set = new HashSet();
21 set.add(p1);
22 set.add(p2);
23 set.add(p3);
24
25 // 比较p1 和 p2， 并打印它们的hashCode()
26 System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
27 // 比较p1 和 p4， 并打印它们的hashCode()
28 System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());
29 // 打印set
30 System.out.printf("set:%s\n", set);
31 }
32
33 /**
34 * @desc Person类。
35 */
36 private static class Person {
37 int age;
38 String name;
39
40 public Person(String name, int age) {
41 this.name = name;
42 this.age = age;
43 }
44
45 public String toString() {
46 return name + " - " +age;
47 }
48
49 /**
50 * @desc重写hashCode
51 */
52 @Override
53 public int hashCode(){
54 int nameHash = name.toUpperCase().hashCode();
55 return nameHash ^ age;
56 }
57
58 /**
59 * @desc 覆盖equals方法
60 */
61 @Override
62 public boolean equals(Object obj){
63 if(obj == null){
64 return false;
65 }
66
67 //如果是同一个对象返回true，反之返回false
68 if(this == obj){
69 return true;
70 }
71
72 //判断是否类型相同
73 if(this.getClass() != obj.getClass()){
74 return false;
75 }
76
77 Person person = (Person)obj;
78 return name.equals(person.name) && age==person.age;
79 }
80 }
81 }
运行结果
p1.equals(p2) : true; p1(68545) p2(68545)
p1.equals(p4) : false; p1(68545) p4(68545)
set:[aaa - 200, eee - 100]
这下，equals() 生效了，HashSet中没有重复元素。比较p1和p2，我们发现：它们的 hashCode() 相等，通过equals()比较它们也返回true。所以，p1和p2被视为相等。比较p1和p4，我们发现：虽然它们的hashCode()相等；但是，通过 equals() 比较它们返回false。所以，p1和p4被视为不相等。
小结
- 在单独使用对象的时候，hashCode() 对于对象判等没有作用。
- 在散列表中使用对象，一定要同时重写 hashCode() 和 equals()，并且要保证 hashCode() 的算法能尽量保证对象的唯一。
- HashSet 会先去判断对象的 hashCode 相不相等，如果不相等对象一定不等，如果相等再去通过 equals() 判断对象是否相等。
- 本节开始背的课文其实就是针对使用散列表存储对象的时候，我们应该如何设计对象的 equals() 和 hashCode()。
三、HashMap 简析源码
上一节分析 HashSet 时，我们看到 HashSet 内部其实维护了一个 HashMap 对象，add() 实际上是调用 map.put(e, PRESENT)，所以我们直接看一下 put(key, value) 都做了些什么。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
//通过 hash 方法计算 key 的 hash 值
}
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)
//tab 就是存放键值对(Node)的数组，如果 tab 为 null 则去初始化 tab
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//通过 hash 计算 index，如果计算位置的 Node 为 null，则新创建一个 Node
tab[i] = newNode(hash, key, value, null);
else {
//当前位置存在 Node
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;
}
1.可以看到 tab 是 Node 类型的数组结构，Node 是负责管理 Key 和 Value 的节点类型，我们就明白了 HashMap 是用一个个节点来帮助我们存储键值对的，并将节点保存在了数组中。方法中最开始就是去判空和初始化 tab 的过程，已有注释标注。
2.根据 key 的 hash 值来计算数组的位置 index，然后对当前位置的节点判空，如果为 null，则新建一个节点对象。
3.若 tab[index] != null，则需要对比当前节点（后文用 curNode 表示）和 put 进来的节点（后文用 putNode 表示）是否相同。可以看到源码中用两个条件进行判断:
-
首先比较 curNode 和 putNode 的 hash 值是否相同（Node 的 hash 即为 key 的 hash），如果 hash 值不同，则两个对象一定不等，两个 hash 等，但对象不一定等（发生了 hash 冲突，我将在下一节详细说解决 hash 冲突的办法），如果 hash 值等，则进入下一个条件。
-
此条件里先比较 curNode.key == putNode.key，也就是直接比较引用的内存地址，如果相同则对象相等，如果两个 key 的引用不同，则继续比较curNode.key.equals(putNode.key)，前提是 putNode.key != null，引用不同则通过 equals 方法来比较两个对象是否相同，有没有似曾相识的感觉，正是我们重写 equals 方法时的思路。
-
一路判断下来，如果条件都为真，直接进行了赋值操作，即向 HashMap 中 put key 值相同的键值对时，value 会覆盖之前的 value。
4.假若 3 中的判断条件为假，即两个对象 hash 值相等，对象却不等，便发生了 hash 冲突，我们先看看 HashMap 是怎么解决冲突的。我在代码注释中已经写到「红黑树」和「单链表」进行存储冲突的节点，为什么是两种方式呢？我们都知道单链表的查询效率并不高，所以当冲突节点 >= TREEIFY_THRESHOLD(8) 时，会调用 treeifyBin() 把单链表转为树，这样之后在 get 的时候效率会提高。这种通过链表结构解决 hash 冲突的方法称为「链地址法」。
5.解决冲突后面的代码就是一些将 value 写入的过程，再之后就是处理数组容量的代码，我没细分析这里，如果同学有兴趣的话再自己钻研一下吧~
分析了这么多 put 的原理，相信 get 就会稍微轻松一些了，咬咬牙，再坚持一下！不多说了，继续看代码。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
1.如果 tab 内有对象，直接取 tab[hash(key)] 这个节点（第一个），源码中有注释 「always check first node」,如果经过 hash 值判断， == 判断，equals 判断后都通过，则直接返回 first 节点，也就是我们通过 key 取到的节点。
2.如果 first 节点不是我们要的，而 first 后面还继续接有其他节点，那么就会遍历后面的节点通过 key.hash 以及 key.equals 找到我们想要的节点然后再返回即可。
充分理解了 put 的原理后，get 很容易就理解了~以后面试官问到懂不懂 HashMap 的原理的时候，可以好好地装一个x了~ 最后，推荐给大家一篇讲HashMap 原理极其细致的文章
http://yikun.github.io/2015/04/01/Java-HashMap%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/#1-_%E6%A6%82%E8%BF%B0
四、Hash 冲突
hash 算法不是万能的，不可能保证每个元素的 hash 值不一样，所以在用散列表存储数据时难免会遇到两个不同的元素却拥有着相同的 hashCode，这样便造成了 hash 冲突。
解决方法有四种，我就用通俗一点的话来阐述一下：
-
开放定址法：
既然当前位置容不下冲突的元素了，那就再找一个空的位置存储 Hash 冲突的值（当前 index 冲突了，那么将冲突的元素放在 index+1)。 -
再散列法：
换一个 Hash 算法再计算一个 hash 值，如果不冲突了就存储值（例如第一个算法是名字的首字母的 Hash 值，如果冲突了，计算名字的第二个字母的 Hash 值，如果冲突解决了则将值放入数组中）。 -
链地址法：
每个数组中都存有一个单链表，发生 Hash 冲突时，只是将冲突的 value 当作新节点插入到链表（HashMap 解决冲突的办法）。 -
公共溢出区法：
将冲突的 value 都存到另外一个顺序表中，查找时如果当前表没有对应值，则去溢出区进行顺序查找。
总结
equals() 和 == 加上 hashCode 其实涉及了很多的基础知识，真的需要我们细细的总结，也许哪一个小的细节就会成为我们面试时的亮点，之后我可能还会继续总结一些针对面试 java 基础相关的知识，欢迎大家继续收看~
我也是个初学者，如写的有问题，请及时联系我！感谢！
网友评论