标签：nsvalue 异或 基础上 直接 加载 表达 就会 方法体 final
"HashMap"由“hash”和“map"两个单词组成，这里的”map"表示“映射”而不是“地图”的意思，两个单词连起来就是“哈希映射表”。Map是一个接口，它有TreeSet 、LinkedHashMap、EnumMap、HashMap等实现类，其中HashMap无疑最重要也很复杂的一个实现类。理清楚了HashMap的原理，对其他的Map实现类也就触类旁通了，其他Map实现类大部分都相对简单.
哈希是一种算法也是一种数据结构。哈希算法能够根据给定的键key快速定位到对应的值value ,HashMap是利用哈希算法实现的一个数据结构。
散列表(Hash table，也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
HashMap内部常用到Object的"hashCode()"和"equal(Object)",要使用HashMap这种集合类型必须重写元素的这两个方法。
HashMap继承AbstractMap，实现了Map接口,Map接口中的”addAll()“ 、"containsAll()"等方法由父类AbstractMap实现。
静态内部类Node实现了Map.Entry接口(Map中的内部接口)，它用来保存一个键-值对，表示一个链表类型节点。而TreeNode扩展了Node，当哈希人冲突严重的时候，使用TreeNode保存健单个键-值对，表示一个二叉树节点。
内部类EntrySet表示HashMap中的entry集合，KeySet表示HashMap的所有Key集合，Values表示所有的value集合。
EntrySet 、KeySet 、Values均是成员内部类而不量静态内部类，这是因为这3个内部类均要直接访问外部部类HashMap的相关成员变量，它们必须与外部类HashMap相绑定。
Node表示包含一个键-值对基础的哈希节点。
Node类中有4个成员变量:
final int hash; final K key; V value; Node<K,V> next;
key value分别表示当前节点的键和值
next表示下个节点的引用（默认情况下使用链表处理哈希冲突，所以必须要有后继节点的引用）
hash表示将key进行哈希运算后的结果(使用HashMap的静态方法"hash（Object）"计算)，此属性非常重要，它决定当前节点放在哈希的哪个桶上。
TreeNode也表示包含一个键-值对基础的哈希节点，一个红黑树节点，由于它间接继承上面提到的Node,因此它也可以表示为一个单向链表节点。
当一个桶上的节点少于8个时，使用Node当作哈希节点，当一个桶上的节点多于8个时，即哈希冲突严重时，使用TreeNode。
TreeNode中有5个成员变量。
parent、left 、right 、prev分别表示父节点、左节点、右节点、前节点
red表示当前节点的红/黑点
TreeNode<K,V> parent; // red-black tree links TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red;
主要有这几个静态常量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; static final int MAXIMUM_CAPACITY = 1 << 30; static final float DEFAULT_LOAD_FACTOR = 0.75f; static final int TREEIFY_THRESHOLD = 8; static final int UNTREEIFY_THRESHOLD = 6; static final int MIN_TREEIFY_CAPACITY = 64;
DEFAULT_INITIAL_CAPACITY为映射表的最默认容量，值为16,无参构造方法使用这个容量。
MAXIMUM_CAPACITY为映射表的最大容量，一般情况下容量不会超过这个数。
DEFAULT_LOAD_FACTOR是默认的加载因子，无构造方法使用这个加载因子。
TREEIFY_THRESHOLD和UNTREEIFY_THRESHOLD分别是从链表转为红黑树和红黑树转为链表的单个桶节点个数阀值。一个桶上链表节点超8个就将其为红黑树，当一个桶上红黑树结点少于6个就将其转为链表。
MIN_TREEIFY_CAPACITY是从链表转为红黑树时所要求的tabel最小长度(只有同时满足TREEIFY_THRESHOLD和MIN_TREEIFY_CAPACITY时才能从链表转化为红黑树)。
成员变量
transient Node<K,V>[] table; transient Set<Map.Entry<K,V>> entrySet; transient int size; transient int modCount; int threshold; final float loadFactor;
table是Node类型的数组，表示哈希桶。其中的每个元素是一个单向链表或红黑树。
entrySet是HashMap的所有Entry的集合。
size表示键值对的个数。
modCount表示当前实例被修改（添加或删除键值对）的次数，这用来作为快速失败的参考依据。
loadFactor表示加载因子，元素个数与容量的比值的达到这个值，table将扩容。
threshold表示阀值，它是容量与加载因子的乘积，即threshold=loadFactor*capacity。当键值对的个数size大于它时，table将扩容。
构造方法
有一个无参构造方法，3个带参构造方法
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; this.threshold = tableSizeFor(initialCapacity); } public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
带参构造方法“HashMap(int , float )”，根据参考设写初始容量和加载因子。
带参构造方法“ HashMap(Map)”,将一个Map中的所有键值 对添加到新的HashMap中，并使用默认的加载因子。
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
put(K,V)方法先使用hash(O)方法，算出k对应的hash值，然后调用putVal（）方法进行实际的键值对插入。
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
根据位操作特点”（1或0）与0进行按位异或运算的结果是其本身“可看出，此处哈希算法的实质是，hashCode的高16位同样作为hash的高16位，将hashCode的高16位和其低16位的异或运算结果作为hash的低16位。
实际上putIfAbsent(K,V)也调用了putVal()方法，putVal是一个很重要也很复杂的一个方法。
putVal的核心逻辑：先根据hash确定当前键值应放入哈希表的哪个桶（这个桶是一个链表或红黑树），然后再此基础上再判断这个桶上是否存在当前键值对就存入的节点，若存在这样的节点，只需要将此节点的value属性更新为当前要添加的value.反之就要构建一个新的节点，并将此节点添加在这个桶上。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { //tab表示哈希桶数组，p表示当前键值对应存入的链表或红黑树(桶) // n表示table的长度，i表示数组tab的下标 Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) //table为空或没有元素时需要重新调整table的大小，否则无法容纳此时新添加的键值 n = (tab = resize()).length; /** * ”(n - 1) & hash“是当前键值对应该落入哈希桶的下标，这是个取余的表示式。 * 根据位运算的特点，只要n是2的幂次方，表达式"hash % n"与”(n - 1) & hash“等价 */ if ((p = tab[i = (n - 1) & hash]) == null) //此下标对应的链表或红黑树为空，将它初始化 tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k;//e表示当前键值对应存入的节点 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) //若链表的头节点（若是红黑树结构就是根节点）的key与当前要添加的键值对key的equals和hash均相同， //那么此链表的头节点就是当前键值要存入的节点 e = p; else if (p instanceof TreeNode) //若是红黑树结构就,调用单独的方法添加键值对 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //当前键值对应存入的节点在链表的非头节点位置， //需要在链表上从头到尾进行遍历，检查此链表上是否已存在key对应的节点。 // 若存在这样的节点，将此节点的value替换成要添加的即可 //若不存在这样的节点，需要构建一个新节点，将此节点添加在链表的尾部 for (int binCount = 0; ; ++binCount) {//binCount表示当前单向链表上的节点个数。 //e表示p的后继节点，在这里可以理解为：p表示e的前驱节点（单向链表不存在前驱节点的说法） if ((e = p.next) == null) { //已经遍历到尾部了，链表上没有这样的节点，必须构建一个新节点放在链表尾部 p.next = newNode(hash, key, value, null); // 这里需要TREEIFY_THRESHOLD，因为即将添加一个节点，在节点添加成功后，就会有TREEIFY_THRESHOLD个键值对 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st //达到阀值了，需要将链表转化为红黑树 treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break;//链表上存在key对应的的节点 p = e; } } if (e != null) { // existing mapping for key //链表上存在key对应的的节点 V oldValue = e.value;//保存原来的value,最后方法需要返回这个值 /** * HashMap.putIfAbsent方法只有map中不存在key对应节点将才添加键值对, * 调用当前putVal（）方法传入的onlyIfAbsent参数为true, * * 进入此处就表明map中已存在key对应的节点了（前面if条件中"e!=null"成立）， * 所以这里要在if条件中对onlyIfAbsent取反。 */ if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e);//空方法，留给子类LinkedHashMap等实现，进而读取有序的功能 return oldValue; } } //map中不存在key对应的节点，map会添加新节点，修改次数自增1 ++modCount; if (++size > threshold) //添加了新节点，键值对个数加1 //如果键值对个数超过阀值，需要重新调整table的容量。 resize(); afterNodeInsertion(evict);//空方法，留给子类LinkedHashMap等实现,进而实现添加（插入）有序的功能 return null; }
putVal（）逻辑详细分析：
1 .如果第1次添加键值对，table应该是null,resize()方法将对table分配内存扩容。
接下来分析下resize()方法如何扩容的：
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { //原容量过大，不能再扩容了，将阀值设为int类型的最大值，返回原table threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) //扩容（原容量的2倍）后小于MAXIMUM_CAPACITY 并且原容量大于默认初始化阀值， //阀值设为原来的2倍 newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold //原容量为0且原阀值大于0， newCap = oldThr; else { // zero initial threshold signifies using defaults //阀值为0，容量为0，使用默认的容量， newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//loadFactor*capacity } if (newThr == 0) { //新阀值为0时，需要重新调整阀值 float ft = (float)newCap * loadFactor; //loadFactor*capacity //为了使阀值不超出限定范围 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//重新分配数组大小 table = newTab; if (oldTab != null) { //将原数组oldTab的元素复制到新数组newTab中 for (int j = 0; j < oldCap; ++j) {//遍历原数组oldTab Node<K,V> e;//e用来保存原数组中每元素 if ((e = oldTab[j]) != null) { oldTab[j] = null;//将原数组的元素引用赋null，加快垃圾回收 if (e.next == null) //e的后继节点为null,e所表示的链表（或红黑树）上只有e这一个节点。 //可以直接算出此链表（或红黑树）e在新数组中应放置的下标，然后再将下标对应的元素赋值 newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode)//e是红黑树，单独处理 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order // e是单向链表，且链表上有多个节点时 Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; //(e.hash & oldCap)=0构造一条链表,小索引链表 // 此链表放在新table的j索引位置 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e;//loHead的引用只初始化一次，以后不再变化 else loTail.next = e; loTail = e; } //(e.hash & oldCap)!=0构造另一条链表，大索引链表 // 此链表放在新table的(j+oldCap)索引位置 else { if (hiTail == null) hiHead = e;//hiHead的引用只初始化一次，以后不再变化 else hiTail.next = e; hiTail = e; } } while ((e = next) != null);//后继节点为空，链表遍历已到尾 if (loTail != null) { //尾节点的后继节点赋为null,同时将小索引链表放置在数组的指定索引处 loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { //尾节点的后继节点赋为null,同时将大索引链表放置在数组的指定索引处 hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
resize()方法扩容时，新的容量是原容量的2倍，且原容量就是2的幂次方，也就是说HashMap的容量始终是2的幂次方。这主要是为了快速取余。只要n是2的幂次方，表达式"hash % n"与”(n - 1) & hash“等价，而位运算显然速度更快。
(2) 如果根据表达式“ (n - 1) & hash”算出键值对当前键值对应该存入哈希桶的下标，如果此哈希桶为null,就用newNode()方法将其初始化。
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) { return new Node<>(hash, key, value, next); }
(3)在找到哈希桶后，下一步就是确定当前键值对应该丰入哈希桶后的哪个节点位置。
此时有两种情况，一种是此桶上已经存这样的键了，另一种是此桶上不在这样的键的节点。若桶上存在这样的节点，就直接将该Node的value属性替换。若桶上不存在这样的节点，将构建一个新的Node节点，并添加在（此桶为链表结构时）链表的尾部。
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
get(Object)方法体内部，主要调用getNode(int,Object)方法找出key对应的Node节点，然后（这个node存在时）再取node节点的value属性
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; }
先确定key对应的Node节点应该在的哈希桶，再在这个哈希桶上遍历链表或红黑树，找到满足条件的key对应节点。若没有这个节点就返回空。
final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {//key对应的Node节点应在table的某个哈希桶。 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) //key对应的节点是哈希桶的头（根）节点，可以直接返回这个节点。 return first; if ((e = first.next) != null) { //key对应的节点在桶上的非头（根）节点位置，需要遍历链表（红黑树） if (first instanceof TreeNode)//桶的数据结构是红黑树时需要单独处理 return ((TreeNode<K,V>)first).getTreeNode(hash, key); do {//遍历链表查找 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }
”remove(Object)“与“remove(Object, Object)”方法均能将键值对（Entry节点）从哈希映射表中移除，且这两个方法都是委托”romveNode(int,Object,Object,boolean,boolean)“方法实现的，只不过后者“remove(Object, Object)”方法要在键与值均匹配的情况下才会移除键值对（Entry节点）。
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } public boolean remove(Object key, Object value) { return removeNode(hash(key), key, value, true, true) != null; }
先是根据hash找到table的索引，再遍历此索引位置元素所代表的链表（或红黑树）。尝试找到这个键值对对应的节点，判断是否找到的规则，依然是先比较hash再比较equals. 若找到这个节点，则将此节点的前后节点通过next属性链接起来。
final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; //start 与putVal方法前半部分逻辑几乎一致 if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { // p表示e的前驱节点 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } //end 与putVal方法前半部分逻辑几乎一致 if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { //存在这样的node节点，且未要求匹配value或在要求必须匹配value时value也刚好匹配 if (node instanceof TreeNode) //红黑树单独处理 ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) //要移除的node节点是链表的头节点时，将原头节点的后继节点设为新的头节点 tab[index] = node.next; else //要移除的node节点是非头节点时，使用next属性将node的前驱节点和后继节点直接链接在一起 p.next = node.next; ++modCount;//减少了一个节点，修改次数加1 --size;//键值对个数自减 afterNodeRemoval(node);//空方法，留给子类实现 return node; } } return null; }
Set表示的是无重复元素且不保证顺序的集合接口。HashMap基本特性之一是Key必须保证唯一、不重复，否则无法根据Key来定位Value,正是基于这一点，HashSet实际上是利用HashMap实现的，它的大部分方法都是直接委托相应的HashMap方法完成功能。
LinkedHashMap是HashMap的子类，它们保证键值对先后顺序，并且（使用构造方法相应的参数）支持选择使用访问访问或添加顺序，默认使用添加顺序。
构造方法：
其构造方法的逻辑也主要是调用父类HashMap的构造方法
public LinkedHashMap() { super(); accessOrder = false; } public LinkedHashMap(Map<? extends K, ? extends V> m) { super(); accessOrder = false; putMapEntries(m, false); } public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) { super(initialCapacity, loadFactor); this.accessOrder = accessOrder; } public boolean containsValue(Object value) { for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) { V v = e.value; if (v == value || (value != null && value.equals(v))) return true; } return false; }
成员变量
static class Entry<K,V> extends HashMap.Node<K,V> { Entry<K,V> before, after; Entry(int hash, K key, V value, Node<K,V> next) { super(hash, key, value, next); } } transient LinkedHashMap.Entry<K,V> head; transient LinkedHashMap.Entry<K,V> tail; final boolean accessOrder;
LinkedHashMap比HashMap多一条双向链表，用此链表来记录相应的顺序。
双向链表的类类型LinkedHashMap.Entry也是继承于父类HashMap中的静态内部类HashMap.Node<K,V>，只不过添加了before、after这两个表示前驱、后继节点的成员变量，将父类的单向链表变成了双向链表而已。
1）不论是添加键值对、删除键值对或获取键对应的值，其基本流程都是先确定算出Key的hash,再根据hash找到对应的table索引（即找到哈希桶），再确定节点应在哈希桶的哪个位置。
2）健的hash是随机的，这导致表达式“(n - 1) & hash”的结果是无规律可循的，因此HashMap的键值对是无序的。若要使用有序的HashMap，请使用其子类LinkedHashMap.
3) 哈希表table每次扩容后，键值对Entry所在的哈希桶的索引，可能不变，即就是原来的index ,也有可能变成（index+oldCap），且只有这两种可能的情况。
4）HashMap不是线程安全的，在并发场景建议使用ConcurrentHashMap。虽然Hashtable也是线程安全的，但它是直接在方法上使用synchronized，是利用阻塞式的锁保证线程安全的，其并发效率低。
标签：nsvalue 异或 基础上 直接 加载 表达 就会 方法体 final
原文地址：https://www.cnblogs.com/gocode/p/analysis-source-code-of-HashMap.html
