作为集合类的两大巨头，Map和Collection一样具有重要的作用，甚至在我们日常的编码中，Map可能用到的场景比list还要多。作为一种数据结构，map有以下特点：
Map<K,V>:Map是以KV形式存储数据的。K叫做关键字（keyword），V代表键值（Value）。map相比于list的最大又是map具有映射的功能。有时我们可能遇到以下的问题，比如说我要存储几个不同的对象在同一个结构中，通过list是很难实现的。即便能存入，在取值的时候也会有困难。但是如果通过kv的形式存储的话。我们可以为每一个对象定义一个特定的符号（keyword），存储入map的时候把这个特定的符号作为K值，这样取出数据的时候可以根据k值去取。尤其是在统计等功能的时候，map则显得更加便捷。
map具有多维度的扩展性，因为他和collection一样具有相同的扩展多维性。我们只需要将map的v值设置成其他的list，甚至是map，通过这样的方式，可以生成强大的数据结构。
map具有很多强大的方法，比如可以返回其键的set，他的值的collection，甚至可以返回其键值对的set，也可以通过foreach的方式对map进行遍历。下面我们针对其三个实现类做实际的详解
一、HashMap
HashMap顾名思义肯定适合哈希表密切相关的。我们针对HashMap的源码进行详细的解读
首先是HashMap的继承和实现类。hashmap继承自AbstractMap，实现了Map接口和Cloneable和Serializable接口。所以HashMap接受深拷贝和序列化。AbstractMap抽象类类似于AbstractList，是对Map接口的一些通用性方法的实现。HashMap接口的三个实现类都继承自抽象类，他们用于一些共用的方法。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable我们对AbstractMap进行了解，首先他是一个抽象类，众所周知，抽象类不能实例化，不能通过new关键字新建他对应的对象实例。但是AbstractMap却具有构造方法，方法是被protected方法所修饰。这样设计的意义在于，所有继承自他的子类都能访问这个构造方法。
protected AbstractMap() {
}通过结构图我们，必要重要的是keySet，values方法和其两个内部类
首先是keySet方法，类中有定义keySet，transient表示这个不参与序列化。keySet方法会返回一个keyword的set，源码表示，在第一次调用这个方法的时候，keySet是空，将会把entrySet的值进行遍历，取出其中的key值放到keySet中。而此后如果重复进行调用的话，都会返回同一个set。但是由于线程不是安全的，所以多个请求返回的seySet值可能不尽相同。
transient Set<K> keySet;
transient Collection<V> values;
public Set<K> keySet() {
Set<K> ks = keySet;
if (ks == null) {
ks = new AbstractSet<K>() {
public Iterator<K> iterator() {
return new Iterator<K>() {
private Iterator<Entry<K,V>> i = entrySet().iterator();
public boolean hasNext() {
return i.hasNext();
}
public K next() {
return i.next().getKey();
}
public void remove() {
i.remove();
}
};
}
public int size() {
return AbstractMap.this.size();
}
public boolean isEmpty() {
return AbstractMap.this.isEmpty();
}
public void clear() {
AbstractMap.this.clear();
}
public boolean contains(Object k) {
return AbstractMap.this.containsKey(k);
}
};
keySet = ks;
}
return ks;
}接下来是values方法，类比于keySet方法，values方法返回的是一个Collection。具体实现与keySet类似，同样是通过遍历entrySet来取得value值，并放入Collection之中。并且只有第一次调用会对其进行初始化，同样不是线程安全的
public Collection<V> values() {
Collection<V> vals = values;
if (vals == null) {
vals = new AbstractCollection<V>() {
public Iterator<V> iterator() {
return new Iterator<V>() {
private Iterator<Entry<K,V>> i = entrySet().iterator();
public boolean hasNext() {
return i.hasNext();
}
public V next() {
return i.next().getValue();
}
public void remove() {
i.remove();
}
};
}
public int size() {
return AbstractMap.this.size();
}
public boolean isEmpty() {
return AbstractMap.this.isEmpty();
}
public void clear() {
AbstractMap.this.clear();
}
public boolean contains(Object v) {
return AbstractMap.this.containsValue(v);
}
};
values = vals;
}
return vals;
}除此之外，我们对齐equals方法进行解析，分析其思路：
首先通过“==”判断，如果是指向同一地址的话确定是同一对象。然后判断o是否是map的一个实例。之后把o强转为泛型，判断o的size，如果size不同自然返回false。最后我们通过entrySet遍历本map，通过o的containsKey进行意义对照判断即可
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o;
if (m.size() != size())
return false;
try {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}AbstractMap具有两个内部类：SimpleEntry和SimpleImmutableEntry，二者的区别在于，一个是可以修改的，一个是不可修改的，源码如下，一旦视图修改SimpleImmutableEntry，将会抛出异常public V setValue(V value) {
throw new UnsupportedOperationException();
}
此外值得一提的是，SimpleEntry的setValue方法返回的是旧的数值
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}这两个Entry都实现了Entry<K,V>接口。主要是通过其存储的keyValue值转化成类似于Collection集合的结构以便于转换。也方便用于遍历时使用
接下来我们继续研究Hashmap的底层代码实现，我们将重点从以下几个方面进行研究：
- hashmap的数据结构实现
- hashmap的读取实现（冲突解决）
- hashmap的扩容机制
- hashmap的线程安全相关
1.hashmap的数据结构
hashmap又称为散列表，毫无疑问，他的实现是基于散列的。我们首先观察其构造方法。其可以通过构造方法设置其容量和最大容量尺度。最大容量尺度指的是扩容之前其容量能达到多满的程度。默认为0.75
hashmap有三种构造方法 无参构造 public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } 带容量参数的构造方法 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } 带容量和最大容量尺度 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); }接下来我们观察其6个成员变量；在这些成员变量中，我们需要清楚。transient 代表的不需要参与序列化，因为由于put和remove操作的频繁进行，这些值的变动十分频繁，故其不需要进行序列化。
Node类型的table transient Node<K,V>[] table; set类型的集合 transient Set<Map.Entry<K,V>> entrySet; 指的是hashmap的映射数量 transient int size; 指的是修改次数---用于后面校验多线程相关问题 transient int modCount; 扩容阀值 到达此值之后进行扩容，大小为capacity*loadFactor int threshold; 同上，只是该值为比例而已 final float loadFactor;接下来我们通过这些类的源码探讨这些类变量的结构是如何实现的，以及其作用是什么
首先是Node<K,V>,Node<KV>实现了Entry类，也是将map内的元素通过转化为结点返回。此内部类的成员变量包括K,V的值以及hash值，还有对应的next指针。hashCode方法返回hash值，此hash值表示对key和value的hash值进行按位异或运算。判断两个node相等，key和对应的value都要相同才行
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }接下来是hashmap自定义的entrySet。于之前讲解过的抽象map一致，如果entrySet只在第一次调用的时候进行初始化，之后无论怎么调用都返回同一个entrySet。这里我们主要讲解其foreach方法。
final class EntrySet extends AbstractSet<Map.Entry<K,V>> { public final int size() { return size; } public final void clear() { HashMap.this.clear(); } public final Iterator<Map.Entry<K,V>> iterator() { return new EntryIterator(); } public final boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<?,?> e = (Map.Entry<?,?>) o; Object key = e.getKey(); Node<K,V> candidate = getNode(hash(key), key); return candidate != null && candidate.equals(e); } public final boolean remove(Object o) { if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>) o; Object key = e.getKey(); Object value = e.getValue(); return removeNode(hash(key), key, value, true, true) != null; } return false; } public final Spliterator<Map.Entry<K,V>> spliterator() { return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super Map.Entry<K,V>> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e); } if (modCount != mc) throw new ConcurrentModificationException(); } } }之前我们提到过，entrSet只会在第一次调用的时候对其进行初始化，如果我们再次对其进行调用的话，其返回内容还将是之前初始化的内容。那么如果我们之前调用过一次entrySet，对其修改之后再次调用回是什么结果呢。按照我们之前的逻辑，似乎会返回和之前一样的entrySet对象，但是这样肯定是不合理的，也不符合逻辑。那么HashMap是如何维护entrySet的数据呢。
我们通过再次审阅源码，发现entrySet实际只是一个视图而已，其中并没有存储hashnmap的数据，实际上hashmap的数据是存储在table之中的，也就是之前我们看到的Node集合。比如如下代码，还是以遍历为例子 ，当我们调用iterator之时，EntrySet中是这样定义的
public final Iterator<Map.Entry<K,V>> iterator() { return new EntryIterator(); }会新建一个EntryIterator对象来进行遍历操作，EntryIterator对象继承自HashIterator，他的next方法实际是从HashIterator的nextNode方法，其中所定义的Nodet实际上就是我们之前提到了的Hashmap的类变量，Node数组。
final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> { public final Map.Entry<K,V> next() { return nextNode(); } } abstract class HashIterator { Node<K,V> next; // next entry to return Node<K,V> current; // current entry int expectedModCount; // for fast-fail int index; // current slot HashIterator() { expectedModCount = modCount; Node<K,V>[] t = table; current = next = null; index = 0; if (t != null && size > 0) { // advance to first entry do {} while (index < t.length && (next = t[index++]) == null); } } public final boolean hasNext() { return next != null; } final Node<K,V> nextNode() { Node<K,V>[] t; Node<K,V> e = next; if (modCount != expectedModCount) throw new ConcurrentModificationException(); if (e == null) throw new NoSuchElementException(); if ((next = (current = e).next) == null && (t = table) != null) { do {} while (index < t.length && (next = t[index++]) == null); } return e; } public final void remove() { Node<K,V> p = current; if (p == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); current = null; K key = p.key; removeNode(hash(key), key, null, false, false); expectedModCount = modCount; } }注意，dowhile操作的实际意义在于，更新当前的current，next的等类变量的值。
再如，实际上entrySet的remove和contains等操作都是对table的操作，故table才是真正存储数值的地方
我们再看hashmap的put，remove等操作
put操作实际上也是对table的操作，下面是具体详读。这里涉及了如何解决hash冲突，大体思路是根据hash值和数组长度-1做与运算找到对应的数组位置，如果发生hash冲突，则将该处的链表向后顺延，如果找到空的，则把需要插入的数值插入到该结点，如果是找到key值相同的话则进行值的更新，并返回原来的值。这种情况不会增加修改次数和size。如果是空的插入的情况，需要考虑插入后的扩容问题
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; 如果之前的map的table是空，会进行扩容操作 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; 这里存储的操作的逻辑是把hash值和数组容量-1按位进行与操作，得到的位置如果没有值的话，把 put进的元素存储在这个位置 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); 否则解决hash冲突 else { Node<K,V> e; K k; 判断put进的数值是否和原来的数值key值一样，一样的话判断为更新该节点的值 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; 红黑树的存储的情况 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { 将P后面的值遍历，如果有空的值或者hash值，key值等于要插入的值，则更新这个值的 value for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); 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; p = e; } } 这是处理如果找到和e相同的节点时，进行更改值并且返回原来值的操作。这种操作是不会增加修改次数和容量的，所以直接返回原来值即可 if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } 修改次数更新，查看是否需要扩容 ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }所以综上，hashmap的内部数据是存储于一个Node<KV>[] table之中的。这个table是个数组，他的每个元素都是一条链表。相同hash值的会被放到同一个链表之中。链表之中按照前后顺序进行排列，新存进的总是放在Node的最尾端。
关于其内部类和数据实现我们先介绍到这儿。
2.hashmap的读取实现
hashmap的存取速度是相当快的，因为他的内部实现相当于链表，采用节点似的方式进行存储。而存储的顺序依赖于其hash值。上面我们有提到hashmap冲突的解决时提到了，存入的位置是（length-1）&hash（key）。是根据key的hash值和map的长度减1进行与操作的结果定义到其未知的。但是如果我们的key是类似于String这种对象时，由于不同对象的hashcode一定不相同，例如String a=“abc” String b =“abc“，如果我们依然采取这种策略，会使map的key值唯一性的矛盾。
我们看一下hashmap的hash值是通过什么方式算出来的
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }我们可以看出，hashmap的最终hash值是其key值的hash值和其右移16位进行异或运算得出的值。那么这样做的目的是什么呢？
一般来说hashmap的容量不会太高，我们以16为例，如果是16的话，数组长度-1所形成的二进制代码高位基本都是0，这样会导致算出的hashcode的高位的值不生效，相当于高位没有参与运算。如果我们将hashcode右移16位在与其本身做或运算，这样计算出的值相当于高位与低位产生了关联，混合了哈希码的高位于地位，从而增加了低位的随机性，减少了哈希冲突。
其实之前我们提到过，hashmap的结构实现是通过数组+链表实现的，但是在1.8版本中，我们引入了红黑树的概念。所谓的红黑树，其实是一种二叉搜索树而已。这种结构实现的树，会将搜索的效率变得很高。默认情况下，当容量大于8的时候，链表会自动转化为红黑树，避免某个桶的hash冲突的值太多影响查询效率。
比如上述put代码中的这段便是通过红黑树存储
而这段是在当链表长度大于8的时候，将链表转化为红黑树。
if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); //大于8转化为红黑树 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; }首先我们简单对红黑树进行介绍
红黑树是一种二叉搜索树。二叉搜索树最多有左右两个节点，对于一个根节点，左子树的所有值都是小于根节点的，右子树的所有节点都是大于根节点的。而红黑树相对于二叉搜索树的区别在于：
- 红黑树节点分为红色或者黑色两种
- 根节点一定是黑色
- 每个叶子节点一定是黑色的
- 每个红色节点的两个子节点都是黑色的（从叶子到根部不能出现两个连续的红色节点）
- 从任何一个节点到其每个叶子的所有路径都包含相同数目的黑色节点
图片类似如下
例如上述图片是一个完整的红黑树，如果我们插入节点的话，不能破坏红黑树的结构。首先，我们插入大小为14的节点，图片如下，这样的话红黑树的结构没有被破坏。
但是当我们插入大小为21的节点的时候，结构就被破坏掉了，违反了不能连续两个红色节点的规则
当红黑树的结构被破坏的时候，我们是怎么维护二叉树的结构的呢？
主要的方法有
- 变色：通过改变节点的颜色来维护结构---（hashmap）所用到的方法
- 旋转：二叉树重要的旋转操作：左旋和右旋
我们会在代码中详细讲解。
hashmap中的红黑树是通过名为treenode的内部类实现的：
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { 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; TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } }我们暂时给出了其中的参数和构造方法，Treenode是继承自linkedHashMap.Entry<K,V>类，，而这个类又继承自node，所以说TreeNode具有node的性质。他共有四个类似指针的变量，parent指向其父节点，left指向其左孩子节点，right指向其右孩子节点，pre指向原来链表中的前个节点。
接下来我们分析下树化的过程。树化是通过treeifyBin方法来实现的。这个方法有量点需要注意的地方。该方法是通过构建dir值来确认插入到数值是左子树还是右子树。dir值是通过hash值确认的，hash值大的在右边，小的在左边。如果hash值相同的话，我们通过compareto方法来比较两个对象的大小。如果键未实现comparable接口，那么dir的值去人为0，放在根节点右边
final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; //如果容量太小（小于64）则进行扩容操作 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); //判断对应的hash值有没有key值相同的存在 else if ((e = tab[index = (n - 1) & hash]) != null) { TreeNode<K,V> hd = null, tl = null; //将所有的Node对象转化为TreeNode对象并且维持前后连接 do { //此操作是生成一个新的treenode节点，treenode的构造方法继承自父类 TreeNode<K,V> p = replacementTreeNode(e, null); if (tl == null) hd = p; else { p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null); if ((tab[index] = hd) != null) //树化 hd.treeify(tab); } } //树化算法（属于Treenode内部类方法） final void treeify(Node<K,V>[] tab) { TreeNode<K,V> root = null; for (TreeNode<K,V> x = this, next; x != null; x = next) { next = (TreeNode<K,V>)x.next; x.left = x.right = null; //root为空的话，说明是根节点。根节点一定是黑色的 if (root == null) { x.parent = null; x.red = false; root = x; } else { //对应的key值和hash值 K k = x.key; int h = x.hash; Class<?> kc = null; for (TreeNode<K,V> p = root;;) { //这里通过dir来确认是左子树还是右子树，ph记录的是hash值 int dir, ph; K pk = p.key; if ((ph = p.hash) > h) //hash值小于根节点，说明在左子树 dir = -1; else if (ph < h) //hash值大于根节点，在右子树 dir = 1; //hash值相同的话，发生了hash碰撞，我们可以通过comparable来判断是进行对象的比较 else if ((kc == null && 首先获取该元素键的Class (kc = comparableClassFor(k)) == null) || 比较两个对象的大小,如果对象未实现comparable接口那么返回0 (dir = compareComparables(kc, k, pk)) == 0) dir = tieBreakOrder(k, pk); TreeNode<K,V> xp = p; //根据返回的dir确认是作为左子树还是右子树,前提是插入到p的位置的节点是空的才能插入，否则继续往下走，知道找到一个为空的可以插入的位置 if ((p = (dir <= 0) ? p.left : p.right) == null) { x.parent = xp; if (dir <= 0) xp.left = x; else xp.right = x; //对树进行平衡，计算当前树达到平衡状态下root的值，一遍下次继续插入的时候使用 root = balanceInsertion(root, x); break; } } } } moveRootToFront(tab, root); } /** * 如果对象x的类是C，如果C实现了Comparable<C>接口，那么返回C，否则返回null */ static Class<?> comparableClassFor(Object x) { if (x instanceof Comparable) { Class<?> c; Type[] ts, as; Type t; ParameterizedType p; if ((c = x.getClass()) == String.class) // 如果x是个字符串对象 return c; // 返回String.class /* * 为什么如果x是个字符串就直接返回c了呢 ? 因为String 实现了 Comparable 接口，可参考如下String类的定义 * public final class String implements java.io.Serializable, Comparable<String>, CharSequence */ // 如果 c 不是字符串类，获取c直接实现的接口（如果是泛型接口则附带泛型信息） if ((ts = c.getGenericInterfaces()) != null) { for (int i = 0; i < ts.length; ++i) { // 遍历接口数组 // 如果当前接口t是个泛型接口 // 如果该泛型接口t的原始类型p 是 Comparable 接口 // 如果该Comparable接口p只定义了一个泛型参数 // 如果这一个泛型参数的类型就是c，那么返回c if (((t = ts[i]) instanceof ParameterizedType) && ((p = (ParameterizedType)t).getRawType() == Comparable.class) && (as = p.getActualTypeArguments()) != null && as.length == 1 && as[0] == c) // type arg is c return c; } // 上面for循环的目的就是为了看看x的class是否 implements Comparable<x的class> } } return null; // 如果c并没有实现 Comparable<c> 那么返回空 } //比较的方法如下 比根节点大返回1，否则返回-1 static int tieBreakOrder(Object a, Object b) { int d; if (a == null || b == null || (d = a.getClass().getName(). compareTo(b.getClass().getName())) == 0) d = (System.identityHashCode(a) <= System.identityHashCode(b) ? -1 : 1); return d; }接下来我们看最重要的方法，红黑树是如何实现平衡的。
首先是插入平衡的实现
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root, TreeNode<K,V> x) { //首先插入的节点一定是红色的，原因上面已经解释 x.red = true; //xp指的是父节点 xpp指的是父节点的父节点，而xppl和xppr分别是xpp的左右节点 for (TreeNode<K,V> xp, xpp, xppl, xppr;;) { if ((xp = x.parent) == null) { //如果父节点为空，说明是根节点，直接变黑即可 x.red = false; return x; } //根节点是黑色的，不必调整即可返回根节点 else if (!xp.red || (xpp = xp.parent) == null) return root; //xp是xpp的左结点 if (xp == (xppl = xpp.left)) { //如果xpp右节点不是空的并且是红色的，即插入节点的祖父节点有右节点并且是红色，根据不能有两个相同的红色节点的性质，我们对他的父节点，祖父节点，祖父节点的右子节点进行变色 if ((xppr = xpp.right) != null && xppr.red) { //祖父节点右子节点，父节点变成黑的 xppr.red = false; xp.red = false; //祖父 节点变成红色 xpp.red = true; //x祖父节点到x节点的颜色没有问题，接着把祖父节点当作x继续遍历修改 x = xpp; } else { //祖父节点没有右节点或者右节点是黑色的 //x是xp的右节点 if (x == xp.right) { //左旋 root = rotateLeft(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; } if (xp != null) { xp.red = false; if (xpp != null) { xpp.red = true; //右旋 root = rotateRight(root, xpp); } } } } else { if (xppl != null && xppl.red) { xppl.red = false; xp.red = false; xpp.red = true; x = xpp; } else { if (x == xp.left) { root = rotateRight(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; } if (xp != null) { xp.red = false; if (xpp != null) { xpp.red = true; root = rotateLeft(root, xpp); } } } } } }综上所述，我们可以通过一下流程图标识转化为红黑树是如何插入节点的
重点我们要记住，我们要保持的原则是插入的节点一定是红色，而且从始至终这个节点的颜色不能做改变。
3.hashmap的扩容机制
当数组的容量到达一定的阀值之后，我们需要扩大hashmap的容量。首先我们需要思考，我们为什么不当数组满值的时候进行扩容，而是当到达一定阀值（默认容量*0.75）的时候进行扩容呢？
首先我们要考虑到，影响hashmap性能的两个方面：空间和时间。首先，数组的可用容量越大，说明空间利用率越低，但是同样的，哈希冲突的几率也变得比较小，冲突几率变小说明一个key值对应一个桶位置的比较多，这样降低了查询时间成本。相反，如果是数组的可用容量比较小，虽然降低了空间成本，但是也同样提高了时间成本。0.75可以说是一个比较折衷的设计，是在空间和时间成本上的综合性能最佳考虑 。
下面我们看下扩容的源码
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; 获取原数组的长度 int oldCap = (oldTab == null) ? 0 : oldTab.length; //获取原来的阀值 int oldThr = threshold; //新的数组长度和阀值暂定为0 int newCap, newThr = 0; if (oldCap > 0) { //static final int MAXIMUM_CAPACITY = 1 << 30;该默认值标识的是默认的最大的容量 if (oldCap >= MAXIMUM_CAPACITY) { //此时代表map已满 threshold = Integer.MAX_VALUE; return oldTab; } //默认情况下容量扩容翻倍 初始容量是16，此时新的阀值也会翻倍 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } //在旧的容量为0，就得阀值大于0的情况下，新的阀值为旧的阀值 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; //等于0时根据默认的初始容量和初始满值比率来计算初始的容量和初始的阀值量 else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } //这是为了如果新的阀值以外为0的话，将其设置为正确的阀值 if (newThr == 0) { float ft = (float)newCap * loadFactor; 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) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) //原数组的元素根据其hash值和容量-1的与运算的值重新定义位置 newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; //对e所代表的链表进行遍历 do { next = e.next; //把e的hash值与原来的容量进行与运算，如果为零的话，存储在lo的链表内，lo链表仍然放在原来链表对应的位置 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } //如果不为零，将放在原来链表位置+原来链表容量的位置 else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); //存入数据 if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }扩容代码有以下几点需要注意：
1.为什么每次扩容都要容量翻倍而不是增加其余的倍数呢？
这就要提到我们之前提到的散列机制了。我们可以得知，每次寻找新插入元素的位置时都需要与数组容量-1做按位与运算。如果我们以2的n次幂这种数据存储的时候，2的n次幂-1得到的结果一定是111111这样的形式。这样的值与其他值做三列，能够充分的散列，使得散列值均匀的分布在数组的每个位置，不会造成冲突降低效率。扩容每次按照翻倍也是这个道理
2.数据是如何从原来的数组复制到新的数组的呢
数据的复制并不是一个桶位置的所有元素都扩容到新的数组之中，而是要重算hash值。但是在jdk1.8中，我们引入了红黑树的概念，但是如果不是基于红黑树的话，在resize的时候，需要通过特定方法进行拆分放置。图片如下
因为扩容导致其hash值可能与之前的不同，放到代码中实现也就是将hash值和原来容量做与运算，如果不为零，说明其对应在旧容量最高位的位置为1.这样扩容之后1与1与预算为1，相当于在原来的位置基础上加了旧数组的容量。我们要把这部分数据挑出去放在新的位置之上。这样的优点在于，我们不必对每一个元素重算其hash值来计算其位置，只需要通过这种分离方式即可实现原数组数据的复制。而且，由于1.7链表的复制采用的头插法（头插法指每次插入的话会插入到表头之后，尾插法指的是插到当前尾节点之后），头插法所面临的问题是，在非线程安全的情况下，可能会造成链表倒置。而1.8实现的这种算法采用的尾插法，可以避免这种bug。
4.hashmap的线程安全问题
hashmap是非线程安全的，多线程环境下会造成脏读甚至死锁的情况。这样的话会使cpu的占用率达到100%。故多线程下推荐使用hashtable和concurrenthashmap
5.ConcurrentHashMap
concurrenthashmap是一种既符合线程安全，有具有高效性的数据结构。相较于hashmap，他的效率可能有所不足，但是实际上面对多线程并发的情况，我们的第一考虑仍然是concurrenthashmap。
为什么hashmap不是线程安全而concurrenthashmap是线程安全的呢？
hashmap虽然高效，但是实际上在多线程的情况下容易造成脏读和死锁等情况。concurrenthashmap的底层数据结构和hashmap是一致的，都是数组+链表+红黑树的结构。但是在concurrenthashmap中引用和分段锁的概念。之前hashmap非线程安全的原因主要是只有一把锁给各个线程提供竞争，但是concurrenthashmap实现了多把锁，通过可重入锁ReentrantLock和Segmengt（子哈希表）来讲table数组分为多个segment来进行维护。下面我们通过源码来解释他是如何实现线程安全的：
在1.7中。concurrenthashmap采用了分段锁的方式实现并发安全。
便于记忆我们可以这样通俗意义上的理解。segment把hashmap分为了一个个hashtable，每个hashtable都是线程安全的，这样在安全和效率之间做了中和，由此而实现的线程安全
他的segment是如下实现的：
static class Segment<K,V> extends ReentrantLock implements Serializable { private static final long serialVersionUID = 2249069246763182397L; final float loadFactor; Segment(float lf) { this.loadFactor = lf; } }继承自重入锁的segment保证了concurrenthashmap的线程安全
而在最新的1.8版本中，不再依赖分段锁的方式，而是转化为CAS+Synchronized来保证并发更新的安全.底层也加入了红黑树，采用数组+红黑树+链表的策略
首先是基本数据结构，Node内部类的元素如下：
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; volatile V val; volatile Node<K,V> next; ｝volatile关键字的意思是可见性，即在多线程的环境下，该值的变动对所有线程可见，具有实时可见性和实现有序性
首先我们看他的table初始化方法：
初始化方法的需要解决的方法之一就是如何确认table不会呗多次初始化。此处我们利用sizectrl来控制，sizeCtrl默认为零，当我们第一执行put操作的时候，线程会执行Unsafe.compareAndSwapInt方法修改sizeCtl为-1，并且只有第一个线程才能修改成功，其他的线程只需要通过yield方法让出cpu时间即可。
其次我们需要了解CAS方法：
CAS(Compare and Swap):比较和替换，是并发算法常用的一种技术。他的主要思想是，输入三个参数，一个当前内存值V，就得预期值A，即将更新的值B，仅当A和V相同的时候，保存内存的值为B 并且返回true，否则什么都不做，返回false
（附上详细解析链接供参考：https://www.jianshu.com/p/fb6e91b013cc）；
在本算法中CAS的意义在于在不实现悲观锁的情况下，通过CAS来保证每次更新初始化的都是安全的数据。
/** * Initializes table, using the size recorded in sizeCtl. */ private final Node<K,V>[] initTable() { Node<K,V>[] tab; int sc; while ((tab = table) == null || tab.length == 0) { //如何保证初始化表格的时候其他的线程不会再次初始化表格 if ((sc = sizeCtl) < 0) //暂停让出时间片 Thread.yield(); // lost initialization race; just spin //CAS策略 当第一次put操作会把sizeCtrl的值变成-1.此时如果其他线程再来操作初始化将会失败 else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { if ((tab = table) == null || tab.length == 0) { //n为sizeCtrl的值，否则为默认容量 int n = (sc > 0) ? sc : DEFAULT_CAPACITY; @SuppressWarnings("unchecked") Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; table = tab = nt; sc = n - (n >>> 2); } } finally { sizeCtl = sc; } break; } } return tab; } private transient volatile int sizeCtl;接下来我们尝试解析PUT操作：
final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException(); //计算hash值 int hash = spread(key.hashCode()); int binCount = 0; for (Node<K,V>[] tab = table;;) { Node<K,V> f; int n, i, fh; if (tab == null || (n = tab.length) == 0) //进行table的初始化 tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { //根据hash值找到对应的桶的位置，如果是空的话，在此处新建一个节点 if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null))) break; // no lock when adding to empty bin } else if ((fh = f.hash) == MOVED) //static final int MOVED = -1 说明此时map正在扩容 多并发的情况如果某个线程在扩容，需要帮助其扩容 tab = helpTransfer(tab, f); else { V oldVal = null; //调用同步块，保持线程安全 synchronized (f) { if (tabAt(tab, i) == f) { if (fh >= 0) { //hash值大于零 binCount = 1; for (Node<K,V> e = f;; ++binCount) { K ek; //hash值和key值都相同，替换掉value即可 if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { oldVal = e.val; if (!onlyIfAbsent) e.val = value; break; } //key值不相同并且e的后面没有其他节点，放到e的后面 Node<K,V> pred = e; if ((e = e.next) == null) { pred.next = new Node<K,V>(hash, key, value, null); break; } } } else if (f instanceof TreeBin) { //此时已经是红黑树结构 Node<K,V> p; binCount = 2; if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) { oldVal = p.val; if (!onlyIfAbsent) p.val = value; } } } } if (binCount != 0) { //容量大于8的时候需要变成红黑树结构 if (binCount >= TREEIFY_THRESHOLD) treeifyBin(tab, i); if (oldVal != null) return oldVal; break; } } } addCount(1L, binCount); return null; }关于map结构我们先介绍到这儿，之后我们会进行进一步的研究，希望能共同进步
