概要

这一章，我们对HashMap进行学习。
我们先对HashMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用HashMap。内容包括：
第1部分 HashMap介绍
第2部分 HashMap数据结构
第3部分 HashMap源码解析(基于JDK1.6.0_45)
第3.1部分 HashMap的“拉链法”相关内容
第3.2部分 HashMap的构造函数
第3.3部分 HashMap的主要对外接口
第3.4部分 HashMap实现的Cloneable接口
第3.5部分 HashMap实现的Serializable接口
第4部分 HashMap遍历方式
第5部分 HashMap示例

转载请注明出处：http://www.cnblogs.com/skywang12345/p/3310835.html

第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个构造函数,如下：

  1. // 默认构造函数。
  2. HashMap()
  3.  
  4. // 指定“容量大小”的构造函数
  5. HashMap(int capacity)
  6.  
  7. // 指定“容量大小”和“加载因子”的构造函数
  8. HashMap(int capacity, float loadFactor)
  9.  
  10. // 包含“子Map”的构造函数
  11. HashMap(Map<? extends K, ? extends V> map)

HashMap的API

  1. void                 clear()
  2. Object               clone()
  3. boolean              containsKey(Object key)
  4. boolean              containsValue(Object value)
  5. Set<Entry<K, V>>     entrySet()
  6. V                    get(Object key)
  7. boolean              isEmpty()
  8. Set<K>               keySet()
  9. V                    put(K key, V value)
  10. void                 putAll(Map<? extends K, ? extends V> map)
  11. V                    remove(Object key)
  12. int                  size()
  13. Collection<V>        values()

第2部分 HashMap数据结构

HashMap的继承关系

  1. java.lang.Object
  2.    ↳     java.util.AbstractMap<K, V>
  3.          ↳     java.util.HashMap<K, V>
  4.  
  5. public class HashMap<K,V>
  6.     extends AbstractMap<K,V>
  7.     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.6.0_45)

为了更了解HashMap的原理，下面对HashMap源码代码作出分析。
在阅读源码时，建议参考后面的说明来建立对HashMap的整体认识，这样更容易理解HashMap。

  1.  package java.util;
  2.  import java.io.*;
  3.  
  4.  public class HashMap<K,V>
  5.      extends AbstractMap<K,V>
  6.      implements Map<K,V>, Cloneable, Serializable
  7.  {
  8.  
  9.      // 默认的初始容量是16，必须是2的幂。
  10.      static final int DEFAULT_INITIAL_CAPACITY = 16;
  11.  
  12.      // 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）
  13.      static final int MAXIMUM_CAPACITY = 1 << 30;
  14.  
  15.      // 默认加载因子
  16.      static final float DEFAULT_LOAD_FACTOR = 0.75f;
  17.  
  18.      // 存储数据的Entry数组，长度是2的幂。
  19.      // HashMap是采用拉链法实现的，每一个Entry本质上是一个单向链表
  20.      transient Entry[] table;
  21.  
  22.      // HashMap的大小，它是HashMap保存的键值对的数量
  23.      transient int size;
  24.  
  25.      // HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）
  26.      int threshold;
  27.  
  28.      // 加载因子实际大小
  29.      final float loadFactor;
  30.  
  31.      // HashMap被改变的次数
  32.      transient volatile int modCount;
  33.  
  34.      // 指定“容量大小”和“加载因子”的构造函数
  35.      public HashMap(int initialCapacity, float loadFactor) {
  36.          if (initialCapacity < 0)
  37.              throw new IllegalArgumentException("Illegal initial capacity: " +
  38.                                                 initialCapacity);
  39.          // HashMap的最大容量只能是MAXIMUM_CAPACITY
  40.          if (initialCapacity > MAXIMUM_CAPACITY)
  41.              initialCapacity = MAXIMUM_CAPACITY;
  42.          if (loadFactor <= 0 || Float.isNaN(loadFactor))
  43.              throw new IllegalArgumentException("Illegal load factor: " +
  44.                                                 loadFactor);
  45.  
  46.          // 找出“大于initialCapacity”的最小的2的幂
  47.          int capacity = 1;
  48.          while (capacity < initialCapacity)
  49.              capacity <<= 1;
  50.  
  51.          // 设置“加载因子”
  52.          this.loadFactor = loadFactor;
  53.          // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
  54.          threshold = (int)(capacity * loadFactor);
  55.          // 创建Entry数组，用来保存数据
  56.          table = new Entry[capacity];
  57.          init();
  58.      }
  59.  
  60.      // 指定“容量大小”的构造函数
  61.      public HashMap(int initialCapacity) {
  62.          this(initialCapacity, DEFAULT_LOAD_FACTOR);
  63.      }
  64.  
  65.      // 默认构造函数。
  66.      public HashMap() {
  67.          // 设置“加载因子”
  68.          this.loadFactor = DEFAULT_LOAD_FACTOR;
  69.          // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
  70.          threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
  71.          // 创建Entry数组，用来保存数据
  72.          table = new Entry[DEFAULT_INITIAL_CAPACITY];
  73.          init();
  74.      }
  75.  
  76.      // 包含“子Map”的构造函数
  77.      public HashMap(Map<? extends K, ? extends V> m) {
  78.          this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
  79.                        DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
  80.          // 将m中的全部元素逐个添加到HashMap中
  81.          putAllForCreate(m);
  82.      }
  83.  
  84.      static int hash(int h) {
  85.          h ^= (h >>> 20) ^ (h >>> 12);
  86.          return h ^ (h >>> 7) ^ (h >>> 4);
  87.      }
  88.  
  89.      // 返回索引值
  90.      // h & (length-1)保证返回值的小于length
  91.      static int indexFor(int h, int length) {
  92.          return h & (length-1);
  93.      }
  94.  
  95.      public int size() {
  96.          return size;
  97.      }
  98.  
  99.      public boolean isEmpty() {
  100.          return size == 0;
  101.      }
  102.  
  103.      // 获取key对应的value
  104.      public V get(Object key) {
  105.          if (key == null)
  106.              return getForNullKey();
  107.          // 获取key的hash值
  108.          int hash = hash(key.hashCode());
  109.          // 在“该hash值对应的链表”上查找“键值等于key”的元素
  110.          for (Entry<K,V> e = table[indexFor(hash, table.length)];
  111.               e != null;
  112.               e = e.next) {
  113.              Object k;
  114.              if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
  115.                  return e.value;
  116.          }
  117.          return null;
  118.      }
  119.  
  120.      // 获取“key为null”的元素的值
  121.      // HashMap将“key为null”的元素存储在table[0]位置！
  122.      private V getForNullKey() {
  123.          for (Entry<K,V> e = table[0]; e != null; e = e.next) {
  124.              if (e.key == null)
  125.                  return e.value;
  126.          }
  127.          return null;
  128.      }
  129.  
  130.      // HashMap是否包含key
  131.      public boolean containsKey(Object key) {
  132.          return getEntry(key) != null;
  133.      }
  134.  
  135.      // 返回“键为key”的键值对
  136.      final Entry<K,V> getEntry(Object key) {
  137.          // 获取哈希值
  138.          // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值
  139.          int hash = (key == null) ? 0 : hash(key.hashCode());
  140.          // 在“该hash值对应的链表”上查找“键值等于key”的元素
  141.          for (Entry<K,V> e = table[indexFor(hash, table.length)];
  142.               e != null;
  143.               e = e.next) {
  144.              Object k;
  145.              if (e.hash == hash &&
  146.                  ((k = e.key) == key || (key != null && key.equals(k))))
  147.                  return e;
  148.          }
  149.          return null;
  150.      }
  151.  
  152.      // 将“key-value”添加到HashMap中
  153.      public V put(K key, V value) {
  154.          // 若“key为null”，则将该键值对添加到table[0]中。
  155.          if (key == null)
  156.              return putForNullKey(value);
  157.          // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
  158.          int hash = hash(key.hashCode());
  159.          int i = indexFor(hash, table.length);
  160.          for (Entry<K,V> e = table[i]; e != null; e = e.next) {
  161.              Object k;
  162.              // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
  163.              if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
  164.                  V oldValue = e.value;
  165.                  e.value = value;
  166.                  e.recordAccess(this);
  167.                  return oldValue;
  168.              }
  169.          }
  170.  
  171.          // 若“该key”对应的键值对不存在，则将“key-value”添加到table中
  172.          modCount++;
  173.          addEntry(hash, key, value, i);
  174.          return null;
  175.      }
  176.  
  177.      // putForNullKey()的作用是将“key为null”键值对添加到table[0]位置
  178.      private V putForNullKey(V value) {
  179.          for (Entry<K,V> e = table[0]; e != null; e = e.next) {
  180.              if (e.key == null) {
  181.                  V oldValue = e.value;
  182.                  e.value = value;
  183.                  e.recordAccess(this);
  184.                  return oldValue;
  185.              }
  186.          }
  187.          // 这里的完全不会被执行到!
  188.          modCount++;
  189.          addEntry(0, null, value, 0);
  190.          return null;
  191.      }
  192.  
  193.      // 创建HashMap对应的“添加方法”，
  194.      // 它和put()不同。putForCreate()是内部方法，它被构造函数等调用，用来创建HashMap
  195.      // 而put()是对外提供的往HashMap中添加元素的方法。
  196.      private void putForCreate(K key, V value) {
  197.          int hash = (key == null) ? 0 : hash(key.hashCode());
  198.          int i = indexFor(hash, table.length);
  199.  
  200.          // 若该HashMap表中存在“键值等于key”的元素，则替换该元素的value值
  201.          for (Entry<K,V> e = table[i]; e != null; e = e.next) {
  202.              Object k;
  203.              if (e.hash == hash &&
  204.                  ((k = e.key) == key || (key != null && key.equals(k)))) {
  205.                  e.value = value;
  206.                  return;
  207.              }
  208.          }
  209.  
  210.          // 若该HashMap表中不存在“键值等于key”的元素，则将该key-value添加到HashMap中
  211.          createEntry(hash, key, value, i);
  212.      }
  213.  
  214.      // 将“m”中的全部元素都添加到HashMap中。
  215.      // 该方法被内部的构造HashMap的方法所调用。
  216.      private void putAllForCreate(Map<? extends K, ? extends V> m) {
  217.          // 利用迭代器将元素逐个添加到HashMap中
  218.          for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
  219.              Map.Entry<? extends K, ? extends V> e = i.next();
  220.              putForCreate(e.getKey(), e.getValue());
  221.          }
  222.      }
  223.  
  224.      // 重新调整HashMap的大小，newCapacity是调整后的单位
  225.      void resize(int newCapacity) {
  226.          Entry[] oldTable = table;
  227.          int oldCapacity = oldTable.length;
  228.          if (oldCapacity == MAXIMUM_CAPACITY) {
  229.              threshold = Integer.MAX_VALUE;
  230.              return;
  231.          }
  232.  
  233.          // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，
  234.          // 然后，将“新HashMap”赋值给“旧HashMap”。
  235.          Entry[] newTable = new Entry[newCapacity];
  236.          transfer(newTable);
  237.          table = newTable;
  238.          threshold = (int)(newCapacity * loadFactor);
  239.      }
  240.  
  241.      // 将HashMap中的全部元素都添加到newTable中
  242.      void transfer(Entry[] newTable) {
  243.          Entry[] src = table;
  244.          int newCapacity = newTable.length;
  245.          for (int j = 0; j < src.length; j++) {
  246.              Entry<K,V> e = src[j];
  247.              if (e != null) {
  248.                  src[j] = null;
  249.                  do {
  250.                      Entry<K,V> next = e.next;
  251.                      int i = indexFor(e.hash, newCapacity);
  252.                      e.next = newTable[i];
  253.                      newTable[i] = e;
  254.                      e = next;
  255.                  } while (e != null);
  256.              }
  257.          }
  258.      }
  259.  
  260.      // 将"m"的全部元素都添加到HashMap中
  261.      public void putAll(Map<? extends K, ? extends V> m) {
  262.          // 有效性判断
  263.          int numKeysToBeAdded = m.size();
  264.          if (numKeysToBeAdded == 0)
  265.              return;
  266.  
  267.          // 计算容量是否足够，
  268.          // 若“当前实际容量 < 需要的容量”，则将容量x2。
  269.          if (numKeysToBeAdded > threshold) {
  270.              int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
  271.              if (targetCapacity > MAXIMUM_CAPACITY)
  272.                  targetCapacity = MAXIMUM_CAPACITY;
  273.              int newCapacity = table.length;
  274.              while (newCapacity < targetCapacity)
  275.                  newCapacity <<= 1;
  276.              if (newCapacity > table.length)
  277.                  resize(newCapacity);
  278.          }
  279.  
  280.          // 通过迭代器，将“m”中的元素逐个添加到HashMap中。
  281.          for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
  282.              Map.Entry<? extends K, ? extends V> e = i.next();
  283.              put(e.getKey(), e.getValue());
  284.          }
  285.      }
  286.  
  287.      // 删除“键为key”元素
  288.      public V remove(Object key) {
  289.          Entry<K,V> e = removeEntryForKey(key);
  290.          return (e == null ? null : e.value);
  291.      }
  292.  
  293.      // 删除“键为key”的元素
  294.      final Entry<K,V> removeEntryForKey(Object key) {
  295.          // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算
  296.          int hash = (key == null) ? 0 : hash(key.hashCode());
  297.          int i = indexFor(hash, table.length);
  298.          Entry<K,V> prev = table[i];
  299.          Entry<K,V> e = prev;
  300.  
  301.          // 删除链表中“键为key”的元素
  302.          // 本质是“删除单向链表中的节点”
  303.          while (e != null) {
  304.              Entry<K,V> next = e.next;
  305.              Object k;
  306.              if (e.hash == hash &&
  307.                  ((k = e.key) == key || (key != null && key.equals(k)))) {
  308.                  modCount++;
  309.                  size--;
  310.                  if (prev == e)
  311.                      table[i] = next;
  312.                  else
  313.                      prev.next = next;
  314.                  e.recordRemoval(this);
  315.                  return e;
  316.              }
  317.              prev = e;
  318.              e = next;
  319.          }
  320.  
  321.          return e;
  322.      }
  323.  
  324.      // 删除“键值对”
  325.      final Entry<K,V> removeMapping(Object o) {
  326.          if (!(o instanceof Map.Entry))
  327.              return null;
  328.  
  329.          Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
  330.          Object key = entry.getKey();
  331.          int hash = (key == null) ? 0 : hash(key.hashCode());
  332.          int i = indexFor(hash, table.length);
  333.          Entry<K,V> prev = table[i];
  334.          Entry<K,V> e = prev;
  335.  
  336.          // 删除链表中的“键值对e”
  337.          // 本质是“删除单向链表中的节点”
  338.          while (e != null) {
  339.              Entry<K,V> next = e.next;
  340.              if (e.hash == hash && e.equals(entry)) {
  341.                  modCount++;
  342.                  size--;
  343.                  if (prev == e)
  344.                      table[i] = next;
  345.                  else
  346.                      prev.next = next;
  347.                  e.recordRemoval(this);
  348.                  return e;
  349.              }
  350.              prev = e;
  351.              e = next;
  352.          }
  353.  
  354.          return e;
  355.      }
  356.  
  357.      // 清空HashMap，将所有的元素设为null
  358.      public void clear() {
  359.          modCount++;
  360.          Entry[] tab = table;
  361.          for (int i = 0; i < tab.length; i++)
  362.              tab[i] = null;
  363.          size = 0;
  364.      }
  365.  
  366.      // 是否包含“值为value”的元素
  367.      public boolean containsValue(Object value) {
  368.      // 若“value为null”，则调用containsNullValue()查找
  369.      if (value == null)
  370.              return containsNullValue();
  371.  
  372.      // 若“value不为null”，则查找HashMap中是否有值为value的节点。
  373.      Entry[] tab = table;
  374.          for (int i = 0; i < tab.length ; i++)
  375.              for (Entry e = tab[i] ; e != null ; e = e.next)
  376.                  if (value.equals(e.value))
  377.                      return true;
  378.      return false;
  379.      }
  380.  
  381.      // 是否包含null值
  382.      private boolean containsNullValue() {
  383.      Entry[] tab = table;
  384.          for (int i = 0; i < tab.length ; i++)
  385.              for (Entry e = tab[i] ; e != null ; e = e.next)
  386.                  if (e.value == null)
  387.                      return true;
  388.      return false;
  389.      }
  390.  
  391.      // 克隆一个HashMap，并返回Object对象
  392.      public Object clone() {
  393.          HashMap<K,V> result = null;
  394.          try {
  395.              result = (HashMap<K,V>)super.clone();
  396.          } catch (CloneNotSupportedException e) {
  397.              // assert false;
  398.          }
  399.          result.table = new Entry[table.length];
  400.          result.entrySet = null;
  401.          result.modCount = 0;
  402.          result.size = 0;
  403.          result.init();
  404.          // 调用putAllForCreate()将全部元素添加到HashMap中
  405.          result.putAllForCreate(this);
  406.  
  407.          return result;
  408.      }
  409.  
  410.      // Entry是单向链表。
  411.      // 它是 “HashMap链式存储法”对应的链表。
  412.      // 它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数
  413.      static class Entry<K,V> implements Map.Entry<K,V> {
  414.          final K key;
  415.          V value;
  416.          // 指向下一个节点
  417.          Entry<K,V> next;
  418.          final int hash;
  419.  
  420.          // 构造函数。
  421.          // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
  422.          Entry(int h, K k, V v, Entry<K,V> n) {
  423.              value = v;
  424.              next = n;
  425.              key = k;
  426.              hash = h;
  427.          }
  428.  
  429.          public final K getKey() {
  430.              return key;
  431.          }
  432.  
  433.          public final V getValue() {
  434.              return value;
  435.          }
  436.  
  437.          public final V setValue(V newValue) {
  438.              V oldValue = value;
  439.              value = newValue;
  440.              return oldValue;
  441.          }
  442.  
  443.          // 判断两个Entry是否相等
  444.          // 若两个Entry的“key”和“value”都相等，则返回true。
  445.          // 否则，返回false
  446.          public final boolean equals(Object o) {
  447.              if (!(o instanceof Map.Entry))
  448.                  return false;
  449.              Map.Entry e = (Map.Entry)o;
  450.              Object k1 = getKey();
  451.              Object k2 = e.getKey();
  452.              if (k1 == k2 || (k1 != null && k1.equals(k2))) {
  453.                  Object v1 = getValue();
  454.                  Object v2 = e.getValue();
  455.                  if (v1 == v2 || (v1 != null && v1.equals(v2)))
  456.                      return true;
  457.              }
  458.              return false;
  459.          }
  460.  
  461.          // 实现hashCode()
  462.          public final int hashCode() {
  463.              return (key==null   ? 0 : key.hashCode()) ^
  464.                     (value==null ? 0 : value.hashCode());
  465.          }
  466.  
  467.          public final String toString() {
  468.              return getKey() + "=" + getValue();
  469.          }
  470.  
  471.          // 当向HashMap中添加元素时，绘调用recordAccess()。
  472.          // 这里不做任何处理
  473.          void recordAccess(HashMap<K,V> m) {
  474.          }
  475.  
  476.          // 当从HashMap中删除元素时，绘调用recordRemoval()。
  477.          // 这里不做任何处理
  478.          void recordRemoval(HashMap<K,V> m) {
  479.          }
  480.      }
  481.  
  482.      // 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。
  483.      void addEntry(int hash, K key, V value, int bucketIndex) {
  484.          // 保存“bucketIndex”位置的值到“e”中
  485.          Entry<K,V> e = table[bucketIndex];
  486.          // 设置“bucketIndex”位置的元素为“新Entry”，
  487.          // 设置“e”为“新Entry的下一个节点”
  488.          table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
  489.          // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小
  490.          if (size++ >= threshold)
  491.              resize(2 * table.length);
  492.      }
  493.  
  494.      // 创建Entry。将“key-value”插入指定位置，bucketIndex是位置索引。
  495.      // 它和addEntry的区别是：
  496.      // (01) addEntry()一般用在 新增Entry可能导致“HashMap的实际容量”超过“阈值”的情况下。
  497.      //   例如，我们新建一个HashMap，然后不断通过put()向HashMap中添加元素；
  498.      // put()是通过addEntry()新增Entry的。
  499.      //   在这种情况下，我们不知道何时“HashMap的实际容量”会超过“阈值”；
  500.      //   因此，需要调用addEntry()
  501.      // (02) createEntry() 一般用在 新增Entry不会导致“HashMap的实际容量”超过“阈值”的情况下。
  502.      //   例如，我们调用HashMap“带有Map”的构造函数，它绘将Map的全部元素添加到HashMap中；
  503.      // 但在添加之前，我们已经计算好“HashMap的容量和阈值”。也就是，可以确定“即使将Map中
  504.      // 的全部元素添加到HashMap中，都不会超过HashMap的阈值”。
  505.      //   此时，调用createEntry()即可。
  506.      void createEntry(int hash, K key, V value, int bucketIndex) {
  507.          // 保存“bucketIndex”位置的值到“e”中
  508.          Entry<K,V> e = table[bucketIndex];
  509.          // 设置“bucketIndex”位置的元素为“新Entry”，
  510.          // 设置“e”为“新Entry的下一个节点”
  511.          table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
  512.          size++;
  513.      }
  514.  
  515.      // HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。
  516.      // 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。
  517.      private abstract class HashIterator<E> implements Iterator<E> {
  518.          // 下一个元素
  519.          Entry<K,V> next;
  520.          // expectedModCount用于实现fast-fail机制。
  521.          int expectedModCount;
  522.          // 当前索引
  523.          int index;
  524.          // 当前元素
  525.          Entry<K,V> current;
  526.  
  527.          HashIterator() {
  528.              expectedModCount = modCount;
  529.              if (size > 0) { // advance to first entry
  530.                  Entry[] t = table;
  531.                  // 将next指向table中第一个不为null的元素。
  532.                  // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。
  533.                  while (index < t.length && (next = t[index++]) == null)
  534.                      ;
  535.              }
  536.          }
  537.  
  538.          public final boolean hasNext() {
  539.              return next != null;
  540.          }
  541.  
  542.          // 获取下一个元素
  543.          final Entry<K,V> nextEntry() {
  544.              if (modCount != expectedModCount)
  545.                  throw new ConcurrentModificationException();
  546.              Entry<K,V> e = next;
  547.              if (e == null)
  548.                  throw new NoSuchElementException();
  549.  
  550.              // 注意！！！
  551.              // 一个Entry就是一个单向链表
  552.              // 若该Entry的下一个节点不为空，就将next指向下一个节点;
  553.              // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。
  554.              if ((next = e.next) == null) {
  555.                  Entry[] t = table;
  556.                  while (index < t.length && (next = t[index++]) == null)
  557.                      ;
  558.              }
  559.              current = e;
  560.              return e;
  561.          }
  562.  
  563.          // 删除当前元素
  564.          public void remove() {
  565.              if (current == null)
  566.                  throw new IllegalStateException();
  567.              if (modCount != expectedModCount)
  568.                  throw new ConcurrentModificationException();
  569.              Object k = current.key;
  570.              current = null;
  571.              HashMap.this.removeEntryForKey(k);
  572.              expectedModCount = modCount;
  573.          }
  574.  
  575.      }
  576.  
  577.      // value的迭代器
  578.      private final class ValueIterator extends HashIterator<V> {
  579.          public V next() {
  580.              return nextEntry().value;
  581.          }
  582.      }
  583.  
  584.      // key的迭代器
  585.      private final class KeyIterator extends HashIterator<K> {
  586.          public K next() {
  587.              return nextEntry().getKey();
  588.          }
  589.      }
  590.  
  591.      // Entry的迭代器
  592.      private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
  593.          public Map.Entry<K,V> next() {
  594.              return nextEntry();
  595.          }
  596.      }
  597.  
  598.      // 返回一个“key迭代器”
  599.      Iterator<K> newKeyIterator()   {
  600.          return new KeyIterator();
  601.      }
  602.      // 返回一个“value迭代器”
  603.      Iterator<V> newValueIterator()   {
  604.          return new ValueIterator();
  605.      }
  606.      // 返回一个“entry迭代器”
  607.      Iterator<Map.Entry<K,V>> newEntryIterator()   {
  608.          return new EntryIterator();
  609.      }
  610.  
  611.      // HashMap的Entry对应的集合
  612.      private transient Set<Map.Entry<K,V>> entrySet = null;
  613.  
  614.      // 返回“key的集合”，实际上返回一个“KeySet对象”
  615.      public Set<K> keySet() {
  616.          Set<K> ks = keySet;
  617.          return (ks != null ? ks : (keySet = new KeySet()));
  618.      }
  619.  
  620.      // Key对应的集合
  621.      // KeySet继承于AbstractSet，说明该集合中没有重复的Key。
  622.      private final class KeySet extends AbstractSet<K> {
  623.          public Iterator<K> iterator() {
  624.              return newKeyIterator();
  625.          }
  626.          public int size() {
  627.              return size;
  628.          }
  629.          public boolean contains(Object o) {
  630.              return containsKey(o);
  631.          }
  632.          public boolean remove(Object o) {
  633.              return HashMap.this.removeEntryForKey(o) != null;
  634.          }
  635.          public void clear() {
  636.              HashMap.this.clear();
  637.          }
  638.      }
  639.  
  640.      // 返回“value集合”，实际上返回的是一个Values对象
  641.      public Collection<V> values() {
  642.          Collection<V> vs = values;
  643.          return (vs != null ? vs : (values = new Values()));
  644.      }
  645.  
  646.      // “value集合”
  647.      // Values继承于AbstractCollection，不同于“KeySet继承于AbstractSet”，
  648.      // Values中的元素能够重复。因为不同的key可以指向相同的value。
  649.      private final class Values extends AbstractCollection<V> {
  650.          public Iterator<V> iterator() {
  651.              return newValueIterator();
  652.          }
  653.          public int size() {
  654.              return size;
  655.          }
  656.          public boolean contains(Object o) {
  657.              return containsValue(o);
  658.          }
  659.          public void clear() {
  660.              HashMap.this.clear();
  661.          }
  662.      }
  663.  
  664.      // 返回“HashMap的Entry集合”
  665.      public Set<Map.Entry<K,V>> entrySet() {
  666.          return entrySet0();
  667.      }
  668.  
  669.      // 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象
  670.      private Set<Map.Entry<K,V>> entrySet0() {
  671.          Set<Map.Entry<K,V>> es = entrySet;
  672.          return es != null ? es : (entrySet = new EntrySet());
  673.      }
  674.  
  675.      // EntrySet对应的集合
  676.      // EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。
  677.      private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
  678.          public Iterator<Map.Entry<K,V>> iterator() {
  679.              return newEntryIterator();
  680.          }
  681.          public boolean contains(Object o) {
  682.              if (!(o instanceof Map.Entry))
  683.                  return false;
  684.              Map.Entry<K,V> e = (Map.Entry<K,V>) o;
  685.              Entry<K,V> candidate = getEntry(e.getKey());
  686.              return candidate != null && candidate.equals(e);
  687.          }
  688.          public boolean remove(Object o) {
  689.              return removeMapping(o) != null;
  690.          }
  691.          public int size() {
  692.              return size;
  693.          }
  694.          public void clear() {
  695.              HashMap.this.clear();
  696.          }
  697.      }
  698.  
  699.      // java.io.Serializable的写入函数
  700.      // 将HashMap的“总的容量，实际容量，所有的Entry”都写入到输出流中
  701.      private void writeObject(java.io.ObjectOutputStream s)
  702.          throws IOException
  703.      {
  704.          Iterator<Map.Entry<K,V>> i =
  705.              (size > 0) ? entrySet0().iterator() : null;
  706.  
  707.          // Write out the threshold, loadfactor, and any hidden stuff
  708.          s.defaultWriteObject();
  709.  
  710.          // Write out number of buckets
  711.          s.writeInt(table.length);
  712.  
  713.          // Write out size (number of Mappings)
  714.          s.writeInt(size);
  715.  
  716.          // Write out keys and values (alternating)
  717.          if (i != null) {
  718.              while (i.hasNext()) {
  719.              Map.Entry<K,V> e = i.next();
  720.              s.writeObject(e.getKey());
  721.              s.writeObject(e.getValue());
  722.              }
  723.          }
  724.      }
  725.  
  726.      private static final long serialVersionUID = 362498820763181265L;
  727.  
  728.      // java.io.Serializable的读取函数：根据写入方式读出
  729.      // 将HashMap的“总的容量，实际容量，所有的Entry”依次读出
  730.      private void readObject(java.io.ObjectInputStream s)
  731.           throws IOException, ClassNotFoundException
  732.      {
  733.          // Read in the threshold, loadfactor, and any hidden stuff
  734.          s.defaultReadObject();
  735.  
  736.          // Read in number of buckets and allocate the bucket array;
  737.          int numBuckets = s.readInt();
  738.          table = new Entry[numBuckets];
  739.  
  740.          init();  // Give subclass a chance to do its thing.
  741.  
  742.          // Read in size (number of Mappings)
  743.          int size = s.readInt();
  744.  
  745.          // Read the keys and values, and put the mappings in the HashMap
  746.          for (int i=0; i<size; i++) {
  747.              K key = (K) s.readObject();
  748.              V value = (V) s.readObject();
  749.              putForCreate(key, value);
  750.          }
  751.      }
  752.  
  753.      // 返回“HashMap总的容量”
  754.      int   capacity()     { return table.length; }
  755.      // 返回“HashMap的加载因子”
  756.      float loadFactor()   { return loadFactor;   }
  757.  }

说明:

在详细介绍HashMap的代码之前，我们需要了解：HashMap就是一个散列表，它是通过“拉链法”解决哈希冲突的。
还需要再补充说明的一点是影响HashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

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

3.1.1 HashMap数据存储数组

  1. transient Entry[] table;

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

3.1.2 数据节点Entry的数据结构

  1.  static class Entry<K,V> implements Map.Entry<K,V> {
  2.      final K key;
  3.      V value;
  4.      // 指向下一个节点
  5.      Entry<K,V> next;
  6.      final int hash;
  7.  
  8.      // 构造函数。
  9.      // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
  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.      }
  16.  
  17.      public final K getKey() {
  18.          return key;
  19.      }
  20.  
  21.      public final V getValue() {
  22.          return value;
  23.      }
  24.  
  25.      public final V setValue(V newValue) {
  26.          V oldValue = value;
  27.          value = newValue;
  28.          return oldValue;
  29.      }
  30.  
  31.      // 判断两个Entry是否相等
  32.      // 若两个Entry的“key”和“value”都相等，则返回true。
  33.      // 否则，返回false
  34.      public final boolean equals(Object o) {
  35.          if (!(o instanceof Map.Entry))
  36.              return false;
  37.          Map.Entry e = (Map.Entry)o;
  38.          Object k1 = getKey();
  39.          Object k2 = e.getKey();
  40.          if (k1 == k2 || (k1 != null && k1.equals(k2))) {
  41.              Object v1 = getValue();
  42.              Object v2 = e.getValue();
  43.              if (v1 == v2 || (v1 != null && v1.equals(v2)))
  44.                  return true;
  45.          }
  46.          return false;
  47.      }
  48.  
  49.      // 实现hashCode()
  50.      public final int hashCode() {
  51.          return (key==null   ? 0 : key.hashCode()) ^
  52.                 (value==null ? 0 : value.hashCode());
  53.      }
  54.  
  55.      public final String toString() {
  56.          return getKey() + "=" + getValue();
  57.      }
  58.  
  59.      // 当向HashMap中添加元素时，绘调用recordAccess()。
  60.      // 这里不做任何处理
  61.      void recordAccess(HashMap<K,V> m) {
  62.      }
  63.  
  64.      // 当从HashMap中删除元素时，绘调用recordRemoval()。
  65.      // 这里不做任何处理
  66.      void recordRemoval(HashMap<K,V> m) {
  67.      }
  68.  }

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

第3.2部分 HashMap的构造函数

HashMap共包括4个构造函数

  1.  // 默认构造函数。
  2.  public HashMap() {
  3.      // 设置“加载因子”
  4.      this.loadFactor = DEFAULT_LOAD_FACTOR;
  5.      // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
  6.      threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
  7.      // 创建Entry数组，用来保存数据
  8.      table = new Entry[DEFAULT_INITIAL_CAPACITY];
  9.      init();
  10.  }
  11.  
  12.  // 指定“容量大小”和“加载因子”的构造函数
  13.  public HashMap(int initialCapacity, float loadFactor) {
  14.      if (initialCapacity < 0)
  15.          throw new IllegalArgumentException("Illegal initial capacity: " +
  16.                                             initialCapacity);
  17.      // HashMap的最大容量只能是MAXIMUM_CAPACITY
  18.      if (initialCapacity > MAXIMUM_CAPACITY)
  19.          initialCapacity = MAXIMUM_CAPACITY;
  20.      if (loadFactor <= 0 || Float.isNaN(loadFactor))
  21.          throw new IllegalArgumentException("Illegal load factor: " +
  22.                                             loadFactor);
  23.  
  24.      // Find a power of 2 >= initialCapacity
  25.      int capacity = 1;
  26.      while (capacity < initialCapacity)
  27.          capacity <<= 1;
  28.  
  29.      // 设置“加载因子”
  30.      this.loadFactor = loadFactor;
  31.      // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
  32.      threshold = (int)(capacity * loadFactor);
  33.      // 创建Entry数组，用来保存数据
  34.      table = new Entry[capacity];
  35.      init();
  36.  }
  37.  
  38.  // 指定“容量大小”的构造函数
  39.  public HashMap(int initialCapacity) {
  40.      this(initialCapacity, DEFAULT_LOAD_FACTOR);
  41.  }
  42.  
  43.  // 包含“子Map”的构造函数
  44.  public HashMap(Map<? extends K, ? extends V> m) {
  45.      this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
  46.                    DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
  47.      // 将m中的全部元素逐个添加到HashMap中
  48.      putAllForCreate(m);
  49.  }

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

3.3.1 clear()

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

  1.  public void clear() {
  2.      modCount++;
  3.      Entry[] tab = table;
  4.      for (int i = 0; i < tab.length; i++)
  5.          tab[i] = null;
  6.      size = 0;
  7.  }

3.3.2 containsKey()

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

  1. public boolean containsKey(Object key) {
  2.     return getEntry(key) != null;
  3. }

containsKey() 首先通过getEntry(key)获取key对应的Entry，然后判断该Entry是否为null。
getEntry()的源码如下：

  1.  final Entry<K,V> getEntry(Object key) {
  2.      // 获取哈希值
  3.      // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值
  4.      int hash = (key == null) ? 0 : hash(key.hashCode());
  5.      // 在“该hash值对应的链表”上查找“键值等于key”的元素
  6.      for (Entry<K,V> e = table[indexFor(hash, table.length)];
  7.           e != null;
  8.           e = e.next) {
  9.          Object k;
  10.          if (e.hash == hash &&
  11.              ((k = e.key) == key || (key != null && key.equals(k))))
  12.              return e;
  13.      }
  14.      return null;
  15.  }

getEntry() 的作用就是返回“键为key”的键值对，它的实现源码中已经进行了说明。
这里需要强调的是：HashMap将“key为null”的元素都放在table的位置0处，即table[0]中；“key不为null”的放在table的其余位置！

3.3.3 containsValue()

containsValue() 的作用是判断HashMap是否包含“值为value”的元素。

  1.  public boolean containsValue(Object value) {
  2.      // 若“value为null”，则调用containsNullValue()查找
  3.      if (value == null)
  4.          return containsNullValue();
  5.  
  6.      // 若“value不为null”，则查找HashMap中是否有值为value的节点。
  7.      Entry[] tab = table;
  8.      for (int i = 0; i < tab.length ; i++)
  9.          for (Entry e = tab[i] ; e != null ; e = e.next)
  10.              if (value.equals(e.value))
  11.                  return true;
  12.      return false;
  13.  }

从中，我们可以看出containsNullValue()分为两步进行处理：第一，若“value为null”，则调用containsNullValue()。第二，若“value不为null”，则查找HashMap中是否有值为value的节点。

containsNullValue() 的作用判断HashMap中是否包含“值为null”的元素。

  1.  private boolean containsNullValue() {
  2.      Entry[] tab = table;
  3.      for (int i = 0; i < tab.length ; i++)
  4.          for (Entry e = tab[i] ; e != null ; e = e.next)
  5.              if (e.value == null)
  6.                  return true;
  7.      return false;
  8.  }

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

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

  1.  // 返回“HashMap的Entry集合”
  2.  public Set<Map.Entry<K,V>> entrySet() {
  3.      return entrySet0();
  4.  }
  5.  
  6.  // 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象
  7.  private Set<Map.Entry<K,V>> entrySet0() {
  8.      Set<Map.Entry<K,V>> es = entrySet;
  9.      return es != null ? es : (entrySet = new EntrySet());
  10.  }
  11.  
  12.  // EntrySet对应的集合
  13.  // EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。
  14.  private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
  15.      public Iterator<Map.Entry<K,V>> iterator() {
  16.          return newEntryIterator();
  17.      }
  18.      public boolean contains(Object o) {
  19.          if (!(o instanceof Map.Entry))
  20.              return false;
  21.          Map.Entry<K,V> e = (Map.Entry<K,V>) o;
  22.          Entry<K,V> candidate = getEntry(e.getKey());
  23.          return candidate != null && candidate.equals(e);
  24.      }
  25.      public boolean remove(Object o) {
  26.          return removeMapping(o) != null;
  27.      }
  28.      public int size() {
  29.          return size;
  30.      }
  31.      public void clear() {
  32.          HashMap.this.clear();
  33.      }
  34.  }

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

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

  1.  // 返回一个“entry迭代器”
  2.  Iterator<Map.Entry<K,V>> newEntryIterator()   {
  3.      return new EntryIterator();
  4.  }
  5.  
  6.  // Entry的迭代器
  7.  private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
  8.      public Map.Entry<K,V> next() {
  9.          return nextEntry();
  10.      }
  11.  }
  12.  
  13.  // HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。
  14.  // 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。
  15.  private abstract class HashIterator<E> implements Iterator<E> {
  16.      // 下一个元素
  17.      Entry<K,V> next;
  18.      // expectedModCount用于实现fast-fail机制。
  19.      int expectedModCount;
  20.      // 当前索引
  21.      int index;
  22.      // 当前元素
  23.      Entry<K,V> current;
  24.  
  25.      HashIterator() {
  26.          expectedModCount = modCount;
  27.          if (size > 0) { // advance to first entry
  28.              Entry[] t = table;
  29.              // 将next指向table中第一个不为null的元素。
  30.              // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。
  31.              while (index < t.length && (next = t[index++]) == null)
  32.                  ;
  33.          }
  34.      }
  35.  
  36.      public final boolean hasNext() {
  37.          return next != null;
  38.      }
  39.  
  40.      // 获取下一个元素
  41.      final Entry<K,V> nextEntry() {
  42.          if (modCount != expectedModCount)
  43.              throw new ConcurrentModificationException();
  44.          Entry<K,V> e = next;
  45.          if (e == null)
  46.              throw new NoSuchElementException();
  47.  
  48.          // 注意！！！
  49.          // 一个Entry就是一个单向链表
  50.          // 若该Entry的下一个节点不为空，就将next指向下一个节点;
  51.          // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。
  52.          if ((next = e.next) == null) {
  53.              Entry[] t = table;
  54.              while (index < t.length && (next = t[index++]) == null)
  55.                  ;
  56.          }
  57.          current = e;
  58.          return e;
  59.      }
  60.  
  61.      // 删除当前元素
  62.      public void remove() {
  63.          if (current == null)
  64.              throw new IllegalStateException();
  65.          if (modCount != expectedModCount)
  66.              throw new ConcurrentModificationException();
  67.          Object k = current.key;
  68.          current = null;
  69.          HashMap.this.removeEntryForKey(k);
  70.          expectedModCount = modCount;
  71.      }
  72.  
  73.  }

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

3.3.5 get()

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

  1.  public V get(Object key) {
  2.      if (key == null)
  3.          return getForNullKey();
  4.      // 获取key的hash值
  5.      int hash = hash(key.hashCode());
  6.      // 在“该hash值对应的链表”上查找“键值等于key”的元素
  7.      for (Entry<K,V> e = table[indexFor(hash, table.length)];
  8.           e != null;
  9.           e = e.next) {
  10.          Object k;
  11.          if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
  12.              return e.value;
  13.      }
  14.      return null;
  15.  }

3.3.6 put()

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

  1.  public V put(K key, V value) {
  2.      // 若“key为null”，则将该键值对添加到table[0]中。
  3.      if (key == null)
  4.          return putForNullKey(value);
  5.      // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
  6.      int hash = hash(key.hashCode());
  7.      int i = indexFor(hash, table.length);
  8.      for (Entry<K,V> e = table[i]; e != null; e = e.next) {
  9.          Object k;
  10.          // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
  11.          if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
  12.              V oldValue = e.value;
  13.              e.value = value;
  14.              e.recordAccess(this);
  15.              return oldValue;
  16.          }
  17.      }
  18.  
  19.      // 若“该key”对应的键值对不存在，则将“key-value”添加到table中
  20.      modCount++;
  21.      addEntry(hash, key, value, i);
  22.      return null;
  23.  }

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

  1.  void addEntry(int hash, K key, V value, int bucketIndex) {
  2.      // 保存“bucketIndex”位置的值到“e”中
  3.      Entry<K,V> e = table[bucketIndex];
  4.      // 设置“bucketIndex”位置的元素为“新Entry”，
  5.      // 设置“e”为“新Entry的下一个节点”
  6.      table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
  7.      // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小
  8.      if (size++ >= threshold)
  9.          resize(2 * table.length);
  10.  }

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

说到addEntry()，就不得不说另一个函数createEntry()。createEntry()的代码如下：

  1.  void createEntry(int hash, K key, V value, int bucketIndex) {
  2.      // 保存“bucketIndex”位置的值到“e”中
  3.      Entry<K,V> e = table[bucketIndex];
  4.      // 设置“bucketIndex”位置的元素为“新Entry”，
  5.      // 设置“e”为“新Entry的下一个节点”
  6.      table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
  7.      size++;
  8.  }

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

  1. if (size++ >= threshold)
  2.     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中，它的代码如下：

  1.  public void putAll(Map<? extends K, ? extends V> m) {
  2.      // 有效性判断
  3.      int numKeysToBeAdded = m.size();
  4.      if (numKeysToBeAdded == 0)
  5.          return;
  6.  
  7.      // 计算容量是否足够，
  8.      // 若“当前实际容量 < 需要的容量”，则将容量x2。
  9.      if (numKeysToBeAdded > threshold) {
  10.          int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
  11.          if (targetCapacity > MAXIMUM_CAPACITY)
  12.              targetCapacity = MAXIMUM_CAPACITY;
  13.          int newCapacity = table.length;
  14.          while (newCapacity < targetCapacity)
  15.              newCapacity <<= 1;
  16.          if (newCapacity > table.length)
  17.              resize(newCapacity);
  18.      }
  19.  
  20.      // 通过迭代器，将“m”中的元素逐个添加到HashMap中。
  21.      for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
  22.          Map.Entry<? extends K, ? extends V> e = i.next();
  23.          put(e.getKey(), e.getValue());
  24.      }
  25.  }

3.3.8 remove()

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

  1.  public V remove(Object key) {
  2.      Entry<K,V> e = removeEntryForKey(key);
  3.      return (e == null ? null : e.value);
  4.  }
  5.  
  6.  // 删除“键为key”的元素
  7.  final Entry<K,V> removeEntryForKey(Object key) {
  8.      // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算
  9.      int hash = (key == null) ? 0 : hash(key.hashCode());
  10.      int i = indexFor(hash, table.length);
  11.      Entry<K,V> prev = table[i];
  12.      Entry<K,V> e = prev;
  13.  
  14.      // 删除链表中“键为key”的元素
  15.      // 本质是“删除单向链表中的节点”
  16.      while (e != null) {
  17.          Entry<K,V> next = e.next;
  18.          Object k;
  19.          if (e.hash == hash &&
  20.              ((k = e.key) == key || (key != null && key.equals(k)))) {
  21.              modCount++;
  22.              size--;
  23.              if (prev == e)
  24.                  table[i] = next;
  25.              else
  26.                  prev.next = next;
  27.              e.recordRemoval(this);
  28.              return e;
  29.          }
  30.          prev = e;
  31.          e = next;
  32.      }
  33.  
  34.      return e;
  35.  }

第3.4部分 HashMap实现的Cloneable接口

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

  1.  // 克隆一个HashMap，并返回Object对象
  2.  public Object clone() {
  3.      HashMap<K,V> result = null;
  4.      try {
  5.          result = (HashMap<K,V>)super.clone();
  6.      } catch (CloneNotSupportedException e) {
  7.          // assert false;
  8.      }
  9.      result.table = new Entry[table.length];
  10.      result.entrySet = null;
  11.      result.modCount = 0;
  12.      result.size = 0;
  13.      result.init();
  14.      // 调用putAllForCreate()将全部元素添加到HashMap中
  15.      result.putAllForCreate(this);
  16.  
  17.      return result;
  18.  }

第3.5部分 HashMap实现的Serializable接口

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

  1.  // java.io.Serializable的写入函数
  2.  // 将HashMap的“总的容量，实际容量，所有的Entry”都写入到输出流中
  3.  private void writeObject(java.io.ObjectOutputStream s)
  4.      throws IOException
  5.  {
  6.      Iterator<Map.Entry<K,V>> i =
  7.          (size > 0) ? entrySet0().iterator() : null;
  8.  
  9.      // Write out the threshold, loadfactor, and any hidden stuff
  10.      s.defaultWriteObject();
  11.  
  12.      // Write out number of buckets
  13.      s.writeInt(table.length);
  14.  
  15.      // Write out size (number of Mappings)
  16.      s.writeInt(size);
  17.  
  18.      // Write out keys and values (alternating)
  19.      if (i != null) {
  20.          while (i.hasNext()) {
  21.          Map.Entry<K,V> e = i.next();
  22.          s.writeObject(e.getKey());
  23.          s.writeObject(e.getValue());
  24.          }
  25.      }
  26.  }
  27.  
  28.  // java.io.Serializable的读取函数：根据写入方式读出
  29.  // 将HashMap的“总的容量，实际容量，所有的Entry”依次读出
  30.  private void readObject(java.io.ObjectInputStream s)
  31.       throws IOException, ClassNotFoundException
  32.  {
  33.      // Read in the threshold, loadfactor, and any hidden stuff
  34.      s.defaultReadObject();
  35.  
  36.      // Read in number of buckets and allocate the bucket array;
  37.      int numBuckets = s.readInt();
  38.      table = new Entry[numBuckets];
  39.  
  40.      init();  // Give subclass a chance to do its thing.
  41.  
  42.      // Read in size (number of Mappings)
  43.      int size = s.readInt();
  44.  
  45.      // Read the keys and values, and put the mappings in the HashMap
  46.      for (int i=0; i<size; i++) {
  47.          K key = (K) s.readObject();
  48.          V value = (V) s.readObject();
  49.          putForCreate(key, value);
  50.      }
  51.  }

第4部分 HashMap遍历方式

4.1 遍历HashMap的键值对

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

  1. // 假设map是HashMap对象
  2. // map中的key是String类型，value是Integer类型
  3. Integer integ = null;
  4. Iterator iter = map.entrySet().iterator();
  5. while(iter.hasNext()) {
  6.     Map.Entry entry = (Map.Entry)iter.next();
  7.     // 获取key
  8.     key = (String)entry.getKey();
  9.         // 获取value
  10.     integ = (Integer)entry.getValue();
  11. }

4.2 遍历HashMap的键

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

  1. // 假设map是HashMap对象
  2. // map中的key是String类型，value是Integer类型
  3. String key = null;
  4. Integer integ = null;
  5. Iterator iter = map.keySet().iterator();
  6. while (iter.hasNext()) {
  7.         // 获取key
  8.     key = (String)iter.next();
  9.         // 根据key，获取value
  10.     integ = (Integer)map.get(key);
  11. }

4.3 遍历HashMap的值

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

  1. // 假设map是HashMap对象
  2. // map中的key是String类型，value是Integer类型
  3. Integer value = null;
  4. Collection c = map.values();
  5. Iterator iter= c.iterator();
  6. while (iter.hasNext()) {
  7.     value = (Integer)iter.next();
  8. }

遍历测试程序如下：

  1.  import java.util.Map;
  2.  import java.util.Random;
  3.  import java.util.Iterator;
  4.  import java.util.HashMap;
  5.  import java.util.HashSet;
  6.  import java.util.Map.Entry;
  7.  import java.util.Collection;
  8.  
  9.  /*
  10.   * @desc 遍历HashMap的测试程序。
  11.   *   (01) 通过entrySet()去遍历key、value，参考实现函数：
  12.   *        iteratorHashMapByEntryset()
  13.   *   (02) 通过keySet()去遍历key、value，参考实现函数：
  14.   *        iteratorHashMapByKeyset()
  15.   *   (03) 通过values()去遍历value，参考实现函数：
  16.   *        iteratorHashMapJustValues()
  17.   *
  18.   * @author skywang
  19.   */
  20.  public class HashMapIteratorTest {
  21.  
  22.      public static void main(String[] args) {
  23.          int val = 0;
  24.          String key = null;
  25.          Integer value = null;
  26.          Random r = new Random();
  27.          HashMap map = new HashMap();
  28.  
  29.          for (int i=0; i<12; i++) {
  30.              // 随机获取一个[0,100)之间的数字
  31.              val = r.nextInt(100);
  32.  
  33.              key = String.valueOf(val);
  34.              value = r.nextInt(5);
  35.              // 添加到HashMap中
  36.              map.put(key, value);
  37.              System.out.println(" key:"+key+" value:"+value);
  38.          }
  39.          // 通过entrySet()遍历HashMap的key-value
  40.          iteratorHashMapByEntryset(map) ;
  41.  
  42.          // 通过keySet()遍历HashMap的key-value
  43.          iteratorHashMapByKeyset(map) ;
  44.  
  45.          // 单单遍历HashMap的value
  46.          iteratorHashMapJustValues(map);
  47.      }
  48.  
  49.      /*
  50.       * 通过entry set遍历HashMap
  51.       * 效率高!
  52.       */
  53.      private static void iteratorHashMapByEntryset(HashMap map) {
  54.          if (map == null)
  55.              return ;
  56.  
  57.          System.out.println("\niterator HashMap By entryset");
  58.          String key = null;
  59.          Integer integ = null;
  60.          Iterator iter = map.entrySet().iterator();
  61.          while(iter.hasNext()) {
  62.              Map.Entry entry = (Map.Entry)iter.next();
  63.  
  64.              key = (String)entry.getKey();
  65.              integ = (Integer)entry.getValue();
  66.              System.out.println(key+" -- "+integ.intValue());
  67.          }
  68.      }
  69.  
  70.      /*
  71.       * 通过keyset来遍历HashMap
  72.       * 效率低!
  73.       */
  74.      private static void iteratorHashMapByKeyset(HashMap map) {
  75.          if (map == null)
  76.              return ;
  77.  
  78.          System.out.println("\niterator HashMap By keyset");
  79.          String key = null;
  80.          Integer integ = null;
  81.          Iterator iter = map.keySet().iterator();
  82.          while (iter.hasNext()) {
  83.              key = (String)iter.next();
  84.              integ = (Integer)map.get(key);
  85.              System.out.println(key+" -- "+integ.intValue());
  86.          }
  87.      }
  88.  
  89.      /*
  90.       * 遍历HashMap的values
  91.       */
  92.      private static void iteratorHashMapJustValues(HashMap map) {
  93.          if (map == null)
  94.              return ;
  95.  
  96.          Collection c = map.values();
  97.          Iterator iter= c.iterator();
  98.          while (iter.hasNext()) {
  99.              System.out.println(iter.next());
  100.         }
  101.      }
  102.  }

第5部分 HashMap示例

下面通过一个实例学习如何使用HashMap

  1.  import java.util.Map;
  2.  import java.util.Random;
  3.  import java.util.Iterator;
  4.  import java.util.HashMap;
  5.  import java.util.HashSet;
  6.  import java.util.Map.Entry;
  7.  import java.util.Collection;
  8.  
  9.  /*
  10.   * @desc HashMap测试程序
  11.   *
  12.   * @author skywang
  13.   */
  14.  public class HashMapTest {
  15.  
  16.      public static void main(String[] args) {
  17.          testHashMapAPIs();
  18.      }
  19.  
  20.      private static void testHashMapAPIs() {
  21.          // 初始化随机种子
  22.          Random r = new Random();
  23.          // 新建HashMap
  24.          HashMap map = new HashMap();
  25.          // 添加操作
  26.          map.put("one", r.nextInt(10));
  27.          map.put("two", r.nextInt(10));
  28.          map.put("three", r.nextInt(10));
  29.  
  30.          // 打印出map
  31.          System.out.println("map:"+map );
  32.  
  33.          // 通过Iterator遍历key-value
  34.          Iterator iter = map.entrySet().iterator();
  35.          while(iter.hasNext()) {
  36.              Map.Entry entry = (Map.Entry)iter.next();
  37.              System.out.println("next : "+ entry.getKey() +" - "+entry.getValue());
  38.          }
  39.  
  40.          // HashMap的键值对个数
  41.          System.out.println("size:"+map.size());
  42.  
  43.          // containsKey(Object key) :是否包含键key
  44.          System.out.println("contains key two : "+map.containsKey("two"));
  45.          System.out.println("contains key five : "+map.containsKey("five"));
  46.  
  47.          // containsValue(Object value) :是否包含值value
  48.          System.out.println("contains value 0 : "+map.containsValue(new Integer(0)));
  49.  
  50.          // remove(Object key) ： 删除键key对应的键值对
  51.          map.remove("three");
  52.  
  53.          System.out.println("map:"+map );
  54.  
  55.          // clear() ： 清空HashMap
  56.          map.clear();
  57.  
  58.          // isEmpty() : HashMap是否为空
  59.          System.out.println((map.isEmpty()?"map is empty":"map is not empty") );
  60.      }
  61.  }

 (某一次)运行结果：

  1. map:{two=7, one=9, three=6}
  2. next : two - 7
  3. next : one - 9
  4. next : three - 6
  5. size:3
  6. contains key two : true
  7. contains key five : false
  8. contains value 0 : false
  9. map:{two=7, one=9}
  10. map is empty

更多内容

Java 集合系列目录

Java 集合系列01之 总体框架

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

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

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

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

Java 集合系列14之 Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)

Java 集合系列18之 Iterator和Enumeration比较

Java 集合系列10之 HashMap详细介绍(源码解析)和使用示例的更多相关文章

  1. 【转】Java 集合系列10之 HashMap详细介绍(源码解析)和使用示例

    概要 这一章,我们对HashMap进行学习.我们先对HashMap有个整体认识,然后再学习它的源码,最后再通过实例来学会使用HashMap.内容包括:第1部分 HashMap介绍第2部分 HashMa ...

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

    概要 前一章,我们学习了HashMap.这一章,我们对Hashtable进行学习.我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Hashtable.第1部分 Ha ...

  3. 【转】Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例

    概要 前一章,我们学习了HashMap.这一章,我们对Hashtable进行学习.我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Hashtable.第1部分 Ha ...

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

    概要  前面,我们已经学习了ArrayList,并了解了fail-fast机制.这一章我们接着学习List的实现类——LinkedList.和学习ArrayList一样,接下来呢,我们先对Linked ...

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

    概要 学完Vector了之后,接下来我们开始学习Stack.Stack很简单,它继承于Vector.学习方式还是和之前一样,先对Stack有个整体认识,然后再学习它的源码:最后再通过实例来学会使用它. ...

  6. 【转】 Java 集合系列07之 Stack详细介绍(源码解析)和使用示例

    概要 学完Vector了之后,接下来我们开始学习Stack.Stack很简单,它继承于Vector.学习方式还是和之前一样,先对Stack有个整体认识,然后再学习它的源码:最后再通过实例来学会使用它. ...

  7. Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例

    概要 这一章,我们对TreeMap进行学习.我们先对TreeMap有个整体认识,然后再学习它的源码,最后再通过实例来学会使用TreeMap.内容包括:第1部分 TreeMap介绍第2部分 TreeMa ...

  8. 【转】Java 集合系列16之 HashSet详细介绍(源码解析)和使用示例--不错

    原文网址:http://www.cnblogs.com/skywang12345/p/3311252.html 概要 这一章,我们对HashSet进行学习.我们先对HashSet有个整体认识,然后再学 ...

  9. 【转】Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例

    概要 这一章,我们对TreeMap进行学习.我们先对TreeMap有个整体认识,然后再学习它的源码,最后再通过实例来学会使用TreeMap.内容包括:第1部分 TreeMap介绍第2部分 TreeMa ...

随机推荐

  1. android SharedPreferences 轻量级存储！

    首先在当前进程也就是当前的项目里面进行存储 SharedPreferences.Editor editor = mContext.getSharedPreferences("tvplay&q ...

  2. 【代码笔记】iOS-点击任何处，出现城市

    一,效果图. 二,工程目录. 三,代码. //点击任何处,出现城市 -(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event { ...

  3. Android 中BaseActivty

    Base接口 IBaseActivity package liu.basedemo.base; /** * 基类接口 * Created by 刘楠 on 2016/7/28 0028.23:05 * ...

  4. iOS & Mac JSON To Model

    NSString * jsonPath=[[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:@"Cont ...

  5. Nutz中那些好用的工具类

    Nutz 是国产的精品开源框架,它全无依赖,只以1兆多的身材,就可以实现SSH全部功能的90%以上.内容主要涵盖了:Ioc.Aop.MVC.Dao.Json等WEB开发的方方面面.  它不仅轻巧,而且 ...

  6. 世道变了 – 你愿意成为微软认证Linux工程师吗？

     随笔世道变了 – 你愿意成为微软认证Linux工程师吗? 世道变了 – 你愿意成为微软认证Linux工程师吗?  leixu十二月 14, 2015随笔 2015年12月9日,微软发布了全新的MCS ...

  7. Sql Server之旅——第五站 确实不得不说的DBCC命令(文后附年会福利)

    今天研发中心办年会,晚上就是各自部门聚餐了,我个人喜欢喝干红,在干红中你可以体味到那种酸甜苦辣...人生何尝不是这样呢???正好 ceo从美国带了干红回来,然后我就顺道开心的过了把瘾....一个字.. ...

  8. 今天说一下 Group by 这个东西

    group by 这个关键字,这个语句太平凡了~基本上只要有报表的地方,就会有它的身影. 常规用法就是 INSERT INTO #TypeValue ( TypeID, Col2 ) , N , N ...

  9. SqlServer链接MySql操作步骤

    Sql Server版本 2008R2 1.从MySQL网站下载最新的MySQL ODBC驱动:http://www.mysql.com/downloads/connector/odbc/,我下载的版 ...

  10. MFC MDI 主框架和标签页数据互操作

    ==================================声明================================== 本文原创,转载在正文中显要的注明作者和出处,并保证文章的完 ...