1.Java集合-HashMap实现原理及源码分析

Posted 2020-10-04 白日梦想家12138

 

　　哈希表（Hash  Table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，这里对java集合框架中的对应实现HashMap的实现原理进行讲解，然后对JDK7的HashMap的源码进行分析

 

　　哈希算法，是一类算法；

　　哈希表（Hash  Table）是一种数据结构；

　　哈希函数：是支撑哈希表的一类函数；

　　HashMap 是 Java中用哈希数据结构实现的Map

 

一、什么是哈希表

　　在讨论哈希表之前，我们先大概了解下其他数据结构在新增、查找等基础操作执行性能

　　数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O（1）；通过给定值查找，需要遍历数据，逐一对比给定关键字和数组元素，时间复杂度为O（n），当然，对于有序数组，则可采用二分查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数据元素的移动，其平均复杂度也为O（n）

　　线性链表：对于链表的新增、删除等操作（在找到指定操作位置后），仅需处理结点的引用即可，时间复杂度为O（1），而查找操作需要遍历链表逐一进行对比，复杂度为O（n）

　　二叉树：对一棵相对平衡的二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O（logn）（这个时间复杂度常见于二分）

　　哈希表：相比上述几种数据结构，在哈希表中进行添加，删除，查找等操作，性能十分高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O（1），接下来我们就来看哈希表是如何实现达到惊艳的常数阶O(1)的。

　　我们知道，数据结构的物理存储结构只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，也这两种物理组织形式）而在上面我们提到过，在数组中根据下标查找某个元素，一次定位就可以达到，哈希表利用了这种特性，哈希表的主干就是数组。

　　比如我们要新增或查找某个元素，我们通过把当前元素的关键字通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作

　　存储位置  =  f（关键字）

　　其中这个函数f一般称为  哈希函数，这个函数设计的好坏会直接影响到哈希表的优劣。举个例子，比如我们要在哈希表中执行插入操作：

　　

 

　　哈希冲突

　　然而没有完美的事，如果有两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的 哈希冲突 ，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放地址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，HashMap即是采用了链地址法，也就是数组 + 链表的方式　　

　　

二、HashMap实现原理

　　HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。

1 //HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂，至于为什么这么做，后面会有详细分析。
2 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

 　　Entry是HashMap中的一个静态内部类。代码如下：

 1 static class Entry<K,V> implements Map.Entry<K,V> {
 2         final K key;
 3         V value;
 4         Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
 5         int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算
 6 
 7         /**
 8          * Creates new entry.
 9          */
10         Entry(int h, K k, V v, Entry<K,V> n) {
11             value = v;
12             next = n;
13             key = k;
14             hash = h;
15 }

所以，HashMap的整体结构如下：

　　简单来说，HashMap由数组 + 链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null），那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度依然为O（1），因为最新的Entry会插入到链表头部，仅需要简单改变引用链即可，而对于查找操作来讲，此时就需要遍历链表，然后通过key对象的equals方法逐一对比查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

 

　　HashMap类中的一些关键属性：

1 //实际存储的key-value键值对的个数
2 transient int size;
3 //阈值；当table被填充了，也就是为table分配内存空间后（初始容量默认为16），threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到
4 int threshold;  //临界值，当实际大小超过临界值时，会进行扩容  threshold = 加载因子*容量
5 //负载因子，代表了table的填充度有多少，默认是0.75
6 final float loadFactor;
7 //用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），需要抛出异常ConcurrentModificationException
8 transient int modCount;

　　注：threshold在这个版本的源码中，起到了两个作用，一个是代表了table的默认初始容量，一个是需要对 HashMap进行扩容的临界值，在对table进行初始化后，就会改变threshold的值，改为加载因子*容量

　　其中loadFactor 加载因子是表示Hash表中元素的填满的程度

　　若：加载因子越大，填满的元素越多，好处是，空间利用率高了，但：冲突的机会大了，链表的常长度会越来越长，查找的效率降低

　　反之，加载因子越小，填满的元素越少，好处是：冲突的机会减小了，但：空间浪费多了，表中的数据过于稀疏（很多空间还没用，就开始扩容了）

　　因此，必须在“冲突的机会” 与 “空间利用率”之间寻找一个平衡与折中，本质上这就是数据结构中有名的 “时-空”矛盾的平衡和折中（一般都不用去设置它，让它取默认值0.75就好了）

　　　　

　　HashMap有四个构造器，如果用户在创建HashMap的时候，没有传入initialCapacity 和 loadFactor这两个参数，会使用默认值，initialCapacity默认为16，loadFactor默认为0.75

 1 public HashMap(int initialCapacity, float loadFactor) {
 2 　　　　　//此处对传入的初始容量进行校验，最大不能超过MAXIMUM_CAPACITY = 1<<30(230)
 3         if (initialCapacity < 0)
 4             throw new IllegalArgumentException("Illegal initial capacity: " +
 5                                                initialCapacity);
 6         if (initialCapacity > MAXIMUM_CAPACITY)
 7             initialCapacity = MAXIMUM_CAPACITY;
 8         if (loadFactor <= 0 || Float.isNaN(loadFactor))
 9             throw new IllegalArgumentException("Illegal load factor: " +
10                                                loadFactor);
11 
12         this.loadFactor = loadFactor;
13         threshold = initialCapacity;
14 　　　　　
15         init();//init方法在HashMap中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现
16 }

　　从上面这段代码可以看出，在常规构造器中，没有为数组table分配内存空间（有一个入参为指定Map的构造器例外），而是在执行put操作的时候才真正构建table数组

 

接下来我们来看看put操作的实现

 1 public V put(K key, V value) {
 2         //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold，此时threshold为initialCapacity 默认是1<<4(24=16)
 3         if (table == EMPTY_TABLE) {
 4             inflateTable(threshold);
 5         }
 6        //如果key为null，存储位置为table[0]或table[0]的冲突链上
 7         if (key == null)
 8             return putForNullKey(value);
 9         int hash = hash(key);//对key的hashcode进一步计算，确保散列均匀
10         int i = indexFor(hash, table.length);//获取在table中的实际位置
11         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
12         //如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value
13             Object k;
14             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
15                 V oldValue = e.value;
16                 e.value = value;
17                 e.recordAccess(this);
18                 return oldValue;
19             }
20         }
21         modCount++;//保证并发访问时，若HashMap内部结构发生变化，快速响应失败
22         addEntry(hash, key, value, i);//新增一个entry
23         return null;
24 }

　　每一个被添加的元素都有一个 hashCode(哈希值)，他们先比较哈希值，是否相同？ 不相同的元素，添加进入 table.  

　　如果hashCode相同的话， 再去比较 equals()方法，如果不相同的话，因为hashcode的值是一样的，所以插入在table数组中的位置是一样的，所以会在这个位置以链表的形式进行存储

　　如果 equals()也相同的话，JVM就认为数据已经存在了，就不会添加数据！

先看下inflateTable这个方法：

1 private void inflateTable(int toSize) {
2         int capacity = roundUpToPowerOf2(toSize);//capacity一定是2的次幂
3         threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//此处为threshold赋值，取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值，capaticy一定不会超过MAXIMUM_CAPACITY，除非loadFactor大于1
4         table = new Entry[capacity];
5         initHashSeedAsNeeded(capacity);
6 }

inflateTable这个方法用于为主干数组table在内存中分配存储空间，通roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂，比如toSize=13，则capacity=16;to_size=16,capacity=16;to_size=17,capacity=32.

1 private static int roundUpToPowerOf2(int number) {
2         // assert number >= 0 : "number must be non-negative";
3         return number >= MAXIMUM_CAPACITY
4                 ? MAXIMUM_CAPACITY
5                 : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
6 }

roundUpToPowerOf2中的这段处理使得数组长度一定为2的次幂，Integer.highestOneBit是用来获取最左边的bit（其他bit位为0）所代表的数值.

　

hash函数

 1 //这是一个神奇的函数，用了很多的异或，移位等运算，对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀
 2 final int hash(Object k) {
 3         int h = hashSeed;
 4         if (0 != h && k instanceof String) {
 5             return sun.misc.Hashing.stringHash32((String) k);
 6         }
 7 
 8         h ^= k.hashCode();
 9 
10         h ^= (h >>> 20) ^ (h >>> 12);
11         return h ^ (h >>> 7) ^ (h >>> 4);
12  }

以上hash函数计算出的值，通过indexFor进一步处理来获取实际的存储位置

1 /**
2      * 返回数组下标
3      */
4     static int indexFor(int h, int length) {
5         return h & (length-1);
6     }

　　我们一般对哈希表的散列很自然地会想到用hash值对length取模（即除法散列法），Hashtable中也是这样实现的，这种方法基本能保证元素在哈希表中散列的比较均匀，但取模会用到除法运算，效率很低，HashMap中则通过h&(length-1)的方法来代替取模，同样实现了均匀的散列，但效率要高很多，这也是HashMap对Hashtable的一个改进。

 

h&（length-1）保证获取的index一定在数组范围内，举个例子，默认容量16，length-1=15，h=18,转换成二进制计算为

最终计算出的index=2。有些版本的对于此处的计算会使用 取模运算，也能保证index一定在数组范围内，不过位运算对计算机来说，性能更高一些（HashMap中有大量位运算）

所以最终存储位置的确定流程是这样的：

·

再来看看addEntry的实现：

1 void addEntry(int hash, K key, V value, int bucketIndex) {
2         if ((size >= threshold) && (null != table[bucketIndex])) {
3             resize(2 * table.length);//当size超过临界阈值threshold，并且即将发生哈希冲突时进行扩容
4             hash = (null != key) ? hash(key) : 0;
5             bucketIndex = indexFor(hash, table.length);
6         }
7 
8         createEntry(hash, key, value, bucketIndex);
9 }

　　通过以上代码能够得知，当发生哈希冲突并且size大于阈值的时候，需要进行数组扩容，扩容时，需要新建一个长度为之前数组2倍的新的数组，然后将当前的Entry数组中的元素全部传输过去，扩容后的新数组长度为之前的2倍，所以扩容相对来说是个耗资源的操作。所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

 

 

三、为什么HashMap的数组长度一定是2的次幂？

　　因为在这个版本的HashMap中，不是用取模运算（hash值对length取模），是通过位运算h&（length-1）来使元素在哈希表中散列的比较均匀，使用位运算的前提就是要保证数组长度是2的次幂，下面我们具体说明：

　　首先，length为2的整数次幂的话，h&(length-1)就相当于对length取模，这样便保证了散列的均匀，同时也提升了效率；

　　其次，length为2的整数次幂的话，就一定是偶数，这样length-1为奇数，奇数的最后一位是1，这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值）。即&后的结果可能为偶数，也可能为奇数，这样便可保证散列的均匀性

　　而如果length为奇数的话，很明显length-1就一定为偶数，它的最后一位是0，这样h&(length-1)的最后一位肯定为0，计算后的结果只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间，因此length取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列

 

接下来我们看看get方法

1 public V get(Object key) {
2 　　　　 //如果key为null,则直接去table[0]处去检索即可。
3         if (key == null)
4             return getForNullKey();
5         Entry<K,V> entry = getEntry(key);
6         return null == entry ? null : entry.getValue();
7  }

get方法通过key值返回对应value，如果key为null，直接去table[0]处检索。我们再看一下getEntry这个方法

 1 final Entry<K,V> getEntry(Object key) {
 2             
 3         if (size == 0) {
 4             return null;
 5         }
 6         //通过key的hashcode值计算hash值
 7         int hash = (key == null) ? 0 : hash(key);
 8         //indexFor (hash&length-1) 获取最终数组索引，然后遍历链表，通过equals方法比对找出对应记录
 9         for (Entry<K,V> e = table[indexFor(hash, table.length)];
10              e != null;
11              e = e.next) {
12             Object k;
13             if (e.hash == hash && 
14                 ((k = e.key) == key || (key != null && key.equals(k))))
15                 return e;
16         }
17         return null;
18 }

　　从上面的源码可以看出，get方法的实现相对简单，key(hashcode)-->hash-->indexFor-->最终索引位置,找到对应位置 table[i]，再查看是否有链表，如果有链表，遍历链表，通过key的equals方法比对查找对应的记录（从链表中存取元素，都需要用到equals方法来判断是否key是否相等）

　　要注意的是，有人觉得上面在定位到数组位置之后然后遍历链表的时候，e.hash == hash这个判断没必要，仅通过equals判断就可以。其实不然，试想一下，如果传入的key对象重写了equals方法却没有重写hashCode，而恰巧此对象定位到这个数组位置，如果仅仅用equals判断可能是相等的，但其hashCode和当前对象不一致，这种情况，根据Object的hashCode的约定，不能返回当前对象，而应该返回null，后面的例子会做出进一步解释。

 

四、重写equals方法需同时重写hashcode方法

很多时候都会听到，“重写equals时也要同时覆盖hashcode”，我们举个小例子来看看，如果重写了equals而不重写hashcode会发生什么样的问题

 1 /**
 2  * Created by chengxiao on 2016/11/15.
 3  */
 4 public class MyTest {
 5     private static class Person{
 6         int idCard;
 7         String name;
 8 
 9         public Person(int idCard, String name) {
10             this.idCard = idCard;
11             this.name = name;
12         }
13         @Override
14         public boolean equals(Object o) {
15             if (this == o) {
16                 return true;
17             }
18             if (o == null || getClass() != o.getClass()){
19                 return false;
20             }
21             Person person = (Person) o;
22             //两个对象是否等值，通过idCard来确定
23             return this.idCard == person.idCard;
24         }
25 
26     }
27     public static void main(String []args){
28         HashMap<Person,String> map = new HashMap<Person, String>();
29         Person person = new Person(1234,"乔峰");
30         //put到hashmap中去
31         map.put(person,"天龙八部");
32         //get取出，从逻辑上讲应该能输出“天龙八部”
33         System.out.println("结果:"+map.get(new Person(1234,"萧峰")));
34     }
35 }

　　如果我们已经对HashMap的原理有了一定了解，这个结果就不难理解了。尽管我们在进行get和put操作的时候，使用的key从逻辑上讲是等值的（通过equals比较是相等的），但由于没有重写hashCode方法，所以put操作时，key(hashcode1)-->hash-->indexFor-->最终索引位置 ，而通过key取出value的时候 key(hashcode1)-->hash-->indexFor-->最终索引位置，由于hashcode1不等于hashcode2，导致没有定位到一个数组位置而返回逻辑上错误的值null（也有可能碰巧定位到一个数组位置，但是也会判断其entry的hash值是否相等，上面get方法中有提到。）

　　所以，在重写equals的方法的时候，必须注意重写hashCode方法，同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）。

 

总结：HashMap的工作原理

HashMap基于hashing原理，我们通过put()和get()方法存储和获取对象。

都是   key(hashcode1)-->hash-->indexFor-->最终索引位置  都是这样一个过程

当发生哈希碰撞时（不同元素最终得到的hash值可能相同，即数组索引可能相同），HashMap即是采用了链地址法来解决，也就是数组 + 链表的方式，链表中的元素通过equlas方法来判断后进行存取

 

最后，看一下HashMap有关的一些面试问题：

先来些简单的问题

“你用过HashMap吗？” “什么是HashMap？你为什么用到它？”

　　几乎每个人都会回答“是的”，然后回答HashMap的一些特性，譬如HashMap可以接受null键值和值，而Hashtable则不能；HashMap是非synchronized;HashMap很快；以及HashMap储存的是键值对等等。这显示出你已经用过HashMap，而且对它相当的熟悉。但是面试官来个急转直下，从此刻开始问出一些刁钻的问题，关于HashMap的更多基础的细节。面试官可能会问出下面的问题：

 

“你知道HashMap的工作原理吗？” “你知道HashMap的get()方法的工作原理吗？”

　　你也许会回答“我没有详查标准的Java API，你可以看看Java源代码或者Open JDK。”“我可以用Google找到答案。”

　　但一些面试者可能可以给出答案，“HashMap是基于hashing的原理，我们使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。当我们给put()方法传递键和值时，我们先对键调用hashCode()方法，返回的hashCode用于找到bucket位置来储存Entry对象。”这里关键点在于指出，HashMap是在bucket中储存键对象和值对象，作为Map.Entry。这一点有助于理解获取对象的逻辑。如果你没有意识到这一点，或者错误的认为仅仅只在bucket中存储值的话，你将不会回答如何从HashMap中获取对象的逻辑。这个答案相当的正确，也显示出面试者确实知道hashing以及HashMap的工作原理。但是这仅仅是故事的开始，当面试官加入一些Java程序员每天要碰到的实际场景的时候，错误的答案频现。下个问题可能是关于HashMap中的碰撞探测(collision detection)以及碰撞的解决方法：

 

“当两个对象的hashcode相同会发生什么？” 

　　从这里开始，真正的困惑开始了，一些面试者会回答因为hashcode相同，所以两个对象是相等的，HashMap将会抛出异常，或者不会存储它们。然后面试官可能会提醒他们有equals()和hashCode()两个方法，并告诉他们两个对象就算hashcode相同，但是它们可能并不相等。一些面试者可能就此放弃，而另外一些还能继续挺进，他们回答“因为hashcode相同，所以它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。”这个答案非常的合理，虽然有很多种处理碰撞的方法，这种方法是最简单的，也正是HashMap的处理方法。但故事还没有完结，面试官会继续问：

 

“如果两个键的hashcode相同，你如何获取值对象？” 

　　面试者会回答：当我们调用get()方法，HashMap会使用键对象的hashcode找到bucket位置，然后获取值对象。面试官提醒他如果有两个值对象储存在同一个bucket，他给出答案:将会遍历链表直到找到值对象。面试官会问因为你并没有值对象去比较，你是如何确定确定找到值对象的？除非面试者直到HashMap在链表中存储的是键值对，否则他们不可能回答出这一题。

　　其中一些记得这个重要知识点的面试者会说，找到bucket位置之后，会调用keys.equals()方法去找到链表中正确的节点，最终找到要找的值对象。完美的答案！

　　许多情况下，面试者会在这个环节中出错，因为他们混淆了hashCode()和equals()方法。因为在此之前hashCode()屡屡出现，而equals()方法仅仅在获取值对象的时候才出现。一些优秀的开发者会指出使用不可变的、声明作final的对象，并且采用合适的equals()和hashCode()方法的话，将会减少碰撞的发生，提高效率。不可变性使得能够缓存不同键的hashcode，这将提高整个获取对象的速度，使用String，Interger这样的wrapper类作为键是非常好的选择（wrapper类正好满足前面提到的）。

 

如果你认为到这里已经完结了，那么听到下面这个问题的时候，你会大吃一惊。“如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？”

　　除非你真正知道HashMap的工作原理，否则你将回答不出这道题。默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)一样，将会创建原来HashMap大小的两倍的bucket数组，来重新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing，因为它调用hash方法找到新的bucket位置。

 

如果你能够回答这道问题，下面的问题来了：“你了解重新调整HashMap大小存在什么问题吗？”你可能回答不上来，这时面试官会提醒你当多线程的情况下，可能产生条件竞争(race condition)。

当重新调整HashMap大小的时候，确实存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么就死循环了。这个时候，你可以质问面试官，为什么这么奇怪，要在多线程的环境下使用HashMap呢？：）

 

热心的读者贡献了更多的关于HashMap的问题：

为什么String, Interger这样的wrapper类适合作为键？

　　 String, Interger这样的wrapper类作为HashMap的键是再适合不过了，而且String最为常用。因为String是不可变的，也是final的，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其他的优点如线程安全。如果你可以仅仅通过将某个field声明成final就能保证hashCode是不变的，那么请这么做吧。因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的。如果两个不相等的对象返回不同的hashcode的话，那么碰撞的几率就会小些，这样就能提高HashMap的性能。

 

我们可以使用自定义的对象作为键吗？ 

　　这是前一个问题的延伸。当然你可能使用任何对象作为键，只要它遵守了equals()和hashCode()方法的定义规则，并且当对象插入到Map中之后将不会再改变了。如果这个自定义对象时不可变的，那么它已经满足了作为键的条件，因为当它创建之后就已经不能改变了。

 

　　我们可以使用CocurrentHashMap来代替Hashtable吗？

这是另外一个很热门的面试题，因为ConcurrentHashMap越来越多人用了。我们知道Hashtable是synchronized的，但是ConcurrentHashMap同步性能更好，因为它仅仅根据同步级别对map的一部分进行上锁。ConcurrentHashMap当然可以代替HashTable，但是HashTable提供更强的线程安全性。

 

让我们再来看看这些问题设计哪些知识点：

　　hashing的概念

　　HashMap中解决碰撞的方法

　　equals()和hashCode()的应用，以及它们在HashMap中的重要性

　　不可变对象的好处

　　HashMap多线程的条件竞争

　　重新调整HashMap的大小

 

 

参考:http://www.cnblogs.com/chengxiao/p/6059914.html

　　http://www.cnblogs.com/ITtangtang/p/3948798.html　

作者： dreamcatcher-cx

出处： <http://www.cnblogs.com/chengxiao/>

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在页面明显位置给出原文链接。