Java 集合系列 09 HashMap详细介绍(源码解析)和使用示例

java 集合系列目录：

Java 集合系列 01 总体框架

Java 集合系列 02 Collection架构

Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例

Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例

Java 集合系列 05 Vector详细介绍(源码解析)和使用示例

Java 集合系列 06 Stack详细介绍(源码解析)和使用示例

Java 集合系列 07 List总结(LinkedList, ArrayList等使用场景和性能分析)

Java 集合系列 08 Map架构

Java 集合系列 09 HashMap详细介绍(源码解析)和使用示例

Java 集合系列 10 Hashtable详细介绍(源码解析)和使用示例

Java 集合系列 11 hashmap 和 hashtable 的区别

Java 集合系列 12 TreeMap

Java 集合系列 13 WeakHashMap

Java 集合系列 14 hashCode

Java 集合系列 15 Map总结

Java 集合系列 16 HashSet

Java 集合系列 17 TreeSet

概要

这一章，我们对HashMap进行学习。
我们先对HashMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用HashMap。内容包括：

第1部分 HashMap介绍
第2部分 HashMap数据结构
第3部分 HashMap源码解析(基于JDK1.7.0_45)
   第3.1部分 HashMap的“拉链法”相关内容
    第3.2部分 HashMap的构造函数
    第3.3部分 HashMap的主要对外接口
    第3.4部分 HashMap实现的Cloneable接口
    第3.5部分 HashMap实现的Serializable接口
第4部分 HashMap遍历方式

第5部分 HashMap实例演示

第1部分 HashMap介绍

HashMap简介

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的。

HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。容量 是哈希表中桶的数量，初始容量 只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

HashMap的构造函数

HashMap共有4个构造函数,如下：

// 默认构造函数。
HashMap()

// 指定“容量大小”的构造函数
HashMap(int capacity)

// 指定“容量大小”和“加载因子”的构造函数
HashMap(int capacity, float loadFactor)

// 包含“子Map”的构造函数
HashMap(Map<? extends K, ? extends V> map)

HashMap的API

 void clear()
          从此映射中移除所有映射关系。
 Object clone()
          返回此 HashMap 实例的浅表副本：并不复制键和值本身。
 boolean containsKey(Object key)
          如果此映射包含对于指定键的映射关系，则返回 true。
 boolean containsValue(Object value)
          如果此映射将一个或多个键映射到指定值，则返回 true。
 Set<Map.Entry<K,V>> entrySet()
          返回此映射所包含的映射关系的 Set 视图。
 V get(Object key)
          返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
 boolean isEmpty()
          如果此映射不包含键-值映射关系，则返回 true。
 Set<K> keySet()
          返回此映射中所包含的键的 Set 视图。
 V put(K key, V value)
          在此映射中关联指定值与指定键。
 void putAll(Map<? extends K,? extends V> m)
          将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
 V remove(Object key)
          从此映射中移除指定键的映射关系（如果存在）。
 int size()
          返回此映射中的键-值映射关系数。
 Collection<V> values()
          返回此映射所包含的值的 Collection 视图。 

第2部分 HashMap数据结构

HashMap的继承关系

java.lang.Object
   ↳     java.util.AbstractMap<K, V>
         ↳     java.util.HashMap<K, V>

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable { }

HashMap与Map关系如下图：

从图中可以看出： 
(01) HashMap继承于AbstractMap类，实现了Map接口。Map是"key-value键值对"接口，AbstractMap实现了"键值对"的通用函数接口。 
(02) HashMap是通过"拉链法"实现的哈希表。它包括几个重要的成员变量：table, size, threshold, loadFactor, modCount。
　　table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的"key-value键值对"都是存储在Entry数组中的。 
　　size是HashMap的大小，它是HashMap保存的键值对的数量。 
　　threshold是HashMap的阈值，用于判断是否需要调整HashMap的容量。threshold的值="容量*加载因子"，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
　　loadFactor就是加载因子。 
　　modCount是用来实现fail-fast机制的。

第3部分 HashMap源码解析(基于JDK1.7.0_45)

为了更了解HashMap的原理，下面对HashMap源码代码作出分析。

第3.1部分 HashMap的“拉链法”相关内容

transient Entry[] table;

HashMap中的key-value都是存储在Entry数组中的。

3.1.2 数据节点Entry的数据结构

     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;
         }

             //判断两个Entry是否相等
      // 若两个Entry的“key”和“value”都相等，则返回true。
      // 否则，返回false
         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) {
         }
     }

从中，我们可以看出 Entry 实际上就是一个单向链表。这也是为什么我们说HashMap是通过拉链法解决哈希冲突的。
Entry 实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数。这些都是基本的读取/修改key、value值的函数。

第3.2部分 HashMap的构造函数

HashMap共包括4个构造函数

 /**
      * Constructs an empty <tt>HashMap</tt> with the specified initial
      * capacity and load factor.
      *
      * @param  initialCapacity the initial capacity
      * @param  loadFactor      the load factor
      * @throws IllegalArgumentException if the initial capacity is negative
      *         or the load factor is nonpositive
      */
     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();
     }

     /**
      * Constructs an empty <tt>HashMap</tt> with the specified initial
      * capacity and the default load factor (0.75).
      *
      * @param  initialCapacity the initial capacity.
      * @throws IllegalArgumentException if the initial capacity is negative.
      */
     public HashMap(int initialCapacity) {
         this(initialCapacity, DEFAULT_LOAD_FACTOR);
     }

     /**
      * Constructs an empty <tt>HashMap</tt> with the default initial capacity
      * (16) and the default load factor (0.75).
      */
     public HashMap() {
         this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
     }

     /**
      * 包含“子Map”的构造函数
      */
     public HashMap(Map<? extends K, ? extends V> m) {
         this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                       DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
         inflateTable(threshold);

         putAllForCreate(m);
     }

第3.3部分 HashMap的主要对外接口

3.3.1 clear()

clear() 的作用是清空HashMap。它是通过将所有的元素设为null来实现的。

  /**
      * Removes all of the mappings from this map.
      * The map will be empty after this call returns.
      */
     public void clear() {
         modCount++;
         Arrays.fill(table, null);
         size = 0;
     }

    /**
      * Assigns the specified Object reference to each element of the specified
      * array of Objects.
      *
      * @param a the array to be filled
      * @param val the value to be stored in all elements of the array
      * @throws ArrayStoreException if the specified value is not of a
      *         runtime type that can be stored in the specified array
      */
     public static void fill(Object[] a, Object val) {
         for (int i = 0, len = a.length; i < len; i++)
             a[i] = val;
     }

3.3.2 containsKey()

containsKey() 的作用是判断HashMap是否包含key。

 /**
      * Returns <tt>true</tt> if this map contains a mapping for the
      * specified key.
      *
      * @param   key   The key whose presence in this map is to be tested
      * @return <tt>true</tt> if this map contains a mapping for the specified
      * key.
      */
     public boolean containsKey(Object key) {
         return getEntry(key) != 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;
     }

3.3.4 entrySet()、values()、keySet()

它们3个的原理类似，这里以entrySet()为例来说明。
entrySet()的作用是返回“HashMap中所有Entry的集合”，它是一个集合。实现代码如下：

 // 返回“HashMap的Entry集合”
 public Set<Map.Entry<K,V>> entrySet() {
     return entrySet0();
 }

 // 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象
 private Set<Map.Entry<K,V>> entrySet0() {
     Set<Map.Entry<K,V>> es = entrySet;
     return es != null ? es : (entrySet = new EntrySet());
 }

 // EntrySet对应的集合
 // EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。
 private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
     public Iterator<Map.Entry<K,V>> iterator() {
         return newEntryIterator();
     }
     public boolean contains(Object o) {
         if (!(o instanceof Map.Entry))
             return false;
         Map.Entry<K,V> e = (Map.Entry<K,V>) o;
         Entry<K,V> candidate = getEntry(e.getKey());
         return candidate != null && candidate.equals(e);
     }
     public boolean remove(Object o) {
         return removeMapping(o) != null;
     }
     public int size() {
         return size;
     }
     public void clear() {
         HashMap.this.clear();
     }
 }

HashMap是通过拉链法实现的散列表。表现在HashMap包括许多的Entry，而每一个Entry本质上又是一个单向链表。那么HashMap遍历key-value键值对的时候，是如何逐个去遍历的呢？

下面我们就看看HashMap是如何通过entrySet()遍历的。
entrySet()实际上是通过newEntryIterator()实现的。 下面我们看看它的代码：

 // 返回一个“entry迭代器”
 Iterator<Map.Entry<K,V>> newEntryIterator()   {
     return new EntryIterator();
 }

 // Entry的迭代器
 private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
     public Map.Entry<K,V> next() {
         return nextEntry();
     }
 }

 // HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。
 // 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。
 private abstract class HashIterator<E> implements Iterator<E> {
     // 下一个元素
     Entry<K,V> next;
     // expectedModCount用于实现fast-fail机制。
     int expectedModCount;
     // 当前索引
     int index;
     // 当前元素
     Entry<K,V> current;

     HashIterator() {
         expectedModCount = modCount;
         if (size > 0) { // advance to first entry
             Entry[] t = table;
             // 将next指向table中第一个不为null的元素。
             // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。
             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();

         // 注意！！！
         // 一个Entry就是一个单向链表
         // 若该Entry的下一个节点不为空，就将next指向下一个节点;
         // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。
         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;
     }

 }

当我们通过entrySet()获取到的Iterator的next()方法去遍历HashMap时，实际上调用的是 nextEntry() 。而nextEntry()的实现方式，先遍历Entry(根据Entry在table中的序号，从小到大的遍历)；然后对每个Entry(即每个单向链表)，逐个遍历。

3.3.5 get()

get() 的作用是获取key对应的value，它的实现代码如下：

 /**
      * Returns the value to which the specified key is mapped,
      * or {@code null} if this map contains no mapping for the key.
      *
      * <p>More formally, if this map contains a mapping from a key
      * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
      * key.equals(k))}, then this method returns {@code v}; otherwise
      * it returns {@code null}.  (There can be at most one such mapping.)
      *
      * 空返回值并不一定表明map不包含映射的关键;也有可能map上显式映射空的关键。
      * containsKey操作可以用来区分这两种情况下。
      */
     public V get(Object key) {
         if (key == null)
             return getForNullKey();
         Entry<K,V> entry = getEntry(key);

         return null == entry ? null : entry.getValue();
     }

     /**
      * Returns the entry associated with the specified key in the
      * HashMap.  Returns null if the HashMap contains no mapping
      * for the key.
      */
     final Entry<K,V> getEntry(Object key) {
         if (size == 0) {
             return null;
         }
             // 获取key的hash值
         int hash = (key == null) ? 0 : hash(key);
         // 在“该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;
     }

3.3.6 put()

put() 的作用是对外提供接口，让HashMap对象可以通过put()将“key-value”添加到HashMap中。

     /**
      * Associates the specified value with the specified key in this map.
      * If the map previously contained a mapping for the key, the old
      * value is replaced.
      *
      * @param key key with which the specified value is to be associated
      * @param value value to be associated with the specified key
      * @return the previous value associated with <tt>key</tt>, or
      *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
      *         (A <tt>null</tt> return can also indicate that the map
      *         previously associated <tt>null</tt> with <tt>key</tt>.)
      */
     public V put(K key, V value) {
         if (table == EMPTY_TABLE) {
             inflateTable(threshold);
         }
         // 若“key为null”，则将该键值对添加到table[0]中。
         if (key == null)
             return putForNullKey(value);
         // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
         int hash = hash(key);
         int i = indexFor(hash, table.length);
         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
             Object k;
             // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                 V oldValue = e.value;
                 e.value = value;
                 e.recordAccess(this);
                 return oldValue;
             }
         }
                 // 若“该key”对应的键值对不存在，则将“key-value”添加到table中
         modCount++;
         addEntry(hash, key, value, i);
         return null;
     }

      /**
      * Offloaded version of put for null keys
      */
     private V putForNullKey(V value) {
         for (Entry<K,V> e = table[0]; e != null; e = e.next) {
             if (e.key == null) {
                 V oldValue = e.value;
                 e.value = value;
                 e.recordAccess(this);
                 return oldValue;
             }
         }
         modCount++;
         addEntry(0, null, value, 0);
         return null;
     }

     /**
          * 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) {
         }

若要添加到HashMap中的键值对对应的key已经存在HashMap中，则找到该键值对；然后新的value取代旧的value，并退出！
若要添加到HashMap中的键值对对应的key不在HashMap中，则将其添加到该哈希值对应的链表中，并调用addEntry()。
下面看看addEntry()的代码：

     /**
      * Adds a new entry with the specified key, value and hash code to
      * the specified bucket.  It is the responsibility of this
      * method to resize the table if appropriate.
      *
      * Subclass overrides this to alter the behavior of put method.
      */
     void addEntry(int hash, K key, V value, int bucketIndex) {
         if ((size >= threshold) && (null != table[bucketIndex])) {
             resize(2 * table.length);
             hash = (null != key) ? hash(key) : 0;
             bucketIndex = indexFor(hash, table.length);
         }

         createEntry(hash, key, value, bucketIndex);
     }

addEntry() 的作用是新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。

createEntry()的代码如下：

     /**
      * Like addEntry except that this version is used when creating entries
      * as part of Map construction or "pseudo-construction" (cloning,
      * deserialization).  This version needn't worry about resizing the table.
      *
      * Subclass overrides this to alter the behavior of HashMap(Map),
      * clone, and readObject.
      */
     void createEntry(int hash, K key, V value, int bucketIndex) {
             // 保存“bucketIndex”位置的值到“e”中
         Entry<K,V> e = table[bucketIndex];
         // 设置“bucketIndex”位置的元素为“新Entry”，
             // 设置“e”为“新Entry的下一个节点”
         table[bucketIndex] = new Entry<>(hash, key, value, e);
         size++;
     }

它们的作用都是将key、value添加到HashMap中。而且，比较addEntry()和createEntry()的代码，我们发现addEntry()多了两句：

if ((size >= threshold) && (null != table[bucketIndex]))
     resize(2 * table.length);

那它们的区别到底是什么呢？
阅读代码，可以发现它们的使用情景不同。
(01) addEntry()一般用在 新增Entry可能导致“HashMap的实际容量”超过“阈值”的情况下。
       例如，我们新建一个HashMap，然后不断通过put()向HashMap中添加元素；put()是通过addEntry()新增Entry的。
       在这种情况下，我们不知道何时“HashMap的实际容量”会超过“阈值”；
       因此，需要调用addEntry()
(02) createEntry() 一般用在 新增Entry不会导致“HashMap的实际容量”超过“阈值”的情况下。
        例如，我们调用HashMap“带有Map”的构造函数，它会将Map的全部元素添加到HashMap中；
       但在添加之前，我们已经计算好“HashMap的容量和阈值”。也就是，可以确定“即使将Map中的全部元素添加到HashMap中，都不会超过HashMap的阈值”。
       此时，调用createEntry()即可。

3.3.7 putAll()

putAll() 的作用是将"m"的全部元素都添加到HashMap中，它的代码如下：

     /**
      * Copies all of the mappings from the specified map to this map.
      * These mappings will replace any mappings that this map had for
      * any of the keys currently in the specified map.
      *
      * @param m mappings to be stored in this map
      * @throws NullPointerException if the specified map is null
      */
     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));
         }

         /*
          *  计算容量是否足够，若“当前实际容量 < 需要的容量”，则将容量x2。
          * Expand the map if the map if the number of mappings to be added
          * is greater than or equal to threshold.  This is conservative; the
          * obvious condition is (m.size() + size) >= threshold, but this
          * condition could result in a map with twice the appropriate capacity,
          * if the keys to be added overlap with the keys already in this map.
          * By using the conservative calculation, we subject ourself
          * to at most one extra resize.
          */
         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);
         }
                 //通过迭代器，将“m”中的元素逐个添加到HashMap中。
         for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
             put(e.getKey(), e.getValue());
     }

     /**
      * Inflates the table.
      */
     private void inflateTable(int toSize) {
         // Find a power of 2 >= toSize
         int capacity = roundUpToPowerOf2(toSize);

         threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
         table = new Entry[capacity];
         initHashSeedAsNeeded(capacity);
     }

     **
      * Rehashes the contents of this map into a new array with a
      * larger capacity.  This method is called automatically when the
      * number of keys in this map reaches its threshold.
      */
     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);
     }

     /**
      * Initialize the hashing mask value. We defer initialization until we
      * really need it.
      */
     final boolean initHashSeedAsNeeded(int capacity) {
         boolean currentAltHashing = hashSeed != 0;
         boolean useAltHashing = sun.misc.VM.isBooted() &&
                 (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
         boolean switching = currentAltHashing ^ useAltHashing;
         if (switching) {
             hashSeed = useAltHashing
                 ? sun.misc.Hashing.randomHashSeed(this)
                 : 0;
         }
         return switching;
     }

3.3.8 remove()

remove() 的作用是删除“键为key”元素

 public V remove(Object key) {
     Entry<K,V> e = removeEntryForKey(key);
     return (e == null ? null : e.value);
 }

 // 删除“键为key”的元素
 final Entry<K,V> removeEntryForKey(Object key) {
     // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算
     int hash = (key == null) ? 0 : hash(key.hashCode());
     int i = indexFor(hash, table.length);
     Entry<K,V> prev = table[i];
     Entry<K,V> e = prev;

     // 删除链表中“键为key”的元素
     // 本质是“删除单向链表中的节点”
     while (e != null) {
         Entry<K,V> next = e.next;
         Object k;
         if (e.hash == hash &&
             ((k = e.key) == key || (key != null && key.equals(k)))) {
             modCount++;
             size--;
             if (prev == e)
                 table[i] = next;
             else
                 prev.next = next;
             e.recordRemoval(this);
             return e;
         }
         prev = e;
         e = next;
     }

     return e;
 }

第3.4部分 HashMap实现的Cloneable接口

HashMap实现了Cloneable接口，即实现了clone()方法。
clone()方法的作用就是克隆一个HashMap对象并返回。

 /**
      * Returns a shallow copy of this <tt>HashMap</tt> instance: the keys and
      * values themselves are not cloned.
      *
      * @return a shallow copy of this map
      */
     public Object clone() {
         HashMap<K,V> result = null;
         try {
             result = (HashMap<K,V>)super.clone();
         } catch (CloneNotSupportedException e) {
             // assert false;
         }
         if (result.table != EMPTY_TABLE) {
             result.inflateTable(Math.min(
                 (int) Math.min(
                     size * Math.min(1 / loadFactor, 4.0f),
                     // we have limits...
                     HashMap.MAXIMUM_CAPACITY),
                table.length));
         }
         result.entrySet = null;
         result.modCount = 0;
         result.size = 0;
         result.init();
     // 调用putAllForCreate()将全部元素添加到HashMap中
         result.putAllForCreate(this);

         return result;
     }

 private void putAllForCreate(Map<? extends K, ? extends V> m) {
         for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
             putForCreate(e.getKey(), e.getValue());
     }

第3.5部分 HashMap实现的Serializable接口

HashMap实现java.io.Serializable，分别实现了串行读取、写入功能。
串行写入函数是writeObject()，它的作用是将HashMap的“总的容量，实际容量，所有的Entry”都写入到输出流中。
而串行读取函数是readObject()，它的作用是将HashMap的“总的容量，实际容量，所有的Entry”依次读出

 // java.io.Serializable的写入函数
 // 将HashMap的“总的容量，实际容量，所有的Entry”都写入到输出流中
 private void writeObject(java.io.ObjectOutputStream s)
     throws IOException
 {
     Iterator<Map.Entry<K,V>> i =
         (size > 0) ? entrySet0().iterator() : null;

     // Write out the threshold, loadfactor, and any hidden stuff
     s.defaultWriteObject();

     // Write out number of buckets
     s.writeInt(table.length);

     // Write out size (number of Mappings)
     s.writeInt(size);

     // Write out keys and values (alternating)
     if (i != null) {
         while (i.hasNext()) {
         Map.Entry<K,V> e = i.next();
         s.writeObject(e.getKey());
         s.writeObject(e.getValue());
         }
     }
 }

 // java.io.Serializable的读取函数：根据写入方式读出
 // 将HashMap的“总的容量，实际容量，所有的Entry”依次读出
 private void readObject(java.io.ObjectInputStream s)
      throws IOException, ClassNotFoundException
 {
     // Read in the threshold, loadfactor, and any hidden stuff
     s.defaultReadObject();

     // Read in number of buckets and allocate the bucket array;
     int numBuckets = s.readInt();
     table = new Entry[numBuckets];

     init();  // Give subclass a chance to do its thing.

     // Read in size (number of Mappings)
     int size = s.readInt();

     // Read the keys and values, and put the mappings in the HashMap
     for (int i=0; i<size; i++) {
         K key = (K) s.readObject();
         V value = (V) s.readObject();
         putForCreate(key, value);
     }
 }

第4部分 HashMap遍历方式

4.1 遍历HashMap的键值对

第一步：根据entrySet()获取HashMap的“键值对”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

public class hashmap_test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        for (int i = 0; i < 5; i++) {
            map.put(i, Integer.valueOf(i).toString());
        }
        Iterator iter = map.entrySet().iterator();
        while(iter.hasNext()){
            Map.Entry entry = (Entry) iter.next();
            Integer key = (Integer) entry.getKey();
            String value = (String) entry.getValue();
        }

    }
}

4.2 遍历HashMap的键

第一步：根据keySet()获取HashMap的“键”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

 public class hashmap_test {
     public static void main(String[] args) {
         HashMap<Integer, String> map = new HashMap<>();
         for (int i = 0; i < 5; i++) {
             map.put(i, Integer.valueOf(i).toString());
         }

         Iterator iter = map.keySet().iterator();
         Integer key = null;
         String value = null;
         while(iter.hasNext()){
             key = (Integer) iter.next();
             value = map.get(key);
         }
     }
 }

第5部分 HashMap实例演示

我们来看个非常简单的例子。有一个”国家”(Country)类，我们将要用Country对象作为key，它的首都的名字（String类型）作为value。下面的例子有助于我们理解key-value对在HashMap中是如何存储的。

1. Country.java

/**
 *
 * @ClassName: Country TODO
 * @author Xingle
 * @date 2014-7-4 下午4:32:10
 */
public class Country {

    private String name;

    private long population;

    public Country(String name, long population) {
        super();
        this.name = name;
        this.population = population;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public long getPopulation() {
        return population;
    }

    public void setPopulation(long population) {
        this.population = population;
    }

    public int hashCode() {
        if (this.name.length() % 2 == 0)
            return 31;
        else
            return 95;
    }

    public boolean equals(Object obj) {
        Country other = (Country) obj;
        if (name.equals(other.getName()))
            return true;
        else
            return false;
    }
}

2. HashMapStructure.java

 /**
  *
  * @ClassName: HashMapStructure TODO
  * @author Xingle
  * @date 2014-7-4 下午4:37:31
  */
 public class HashMapStructure {

     public static void main(String[] args){
         Country india = new Country("India", 1000);
         Country japan = new Country("Japan", 1000);
         Country france = new Country("France", 1000);
         Country russia = new Country("Russia", 1000);

         HashMap<Country, String> countryCapitalMap = new HashMap<Country, String>();
         countryCapitalMap.put(india, "Delhi");
         countryCapitalMap.put(japan,"Tokyo");
         countryCapitalMap.put(france,"Paris");
         countryCapitalMap.put(russia,"Moscow");

         //key迭代器
         Iterator<Country> countryCapitalIter = countryCapitalMap.keySet().iterator();
         while(countryCapitalIter.hasNext()){
             Country countryObj = countryCapitalIter.next();
             String capital = countryCapitalMap.get(countryObj);
             System.out.println(countryObj.getName()+"---"+countryObj.hashCode()+"----"+capital);
         }

     }
 }

执行结果：

Japan---95----Tokyo
India---95----Delhi
Russia---31----Moscow
France---31----Paris

现在，在第22行设置一个断点,debug下，查看countryCapitalMap，将会看到如下的结构：

从上图可以观察到以下几点：

1.table大小是16的Entry数组。这个table数组存储了Entry类的对象。HashMap类有一个叫做Entry的内部类。这个Entry类包含了key-value作为实例变量

2.我们来看下Entry类的结构。Entry类的结构：

static class Entry implements Map.Entry
{
        final K key;
        V value;
        Entry next;
        final int hash;
        ...//More code goes here
}   `

每当往hashmap里面存放key-value对的时候，都会为它们实例化一个Entry对象，这个Entry对象就会存储在前面提到的Entry数组table中。那么，上面创建的Entry对象将会存放在具体哪个位置（在table中的精确位置）。答案就是，根据key的hashcode()方法计算出来的hash值（来决定）。hash值用来计算key在Entry数组的索引。
现在，如果你看下上图中数组的索引10，它有一个叫做HashMap$Entry的Entry对象。
我们往hashmap放了4个key-value对，但是看上去好像只有2个元素！！！这是因为，如果两个元素有相同的hashcode，它们会被放在同一个索引上，以链表(LinkedList)的形式来存储的(逻辑上)。
上面的country对象的key-value的hash值是如何计算出来的。

下图会清晰的从概念上解释下链表。

现在假如你已经很好地了解了hashmap的结构，让我们看下put和get方法。

Put :

让我们看下put方法的实现：

/**
  * Associates the specified value with the specified key in this map. If the
  * map previously contained a mapping for the key, the old value is
  * replaced.
  *
  * @param key
  *            key with which the specified value is to be associated
  * @param value
  *            value to be associated with the specified key
  * @return the previous value associated with <tt>key</tt>, or <tt>null</tt>
  *         if there was no mapping for <tt>key</tt>. (A <tt>null</tt> return
  *         can also indicate that the map previously associated
  *         <tt>null</tt> with <tt>key</tt>.)
  */
 public V put(K key, V value) {
  if (key == null)
   return putForNullKey(value);
  int hash = hash(key.hashCode());
  int i = indexFor(hash, table.length);
  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++;
  addEntry(hash, key, value, i);
  return null;
 }

现在我们一步一步来看下上面的代码。

1. 对key做null检查。如果key是null，会被存储到table[0]，因为null的hash值总是0。

2. key的hashcode()方法会被调用，然后计算hash值。hash值用来找到存储Entry对象的数组的索引。有时候hash函数可能写的很不好，所以JDK的设计者添加了另一个叫做hash()的方法，它接收刚才计算的hash值作为参数。如果你想了解更多关于hash()函数的东西，可以参考：hashmap中的hash和indexFor方法

3. indexFor(hash,table.length)用来计算在table数组中存储Entry对象的精确的索引。

4. 在我们的例子中已经看到，如果两个key有相同的hash值(也叫冲突)，他们会以链表的形式来存储。所以，这里我们就迭代链表。

• 如果在刚才计算出来的索引位置没有元素，直接把Entry对象放在那个索引上。
• 如果索引上有元素，然后会进行迭代，一直到Entry->next是null。当前的Entry对象变成链表的下一个节点。
• 如果我们再次放入同样的key会怎样呢？逻辑上，它应该替换老的value。事实上，它确实是这么做的。在迭代的过程中，会调用equals()方法来检查key的相等性(key.equals(k))，如果这个方法返回true，它就会用当前Entry的value来替换之前的value。

Get:

现在我们来看下get方法的实现：

/**
  * Returns the value to which the specified key is mapped, or {@code null}
  * if this map contains no mapping for the key.
  *
  * <p>
  * More formally, if this map contains a mapping from a key {@code k} to a
  * value {@code v} such that {@code (key==null ? k==null :
  * key.equals(k))}, then this method returns {@code v}; otherwise it returns
  * {@code null}. (There can be at most one such mapping.)
  *
  * </p><p>
  * A return value of {@code null} does not <i>necessarily</i> indicate that
  * the map contains no mapping for the key; it's also possible that the map
  * explicitly maps the key to {@code null}. The {@link #containsKey
  * containsKey} operation may be used to distinguish these two cases.
  *
  * @see #put(Object, Object)
  */
 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;
 }

当你理解了hashmap的put的工作原理，理解get的工作原理就非常简单了。当你传递一个key从hashmap总获取value的时候：

1. 对key进行null检查。如果key是null，table[0]这个位置的元素将被返回。

2. key的hashcode()方法被调用，然后计算hash值。

3. indexFor(hash,table.length)用来计算要获取的Entry对象在table数组中的精确的位置，使用刚才计算的hash值。

4. 在获取了table数组的索引之后，会迭代链表，调用equals()方法检查key的相等性，如果equals()方法返回true，get方法返回Entry对象的value，否则，返回null。

要牢记以下关键点：

• HashMap有一个叫做Entry的内部类，它用来存储key-value对。
• 上面的Entry对象是存储在一个叫做table的Entry数组中。
• table的索引在逻辑上叫做“桶”(bucket)，它存储了链表的第一个元素。
• key的hashcode()方法用来找到Entry对象所在的桶。
• 如果两个key有相同的hash值，他们会被放在table数组的同一个桶里面。
• key的equals()方法用来确保key的唯一性。
• value对象的equals()和hashcode()方法根本一点用也没有。

---

转载：http://www.cnblogs.com/skywang12345/p/3310835.html