【Java集合学习系列】HashMap实现原理及源码分析

HashMap特性

hashMap是基于哈希表的Map接口的非同步实现,继承自AbstractMap接口,实现了Map接口(HashTable跟HashMap很像,HashTable中的方法是线程安全的,也就是同步的,而HashMap是非同步的,这是唯一的区别),此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。

HashMap的数据结构

HashMap是基于hashing的原理,实际上就是一个“链表的数组”的数据结构,每个元素存放在链表头结点的数组,即数组和链表的结合体—哈希表。

PS:数组的特点是寻址容易,但是插入和删除困难;链表的特点是寻址困难,但是插入和删除容易。哈希表就是综合了这两者特性的一种数据结构,寻址容易,插入和删除也容易。

下面我们就结合哈希表的一种常用实现-拉链法来学习一下哈希表的使用:

《【Java集合学习系列】HashMap实现原理及源码分析》

拉链法:将具有同一散列地址的记录存储在一条线性链表中。在除留余数法中,取关键字被某个不大于哈希表长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中的链表出现越少,性能才会越好。
《【Java集合学习系列】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在应用中遇到的问题

HashMap在并发下可能出现的问题分析

    原文作者:java集合源码分析
    原文地址: https://blog.csdn.net/lmb55/article/details/77727348
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞