程序博客网 > 林彪的军事才能 知乎

Java HashMap实现详解

来源：互联网 发布：林彪的军事才能 知乎 编辑：程序博客网 时间：2024/05/02 00:39

以前学习HahsMap都是粗略的了解一下，能够用就行了。这次对HahsMap的源代码看了几遍，对此有一定的理解，就我的理解我总结出如下几点。但在此之前，我们先说下HahsMap的结构，简单来说：HahsMap其实是一个数组和链表的结合体。 
第一、首先对HahsMap的初始容量（也即DEFAULT_INITIAL_CAPACITY）来说个事，看下面的代码吧： 
Java代码  收藏代码
  1. public class TestHashMap {  
  2.     public static void main(String[] args) {  
  3.         HashMap<Integer, Integer> hm1=new HashMap<Integer, Integer>();  
  4.         HashMap<Integer, Integer> hm2=new HashMap<Integer, Integer>(1024<<7);  
  5.         long time1=System.currentTimeMillis();    
  6.         for(int i=0;i<100000;i++){  
  7.             hm1.put(i, i);  
  8.         }  
  9.         long time2=System.currentTimeMillis();    
  10.         long time3=System.currentTimeMillis();    
  11.         for(int i=0;i<100000;i++){  
  12.             hm2.put(i, i);  
  13.         }  
  14.         long time4=System.currentTimeMillis();   
  15.         System.out.println("默认初始容量8所用时间为："+(time2-time1));  
  16.         System.out.println("定义初始容量131072所用时间为："+(time4-time3));  
  17.     }  
  18. }  

程序运行的结果为：默认初始容量8所用时间为：94 
               定义初始容量131072所用时间为：47 
可以看出，第二种方法所用时间基本上是前面的一半，这是为什么呢？其实，HashMap的rehash是一个非常消耗性能的操作，rehash的次数越多，所消耗的时间也就越长。当插入100000个元素时，使用初始容量rehash的次数会很多，而根据（100000）/0.75=133333（0.75是HashMap的默认装填因子），也即是说第二种方法只要rehash一次即可，所以消耗的时间会大大减少。 
第二、HashMap的装填因子，按如上代码，我们稍做修改，把定义的hm1和hm2修改成如下： 
Java代码  收藏代码
  1. HashMap<Integer, Integer> hm1=new HashMap<Integer, Integer>(1024<<7,1);  
  2.         HashMap<Integer, Integer> hm2=new HashMap<Integer, Integer>(1024<<7);  
在此运行，结果为：定义装填因子为1所用时间为：47 
               默认装填因子为0.75所用时间为：62 
在这里，我们循环插入100000个数据，但根据HashMap中的hash()函数，基本呈均匀分布，这样，没有什么冲突，那当然是装满更好，插入的效率会提高。但并不是装填因子越大越好，因为我们并不知道插入的数据是不是接近于均匀分布，如果不是的话，那么冲突会很大，查询的效率就会降低，装填因子太小也不好，因为这样会很浪费空间。所以HashMap默认的装填因子取了个折中的数0.75。 
小结下：装填因子衡量的是一个散列表的空间使用程度，装填因子越大表示散列表的装填程度越高，反之越小。我们知道对一个链表法的散列表来说，查询一个元素的平均时间为O(1+a),因此，如果装填因子越大，对空间的利用更充分，然而查询效率就会降低；如果装填因子过小，那么散列表的数据就过于稀疏，对空间造成严重的浪费。 
总结下：如果你知道所要插入的数据的个数N，那么你可以定义HashMap的容量大小为：N/0.75,有因为HashMap的容量必须是2的幂次方，找一个接近的即可；如果你还知道其近似一个均匀分布的话，那么装填因子也可以自己定义，接近于1会更效率。


1.    HashMap概述：
   HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
 
2.    HashMap的数据结构：
   在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

 
   从上图中可以看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。
   源码如下：
 /**
 * The table, resized as necessary. Length MUST Always be a power of two.
 */
transient Entry[] table;
 
static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    final int hash;
    ……
}
   可以看出，Entry就是数组中的元素，每个 Map.Entry 其实就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。
 
3.    HashMap的存取实现：
   1) 存储：
 public V put(K key, V value) {
    // HashMap允许存放null键和null值。
    // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。
    if (key == null)
        return putForNullKey(value);
    // 根据key的keyCode重新计算hash值。
    int hash = hash(key.hashCode());
    // 搜索指定hash值在对应table中的索引。
    int i = indexFor(hash, table.length);
    // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。
    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;
        }
    }
    // 如果i索引处的Entry为null，表明此处还没有Entry。
    modCount++;
    // 将key、value添加到i索引处。
    addEntry(hash, key, value, i);
    return null;
}
   从上面的源代码中可以看出：当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。
   addEntry(hash, key, value, i)方法根据计算出的hash值，将key-value对放在数组table的i索引处。addEntry 是 HashMap 提供的一个包访问权限的方法，代码如下：
 void addEntry(int hash, K key, V value, int bucketIndex) {
    // 获取指定 bucketIndex 索引处的 Entry 
    Entry<K,V> e = table[bucketIndex];
    // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    // 如果 Map 中的 key-value 对的数量超过了极限
    if (size++ >= threshold)
    // 把 table 对象的长度扩充到原来的2倍。
        resize(2 * table.length);
}
   当系统决定存储HashMap中的key-value对时，完全没有考虑Entry中的value，仅仅只是根据key来计算并决定每个Entry的存储位置。我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。
   hash(int h)方法根据key的hashCode重新计算一次散列。此算法加入了高位计算，防止低位不变，高位变化时，造成的hash冲突。
static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
 
   我们可以看到在HashMap中要找到某个元素，需要根据key的hash值来求得对应数组中的位置。如何计算这个位置就是hash算法。前面说过HashMap的数据结构是数组和链表的结合，所以我们当然希望这个HashMap里面的 元素位置尽量的分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，而不用再去遍历链表，这样就大大优化了查询的效率。
   对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 hash 码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，“模”运算的消耗还是比较大的，在HashMap中是这样做的：调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。indexFor(int h, int length) 方法的代码如下：
static int indexFor(int h, int length) {
    return h & (length-1);
}
 
   这个方法非常巧妙，它通过 h & (table.length -1) 来得到该对象的保存位，而HashMap底层数组的长度总是 2 的 n 次方，这是HashMap在速度上的优化。在 HashMap 构造器中有如下代码：
int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;
   这段代码保证初始化时HashMap的容量总是2的n次方，即底层数组的长度总是为2的n次方。
当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     （8为1000）有问题
       9 & (16-1)：                      0101       &             1111         =       0101   （9是1001）
  
   从上面的例子中可以看出：当它们和15-1（1110）“与”的时候，产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到数组中的同一个位置上形成链表，那么查询的时候就需要遍历这个链 表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hash值会与15-1（1110）进行“与”，那么 最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！而当数组长度为16时，即为2的n次方时，2n-1得到的二进制数的每个位上的值都为1，这使得在低位上&时，得到的和原hash的低位相同，加之hash(int h)方法对key的hashCode的进一步优化，加入了高位计算，就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。
   
   所以说，当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。
   根据上面 put 方法的源代码可以看出，当程序试图将一个key-value对放入HashMap中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但key不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部——具体说明继续看 addEntry() 方法的说明。
   2) 读取：
public V get(Object key) {
    if (key == null)
        return getForNullKey();
    int hash = hash(key.hashCode());
    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.equals(k)))
            return e.value;
    }
    return null;
}
 
   有了上面存储时的hash算法作为基础，理解起来这段代码就很容易了。从上面的源代码中可以看出：从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。
  
   3) 归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。
 
4.    HashMap的resize（rehash）：
   当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。
   那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
 
5.    HashMap的性能参数：
   HashMap 包含如下几个构造器：
   HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
   HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
   HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。
   HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数，它们是初始容量initialCapacity和加载因子loadFactor。
   initialCapacity：HashMap的最大容量，即为底层数组的长度。
   loadFactor：负载因子loadFactor定义为：散列表的实际元素数目(n)/ 散列表的容量(m)。
   负载因子衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。
   HashMap的实现中，通过threshold字段来判断HashMap的最大容量：
threshold = (int)(capacity * loadFactor);
   结合负载因子的定义公式可知，threshold就是在此loadFactor和capacity对应下允许的最大元素数目，超过这个数目就重新resize，以降低实际的负载因子。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时， resize后的HashMap容量是容量的两倍：
 
if (size++ >= threshold)   
    resize(2 * table.length);  
 
6.    Fail-Fast机制：
   我们知道java.util.HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。
   这一策略在源码中的实现是通过modCount域，modCount顾名思义就是修改次数，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。
HashIterator() {
    expectedModCount = modCount;
    if (size > 0) { // advance to first entry
    Entry[] t = table;
    while (index < t.length && (next = t[index++]) == null)
        ;
    }
}
 
   在迭代过程中，判断modCount跟expectedModCount是否相等，如果不相等就表示已经有其他线程修改了Map：
   注意到modCount声明为volatile，保证线程之间修改的可见性。
final Entry<K,V> nextEntry() {   
    if (modCount != expectedModCount)   
        throw new ConcurrentModificationException();
 
   在HashMap的API中指出：
   由所有HashMap类的“collection 视图方法”所返回的迭代器都是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时间发生任意不确定行为的风险。
   注意，迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

然后来看一下Java的Hashtable实现

java.util.Hashtable的本质是个数组，数组的元素是linked的键值对（单向链表）。

Java代码 复制代码 收藏代码
  1. private transient Entry[] table; // Entry数组  


Java代码 复制代码 收藏代码
  1. private static class Entry<K,V> implements Map.Entry<K,V> {   
  2.     int hash;   
  3.     K key;   
  4.     V value;   
  5.     Entry<K,V> next; // Entry此处表明是个单链表   
  6.     ...   
  7. }  


我们可以使用指定数组大小、装填因子的构造函数，也可以使用默认构造函数，默认数组的大小是11，装填因子是0.75.
Java代码 复制代码 收藏代码
  1. public Hashtable(int initialCapacity, float loadFactor) {   
  2. ...   
  3. }   
  4. public Hashtable() {   
  5.     this(11, 0.75f);   
  6. }  


当要扩大数组时，大小变为oldCapacity * 2 + 1，当然这无法保证数组的大小总是素数。
来看下其中的元素插入的方法，put方法：
Java代码 复制代码 收藏代码
  1. public synchronized V put(K key, V value) {   
  2.     // Make sure the value is not null   
  3.     if (value == null) {   
  4.         throw new NullPointerException();   
  5.     }   
  6.        
  7.     // Makes sure the key is not already in the hashtable.  
  8.     Entry tab[] = table;   
  9.     int hash = key.hashCode();   
  10.     int index = (hash & 0x7FFFFFFF) % tab.length;   
  11.     for (Entry<K, V> e = tab[index]; e != null; e = e.next) {   
  12.         if ((e.hash == hash) && e.key.equals(key)) {   
  13.             V old = e.value;   
  14.             e.value = value;   
  15.             return old;   
  16.         }   
  17.     }   
  18. }  


Java中Object类有几个方法，其中一个是hashCode(), 这说明Java中所有对象都具有这一方法，调用可以得到对象自身的hash码。对表的长度取余得址，并在冲突位置使用链表。

HashMap与Hashtable的功能几乎一样。但HashMap的的初始数组大小是16而不是11，当要扩大数组时，大小变为原来的2倍，默认的装填因子也是0.75. 其put方法如下，对hash值和index都有更改：
Java代码 复制代码 收藏代码
  1. public V put(K key, V value) {   
  2.     if (key == null)   
  3.         return putForNullKey(value);   
  4.     int hash = hash(key.hashCode());   
  5.     int i = indexFor(hash, table.length);   
  6.     for (Entry<K, V> e = table[i]; e != null; e = e.next) {   
  7.         Object k;   
  8.         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {   
  9.             V oldValue = e.value;   
  10.             e.value = value;   
  11.             e.recordAccess(this);   
  12.             return oldValue;   
  13.         }   
  14.     }   
  15.   
  16.     modCount++;   
  17.     addEntry(hash, key, value, i);   
  18.     return null;   
  19. }   
  20.   
  21.   
  22. /**  
  23.  * Applies a supplemental hash function to a given hashCode, which 
  24.  * defends against poor quality hash functions.  This is critical 
  25.  * because HashMap uses power-of-two length hash tables, that 
  26.  * otherwise encounter collisions for hashCodes that do not differ 
  27.  * in lower bits. Note: Null keys always map to hash 0, thus index 0. 
  28.  */  
  29. static int hash(int h) {   
  30.     // This function ensures that hashCodes that differ only by  
  31.     // constant multiples at each bit position have a bounded  
  32.     // number of collisions (approximately 8 at default load factor).  
  33.     h ^= (h >>> 20) ^ (h >>> 12);   
  34.     return h ^ (h >>> 7) ^ (h >>> 4);   
  35. }   
  36.   
  37. /**  
  38.  * Returns index for hash code h.  
  39.  */  
  40. static int indexFor(int h, int length) {   
  41.     return h & (length-1);   
  42. }  

可以想像，当表中的数据个数接近表的容量大小时，发生冲突的概率会明显增大，因此，在“数据个数/表容量”到达某个比例的时侯，需要扩大表的容量，这个比例称为“装填因子”(load factor).

解决冲突主要有下面两类方法：
× 分离链接法，就是对hash到同一地址的不同元素，用链表连起来，也叫拉链法
× 开放定址法，如果地址有冲突，就在此地址附近找。包括线性探测法，平方探测法，双散列等



再看看其它开源的Java库中的Hashtable

目前存在多个开源的Java Collection实现，各个目的不同，侧重点也不同。以下对开源框架中哈希表的分析主要从几个方面入手：默认装填因子和capacity扩展方式，散列函数以及解决冲突的方法。

1. Trove - Trove库提供一套高效的基础集合类。

gnu.trove.set.hash.THashMap的继承关系：THashMap -> TObjectHash -> THash，其内部的键和值使分别用2个数组表示。其解决冲突的方式采用开放寻址法，开放寻址法对空间要求较高，因此其默认装填因子load factor是0.5，而不是0.75. 下面看代码一步步解释：

默认初始化，装填因子0.5，数组大小始从素数中取，也就是始终是素数。
Java代码 复制代码 收藏代码
  1. /** the load above which rehashing occurs. */  
  2. public static final float DEFAULT_LOAD_FACTOR = 0.5f;   
  3.   
  4. protected int setUp( int initialCapacity ) {   
  5.     int capacity;   
  6.     capacity = PrimeFinder.nextPrime( initialCapacity );   
  7.     computeMaxSize( capacity );   
  8.     computeNextAutoCompactionAmount( initialCapacity );   
  9.     return capacity;   
  10. }  


然后看其put方法，insertKey(T key)是其散列算法，hash码对数组长度取余后，得到index，首先检查该位置是否被占用，如果被占用，使用双散列算法解决冲突，也就是代码中的insertKeyRehash()方法。
Java代码 复制代码 收藏代码
  1. public V put(K key, V value) {   
  2.     // insertKey() inserts the key if a slot if found and returns the index  
  3.     int index = insertKey(key);   
  4.     return doPut(value, index);   
  5. }   
  6.   
  7.   
  8. protected int insertKey(T key) {   
  9.     consumeFreeSlot = false;   
  10.   
  11.     if (key == null)   
  12.         return insertKeyForNull();   
  13.   
  14.     final int hash = hash(key) & 0x7fffffff;   
  15.     int index = hash % _set.length;   
  16.     Object cur = _set[index];   
  17.   
  18.     if (cur == FREE) {   
  19.         consumeFreeSlot = true;   
  20.         _set[index] = key;  // insert value   
  21.         return index;       // empty, all done  
  22.     }   
  23.   
  24.     if (cur == key || equals(key, cur)) {   
  25.         return -index - 1;   // already stored  
  26.     }   
  27.   
  28.     return insertKeyRehash(key, index, hash, cur);   
  29. }  




2. Javolution - 对实时、内置、高性能系统提供Java解决方案

Javolution中的哈希表是jvolution.util.FastMap, 冲突解决是其内部是双向链表，默认初始大小是16，扩展时变为2倍。并没有显式定义load factor, 从下面语句可以知道，其值为0.5
Java代码 复制代码 收藏代码
  1. if (map._entryCount + map._nullCount > (entries.length >> 1)) { // Table more than half empty.  
  2.     map.resizeTable(_isShared);   
  3. }  


再看下put函数，比较惊人的是其index和slot的取得，完全是用hashkey移位的方式取得的，这样同时计算了index和避免了碰撞。
Java代码 复制代码 收藏代码
  1. private final Object put(Object key, Object value, int keyHash,   
  2.         boolean concurrent, boolean noReplace, boolean returnEntry) {   
  3.     final FastMap map = getSubMap(keyHash);   
  4.     final Entry[] entries = map._entries; // Atomic.  
  5.     final int mask = entries.length - 1;   
  6.     int slot = -1;   
  7.     for (int i = keyHash >> map._keyShift;; i++) {   
  8.         Entry entry = entries[i & mask];   
  9.         if (entry == null) {   
  10.             slot = slot < 0 ? i & mask : slot;   
  11.             break;   
  12.         } else if (entry == Entry.NULL) {   
  13.             slot = slot < 0 ? i & mask : slot;   
  14.         } else if ((key == entry._key) || ((keyHash == entry._keyHash) && (_isDirectKeyComparator ? key.equals(entry._key)   
  15.                 : _keyComparator.areEqual(key, entry._key)))) {   
  16.             if (noReplace) {   
  17.                 return returnEntry ? entry : entry._value;   
  18.             }   
  19.             Object prevValue = entry._value;   
  20.             entry._value = value;   
  21.             return returnEntry ? entry : prevValue;   
  22.         }   
  23.     }   
  24.     ...   
  25. }      




0 0
林彪的军事才能 知乎 林彪的军事才能 知乎
原创粉丝点击
热门IT博客
乐清知临寄宿学校校长乐清知临寄宿学校校长
php 查询数据类型charphp 查询数据类型char
ipad清理内存软件
淘宝客服岗位职责描述
multisim mac版破解
php nodejs 对比
怎么成为淘宝商家
精雕软件社区
case在c语言中的意思
西南大学网络教育收费
rose only和beast 知乎
php定义json数组
unity3d assetbundle
免费api数据接口
法式风情 知乎
公司样本制作软件
windows家庭中文版
android反编译windows
rmvb剪辑软件
power dvd mac
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 2018年建筑学就业崩溃 中国大学建筑学专业排名 建筑学专业就业前景 女生建筑学就业前景 建筑学就业前景及工资 建筑学包括哪些专业 未来5到20年建筑学的就业前景 建筑学研究生大学排名 东南大学建筑学硕士 东南大学建筑学排名 有建筑学专业的大学 中南大学建筑学排名 东南大学建筑学分数线 生物科学专业 应用化学就业方向 采矿工程就业前景 土木工程专业就业方向 信息工程专业就业方向 物流工程专业就业前景 土木工程就业方向 包装工程就业前景 建设工程管理专业 生物技术专业就业前景 动物科学专业就业前景 建筑专业 农林经济管理就业方向 建筑类专业就业前景 城市规划专业就业前景 建筑室内设计专业介绍 交通运输专业就业方向 建筑经济管理 城乡规划专业就业前景 车辆工程就业方向 食品科学与工程专业就业前景 建筑工程专业就业前景 地质工程专业就业前景 建筑管理专业 信息工程专业 物流工程专业 农业专业就业前景 信息工程专业就业前景

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里