Java++：jdk1.7 HashMap 的get()和put() 源码
HashMap的概述：
基于哈希表的 Map 接口的实现。
此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。
迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。
所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。
HashMap 的实例有两个参数影响其性能：初始容量 和 加载因子。
容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。
加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。
当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
通常，默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。
加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。
在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。
如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。
如果很多映射关系要存储在 HashMap 实例中，则相对于按需执行自动的 rehash 操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。
注意：此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。
（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）
这一般通过对自然封装该映射的对象进行同步操作来完成。
如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。
最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示：
Map m = Collections.synchronizedMap(new HashMap(…));
由所有此类的“collection 视图方法”所返回的迭代器都是快速失败 的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。
因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时间发生任意不确定行为的风险。
注意：迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。
快速失败迭代器尽最大努力抛出 ConcurrentModificationException。
因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。
此类是 Java Collections Framework 的成员。
HashMap的桶（容量）：
// 默认的初始桶(容量)是16，每次扩容都是x2 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 // 最大容量为（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换） static final int MAXIMUM_CAPACITY = 1 << 30; // 默认加载因子为0.75, static final float DEFAULT_LOAD_FACTOR = 0.75f;
加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 resize 操作（即扩容）。
下面说下加载因子，如果加载因子越大，对空间的利用更充分，但是查找效率会降低（链表长度会越来越长）；如果加载因子太小，那么表中的数据将过于稀疏（很多空间还没用，就开始扩容了），对空间造成严重浪费。
如果我们在构造方法中不指定，则系统默认加载因子为0.75，这是一个比较理想的值，一般情况下我们是无需修改的。
另外，无论我们指定的容量为多少，构造方法都会将实际容量设为不小于指定容量的2的次方的一个数，且最大值不能超过2的30次方。
HashMap的key和value可以为null：
get（）：
// 获取key对应的value public V get(Object key) { if (key == null) //如果key为null,调用getForNullKey() return getForNullKey(); //key不为null,调用getEntry(key); Entry<K,V> entry = getEntry(key); return null == entry ? null : entry.getValue(); } //当key为null时,获取value private V getForNullKey() { if (size == 0) { return null;//链表为空,返回null } //链表不为空,将“key为null”的元素存储在table[0]位置，但不一定是该链表的第一个位置！ for (Entry<K,V> e = table[0]; e != null; e = e.next) { if (e.key == null) return e.value; } return null; } //key不为null,获取value final Entry<K,V> getEntry(Object key) { if (size == 0) {//判断链表中是否有值 //链表中没值,也就是没有value 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; //判断key是否相同 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e;//key相等,返回相应的value } return null;//链表中没有相应的key }
首先，如果key为null，则直接从哈希表的第一个位置table[0]对应的链表上查找。
记住，key为null的键值对永远都放在以table[0]为头结点的链表中，当然不一定是存放在头结点table[0]中。
如果key不为null，则先求的key的hash值，根据hash值找到在table中的索引，在该索引对应的单链表中查找是否有键值对的key与目标key相等，有就返回对应的value，没有则返回null。
put（）：
// 将“key-value”添加到HashMap中 public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null)// 若“key为null”，则将该键值对添加到table[0]中。 return putForNullKey(value); // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。 int hash = hash(key);//获取key的hash值 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))) { // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！ V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } // 若“key”对应的键值对不存在，则将“key-value”添加到table中 modCount++; //将key-value添加到table[i]处 addEntry(hash, key, value, i); return null; }
如果key为null，则将其添加到table[0]对应的链表中，putForNullKey的源码如下
// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置 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; } } // 如果没有存在key为null的键值对，则直接添加到table[0]处! modCount++; addEntry(0, null, value, 0); return null; }
如果key不为null，则同样先求出key的hash值，根据hash值得出在table中的索引，而后遍历对应的单链表，如果单链表中存在与目标key相等的键值对，
则将新的value覆盖旧的value，比将旧的value返回，如果找不到与目标key相等的键值对，或者该单链表为空，调用addEntry()方法将该键值对插入到改单链表的头结点位置（每次新插入的节点都是放在头结点的位置）.
如果key为null,调用putForNullKey(),直接去遍历table[0]Entry链表，寻找e.key==null的Entry或者没有找到遍历结束。
如果找到了e.key==null，就保存null值对应的原值oldValue，然后覆盖原值，并返回oldValue
如果在putForNullKey()中,在table[0]Entry链表中没有找到也会调用addEntry方法添加一个key为null的Entry。
下面是addEntry的源码：
void addEntry(int hash, K key, V value, int bucketIndex) { //先判断大小 if ((size >= threshold) && (null != table[bucketIndex])) { // 若HashMap的实际大小不小于 “阈值”，则调整HashMap的大小 resize(2 * table.length);//扩容,每次增长2倍 hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex);//新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。 } 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++;
注意这里new Entry<>()的构造方法，将key-value键值对赋给table[bucketIndex]，并将其next指向元素e，这便将key-value放到了头结点中，并将之前的头结点接在了它的后面。
该方法也说明，每次put键值对的时候，总是将新的该键值对放在table[bucketIndex]处（即头结点处）。
同时也要注意,这个方法首先会判断是否要扩容，当现在的HashMap中的Entry数大于等于扩容临界值（capacity*load factor）并且index对应的地方没有Entry就扩容.HashMap每次扩容的大小为2倍原容量，
默认容量为16，hashmap的capacity会一直是2的整数幂。
// 重新调整HashMap的大小，newCapacity是调整后的单位 void resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { //旧容量不小于最大容量(一般不会发生,反正我没遇到过) threshold = Integer.MAX_VALUE; return; } //一般扩容 // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中， // 然后，将“新HashMap”赋值给“旧HashMap”。 Entry[] newTable = new Entry[newCapacity]; transfer(newTable, initHashSeedAsNeeded(newCapacity)); table = newTable; threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); }
很明显，是新建了一个HashMap的底层数组，而后调用transfer方法，将就HashMap的全部元素添加到新的HashMap中（要重新计算元素在新的数组中的索引位置）。
transfer方法的源码如下：
// 将HashMap中的全部元素都添加到newTable中 void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) { Entry<K,V> next = e.next; if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; newTable[i] = e; e = next; } } }
遍历原表table ，从table[0]开始，e=table[0]，不为null就创建一个临时Entry next引用e.的下一个Entry，然后把e放到新表中，头插到table[i]中，i由indexFor方法决定i(h&newCapacity)，然后让e=next，继续遍历拷贝。
扩容之后继续插入要插入的Entry，这个时候就要重新hash了，因为旧表已经扩容了,若果key为nul任然是0。
然后进行真正的插入，调用 createEntry(hash, key, value, bucketIndex)，
下面是源码：
void createEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<>(hash, key, value, e); size++; } //进行头插，创建一个新的entry， Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; }
新的entry复制到table[bucketIndex]，并next引用原来的table[bucketIndex]，完成。
……..
仅仅只是HashMap的普通扩容,就这么麻烦,如果再加上线程安全,而加同步的话,那么效率可想而知.并且,HashMap在高并发场景下调用transfer方法，可能会出现环形链表，导致程序死循环。
