HashMap特性
hashMap是基于哈希表的Map接口的非同步实现,继承自AbstractMap接口,实现了Map接口(HashTable跟HashMap很像,HashTable中的方法是线程安全的,也就是同步的,而HashMap是非同步的,这是唯一的区别),此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。
HashMap的数据结构
HashMap是基于hashing的原理,实际上就是一个“链表的数组”的数据结构,每个元素存放在链表头结点的数组,即数组和链表的结合体—哈希表。
PS:数组的特点是寻址容易,但是插入和删除困难;链表的特点是寻址困难,但是插入和删除容易。哈希表就是综合了这两者特性的一种数据结构,寻址容易,插入和删除也容易。
下面我们就结合哈希表的一种常用实现-拉链法来学习一下哈希表的使用:
拉链法:将具有同一散列地址的记录存储在一条线性链表中。在除留余数法中,取关键字被某个不大于哈希表长m的数p除后所得余数为我们需要的哈希地址。
H(key) = key MOD p(p <= m)
比如,以上length为16的数组,每个数组元素存储的都是一个链表的头结点。设关键字为(12,28,108,140),除数为16(小于等于16),散列地址为(12,12,12,12),所以(12,28,108,140)都存储在数组下标为12的位置。
从以上我们可以看出HashMap存储数据结构的容器就是一个线性数组。说到这里,我们知道HashMap是按键值对来存取数据的,但是线性数组怎么实现按键值对存取数据?
看HashMap的源码我们知道,HashMap里面实现了一个静态内部类Entry,Entry的主要属性key、value、next。看到这里就明白了,原来HashMap按照键值对存取数据是通过Entry这个基础bean来实现的。再回头看我们上面说的线性数组实现按键值对存取数据,这个线性数组就是Entry[],Map中的数据都保存在线性数组Entry中。数组中的每一项又是一个链表,当新建一个HashMap的时候,就会初始化一个数组。其中Entry就是数组中的元素,每个Map.Entry其实就是一个key-value对,它持有一个指向下一个元素的引用next,这就构成了链表,如下图。
数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的,如果定位到的数组位置不含链表(当前entry的next指向null),那么对于查找,添加等操作很快,仅需一次寻址即可;如果定位到的数组包含链表,对于添加操作,其时间复杂度依然为O(1),因为最新的Entry会插入链表头部,急需要简单改变引用链即可,而对于查找操作来讲,此时就需要遍历链表,然后通过key对象的equals方法逐一比对查找。所以,性能考虑,HashMap中的链表出现越少,性能才会越好。
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
/**
* This method is invoked whenever the value in an entry is
* overwritten by an invocation of put(k,v) for a key k that's already
* in the HashMap.
*/
void recordAccess(HashMap<K,V> m) {
}
/**
* This method is invoked whenever the entry is
* removed from the table.
*/
void recordRemoval(HashMap<K,V> m) {
}
}
HashMap的存取实现
我们上面说到HashMap是线性数组,因为我们知道HashMap可以随机存取,线性数组实现随机存取?HashMap是怎么实现的呢?我们看下下面的算法:
//存储时
int hash = key.hashCode();// 每个key的hash是一个固定的int值
int index = hash % Entry[].length;
Entry[index] = value;
//取值时
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];
这就是HashMap通过键值对实现存取的基本原理。
我们看下源码:
存储:
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//HashMap允许存放null key和null value,当key为null时,调用putForNullKey方法,将value放到数组第一个位置
if (key == null)
return putForNullKey(value);
//计算hash值
int hash = hash(key);
//搜素指定的hash值所对应的table中的索引
int i = indexFor(hash, table.length);
//如果索引i处的Entry不为null,通过不断遍历元素e的下一个元素,直到找到索引i处的Entry为null,表明此处还没有Entry
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;//modCount记录HashMap中修改结构的次数
//将key、value添加到索引i处
addEntry(hash, key, value, i);
return null;
}
当我们向HashMap中put元素的时候,先根据key值计算hashcode,然后根据hash值得到这个元素在数组中的位置(下标)。如果数组的相应位置已经存放了元素,则在该位置上的元素以链表的形式存放,新加入的元素存放在链表的头部,最先加入的元素存放在链表的尾部。如果数组的该位置上没有元素,就直接将该元素放到此数组的该位置上。
void addEntry(int hash, K key, V value, int bucketIndex) {
//如果Map中的key-value对的数量超过了极限或者bucketIndex索引不存在,将table对象的长度扩充到原来的2倍
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
//添加Entry
createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
//获取指定bucketIndex所引处的Entry
Entry<K,V> e = table[bucketIndex];
//将新建的Entry放入bucketIndex索引处,并让新的Entry指向原来的Entry
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
根据hash值调用addEntry(hash,key,value,i)方法将key、value值键值对存储在数组table的i索引处。从源码中我们可以看到,当系统决定存储HashMap中的key、value键值对的时候,没有有关value的操作,只是根据key来计算每个Entry的存储位置。也就是说,当系统决定了key存储的位置之后,value也就随之保存了。
上面的hash(int h)方法根据key值重新计算了一次散列。此算法加入了高位计算,防止低位不变,高位变化时造成的hash冲突。
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
我们可以看到,在上面我们是使用hash算法根据key来求得元素在对应数组中的位置。因为我们知道HashMap的数据结构是数组和链表的结合,如果HashMap里面的元素位置分布得比较均匀,每个位置上的元素数量只有一个,那么当我们用hash算法求位置的时候,马上就可以知道对应位置的元素是不是我们需要的,而不需要再去遍历链表,这样能大大优化查询效率。
对于任意对象。只要它的key值相同,
int hash = hash(key);
int i = indexFor(hash, table.length);
调用hash算法求得的hash值就是相同的。我们上面提到过的拉链法是值对表长度取模,在这里如果使用hash值对数组长度取模,元素的分配相对来说也会比较均匀。但是“模”运算的消耗比较大,HashMap是怎么解决这个问题的呢?
HashMap使用了indexFor(int h,int length)方法来计算该对象应该保存在table数组的哪个索引处,方法如下:
/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
}
我们注意到注释里面有一行:table的长度length必须是2的非零幂。看到这里,我们需要提到另一个知识点,HashMap底层数组的长度总是2的n次方,这是HashMap在速度上的优化。
看下HashMap的putAll方法的源码:
public void putAll(Map<? extends K, ? extends V> m) {
int numKeysToBeAdded = m.size();
if (numKeysToBeAdded == 0)
return;
if (table == EMPTY_TABLE) {
inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold));
}
if (numKeysToBeAdded > threshold) {
int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
int newCapacity = table.length;
while (newCapacity < targetCapacity)
newCapacity <<= 1;
if (newCapacity > table.length)
resize(newCapacity);
}
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
put(e.getKey(), e.getValue());
}
我们注意到有这么一行:
while (newCapacity < targetCapacity)
newCapacity <<= 1;
PS:
int i = 1;
//类似于 i++就是 i = i+1;的这结构
i <<= 1;//i = i<<1 i等于i乘以2的1次方
i <<= 2;//i = i<<2 i等于i乘以2的2次方,>>就是相除了
这段代码在JDK1.7之前出现在HashMap的构造函数中,保证了初始化HashMap的容量(即底层数组的长度)总是2的n次方。
扩容的时候也有一个方法:
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
当length总是 2 的n次方时,h& (length-1)运算等价于对length取模,也就是h%length,但是&比%具有更高的效率。
这看上去很简单,其实比较有玄机的,我们举个例子来说明:
假设数组长度分别为15和16,优化后的hash码分别为8和9,那么&运算后的结果如下:
h & (table.length-1) | hash | table.length-1
8 & (15-1): | 0100 & 1110 = 0100
9 & (15-1): | 0101 & 1110 = 0100
8 & (16-1): | 0100 & 1111 = 0100
9 & (16-1): | 0101 & 1111 = 0101
从上面的例子中可以看出:当8、9两个数和(15-1)2=(1110)进行“与运算&”的时候,产生了相同的结果,都为0100,也就是说它们会定位到数组中的同一个位置上去,这就产生了碰撞,8和9会被放到数组中的同一个位置上形成链表,那么查询的时候就需要遍历这个链 表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hash值会与(15-1)2=(1110)进行“与运算&”,那么最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!
而当数组长度为16时,即为2的n次方时,2n-1得到的二进制数的每个位上的值都为1(比如(24-1)2=1111),这使得在低位上&时,得到的和原hash的低位相同,加之hash(int h)方法对key的hashCode的进一步优化,加入了高位计算,就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。
所以说,当数组长度为2的n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。
读取:
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
private V getForNullKey() {
if (size == 0) {
return null;
}
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
总结起来,从HashMap中get元素的时候,会首先计算key的hash值,找到数组中对应位置的元素,然后通过equals比较key值从而找出需要的元素,
HashMap的存取归纳来说,就是HashMap 在底层将 key-value 当成一个整体进行处理,这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对,当需要存储一个 Entry 对象时,会根据hash算法来决定其在数组中的存储位置,在根据equals方法决定其在该数组位置上的链表中的存储位置;当需要取出一个Entry时,也会根据hash算法找到其在数组中的存储位置,再根据equals方法从该位置上的链表中取出该Entry。
HashMap的resize(rehash):
当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,数组扩容这个操作也会出现在ArrayList中,这是一个常用的操作,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
那么HashMap什么时候进行扩容呢?当HashMap中的元素个数超过数组大小*loadFactor时,就会进行数组扩容,loadFactor的默认值为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小为16,那么当HashMap中元素个数超过16*0.75=12(这个值就是代码中的threshold值,也叫做临界值)的时候,就把数组的大小扩展为 2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//如果当前数组的长度已经达到最大值则不进行调整
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//根据入参的长度定义新数组
Entry[] newTable = new Entry[newCapacity];
//按照最新的规则,将旧数组中的元素转移到新数组
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//更新临界值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable, boolean rehash) {
//生成的新数组的长度
int newCapacity = newTable.length;
//遍历旧数组取值放入新数组
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
HashMap构造函数:
其中有两个要注意的性能参数:initialCapacity(初始容量), loadFactor(负载因子)。
/**
* 构建一个初始容量为16,,负载因子为0.75的HashMap
*
* initialCapacity:HashMap的最大容量,即为底层数组的长度,默认为16.
* loadFactor:负载因子loadFactor定义为:散列表的实际元素数目(n)/ 散列表的容量(m),默认为0.75.
*/
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
/**
* 构建一个初始容量为initialCapacity,,负载因子为0.75的HashMap
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 构建一个指定初始容量和指定负载因子的HashMap
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;//临界值
init();
}
负载因子衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费。
threshold临界值就是在此loadFactor和capacity对应下允许的最大元素数目,超过这个数目就重新resize,以降低实际的负载因子。当容量超出最大容量时,resize后的HashMap容量是现有容量的两倍,addEntry方法中有这样一段代码:
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
ConcurrentModificationException
java.util.HashMap不是线程安全的(为什么HashMap不是线程安全的),如果在使用迭代器的过程中有其它线程修改了map,就会抛出ConcurrentModificationException。
关于这个异常,我们需要学习HashMap源码的一个抽象内部类HashIterator,这牵涉到fail-fast策略。这一策略在源码中的实现是通过modCount。在上面的学习中我们知道modCount是记录的修改次数,每次对HashMap内容的修改,这个值都会增加。在迭代器初始化的过程中会将这个值赋值给迭代器的expectedModCount。在迭代过程中,判断modCount跟expectedModCount是否相等,如果不相等就表示已经有其他线程修改了Map。看了源码我们就会知道,modCount声明为volatile,保证线程之间修改的可见性。(volatile之所以线程安全是因为被volatile修饰的变量不保存缓存,直接在内存中修改,因此能够保证线程之间修改的可见性)。
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // current slot
Entry<K,V> current; // current entry
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
final Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
}
重写equals方法需同时重写hashCode方法
在此之前我们先来看一下java中==和equals的区别:
String str1=new String("apple");
String str2=new String("apple");
str1==str2;//false
str1.equals(str2);//true
结果解析:==比较的是两个对象的地址,equals比较的是两个对象的内容.
如果一个类没有自己定义equals方法,那么它将继承Object类的equals方法,Object类的equals方法的实现代码如下:
boolean equals(Object o){
return this==o;
}
这说明,如果一个类没有自己定义equals方法,它默认的equals方法(从Object 类继承的)就是使用==操作符,也是在比较两个变量指向的对象是否是同一对象,这时候使用equals和使用==会得到同样的结果,如果比较的是两个独立的对象则总返回false。
总结来说:
1)对于==,如果作用于基本数据类型的变量,则直接比较其存储的 “值”是否相等;如果作用于引用类型的变量,则比较的是所指向的对象的地址
2)对于equals方法,注意:equals方法不能作用于基本数据类型的变量。如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址;诸如String、Date等类对equals方法进行了重写的话,比较的是所指向的对象的内容。
下面我们来看,为什么重写equals方法时必须要重写hashCode方法:
在使用HashMap添加对象时,hashCode()方法会被调用,判断与已经存储在集合中对象的hashCode值是否一致。如果不一致则直接加进去(不用比较equals()提高效率);如果一致,则进行equals方法的比较,如果返回true,说明集合中已经存在这个对象,不能添加。如果返回false,表名集合中没有这个对象,可以加进去。所以,在重写hashCode()方法或者equals()方法的任何一个方法时,都必须重写另外一个。
object对象中默认的public boolean equals(Object obj),对于任何非空引用值 x 和 y,当且仅当 x 和 y 引用同一个对象时,此方法才返回 true。Object默认的hashCode散列码是对象的存储地址,对象不同其所调用的hashCode方法所得到的值也不同
equals()方法和hashCode()方法有一个常规协定,如下:
(1)当obj1.equals(obj2)为true时,obj1.hashCode() == obj2.hashCode()必须为true【同一个对象的hashCode必须相等】
(2)当obj1.hashCode() == obj2.hashCode()为false时,obj1.equals(obj2)必须为false【hashCode不相等的两个对象一定不是同一个对象】
如果不重写equals,就相当于使用==,那么比较的是对象的引用是否指向同一块内存地址。重写之后的目的是为了区别于==,去比较两个对象的value值是否相等。
通过上面的学习,我们知道,hashCode是用于散列数据的快速存取,如利用HashSet/HashMap/HashTable类来存储数据时,都是根据存储对象的hashCode值来进行判断是否相同。
这样,如果我们对一个对象重写了equals,意思是只要对象的成员变量的值都相等那么equals就等于true,但不重写hashCode,那么当我们再重新new一个新对象,当原对象.equals(新对象)等于true的时候,两者的hashCode是不一样的,由此产生了理解的不一致。如果在存储散列集合时(如set时),将会存储两个值一样的对象,导致混淆,看下面的测试代码。因此,重写equals方法时也必须要重写hashCode方法。
测试代码:
import java.util.Collection;
import java.util.HashSet;
public class HelloWord {
public static void main(String[] args) {
Person n1 = new Person("Tom");
Person n2 = new Person("Tom");
Collection c = new HashSet();
System.out.println("n1放入collection集合");
c.add(n1);
System.out.println("n2放入collection集合");
c.add(n2);
System.out.println("equals比较");
System.out.println("n1.equals(n2) : " + n1.equals(n2));
System.out.println("计算hashCode");
System.out.println("n1.hashCode() : " + n1.hashCode());
System.out.println("n2.hashCode() :" + n2.hashCode());
System.out.println("显示集合列表");
System.out.println("c : " + c);
}
}
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String toString(){
return this.name;
}
public boolean equals(Object obj) {
if (obj instanceof Person) {
Person person = (Person) obj;
System.out.println("[equals:name]"+ name);
System.out.println("[equals:person.name]"+ person.name);
return (name.equals(person.name));
}
return super.equals(obj);
}
/*
public int hashCode() {
Person person = (Person) this;
System.out.println("[hashCode:person.name]" + person.name);
System.out.println("[hashCode:name.hashCode()]" + name.hashCode());
return name.hashCode();
}*/
}
重写了hashCode方法的运行结果:
n1放入collection集合
[hashCode:person.name]Tom
[hashCode:name.hashCode()]84274
n2放入collection集合
[hashCode:person.name]Tom
[hashCode:name.hashCode()]84274
[equals:name]Tom
[equals:person.name]Tom
equals比较
[equals:name]Tom
[equals:person.name]Tom
n1.equals(n2) : true
计算hashCode
[hashCode:person.name]Tom
[hashCode:name.hashCode()]84274
n1.hashCode() : 84274
[hashCode:person.name]Tom
[hashCode:name.hashCode()]84274
n2.hashCode() :84274
显示集合列表
c : [Tom]
不重写hashCode方法的运行结果:
n1放入collection集合
n2放入collection集合
equals比较
[equals:name]Tom
[equals:person.name]Tom
n1.equals(n2) : true
计算hashCode
n1.hashCode() : 1326101490
n2.hashCode() :1202453864
显示集合列表
c : [Tom, Tom]
HashMap在应用中遇到的问题: