Java类集（二）

6. HashMap，TreeMap，HashTable的关系与区别
   a. HashMap，TreeMap，HashTable都是Map的常用子类，HashMap基于哈希表+红黑树（JDK1.8之后），HashTable基于哈希表，TreeMap基于红黑树。
   b. HashMap采用懒加载策略，添加元素时才初始化，采用异步处理，线程不安全，性能较高（JDK1.2）
   c. HashTable产生对象时初始化内部哈希表（默认大小为16），采用synchronized同步方法，线程安全，性能很低（读读互斥）。
   d. 关于null
   HashMap ：K与V都允许为null
   TreeMap ：K不为null，V可以为null
   HashTable：K与V都不允许为null

7. HashMap内部源码解析（负载因子，树化策略，扩容策略，内部哈希算法）

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    内部哈希实现:
    保留高16位(保留有效位数),让高低16位都参与异或运算，降低哈希冲突的概率
    为何不直接使用hashCode方法?
    返回值普遍较大，需要开辟大量空间
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    (h = key.hashCode()) ^ (h >>> 16)

    为何哈希表长度必须为2^n?
    保证哈希表中所有索引位置都有可能被访问到
    假设n=15 

    HashMap中元素真正的索引下标计算:
    (n - 1) & hash

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 此时哈希表还未初始化，完成初始化操作
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 此时哈希表对应的索引下标未存储元素
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 哈希表初始化并且对应的索引下标有元素
        else {
            Node<K,V> e; K k;
            // 此时冲突位置的key值与要保存的元素key值相等,只需要将value替换
            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 {
                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;
                }
            }
            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;
    }

负载因子 float loadFactor(默认为0.75）
树化阈值 int TREEIFY_THRESHOLD = 8;
解树化阈值 int UNTREEIFY_THRESHOLD = 6;
容量 int threshold=loadFactor * cap(哈希表长度 table.length);
当前集合元素个数 int size;

树化逻辑：当前桶中链表的长度 >= 8 并且 哈希表的长度 >= 64，否则只是简单的扩容处理。
为何引入红黑树：优化链表长度过长导致性能急剧降低 O(n) -> O(logn)
解树化：当红黑树节点个数在扩容或删除时个数 <=6，在下一次resize()过程中会将红黑树退化为链表，节省空间。

负载因子loadFactor > 0.75 ：增加了哈希表的利用率，哈希冲突概率明显增加
负载因子loadFactor < 0.75 ：降低了哈希表的利用率，导致频繁扩容，哈希冲突概率明显降低

8. JDK1.7与JDK1.8 ConcurrentHashMap设计区别
   JDK1.7
   Segment是ReentrantLock的子类
   将Hashtable的整张表加锁,一把锁优化为16个Segment(16把锁),锁的是当前的Segement
   不同Segement之间还是异步.
   Segement初始化为16之后不可再扩容.
   结构:16Segment+哈希表
   JDK1.8
   ConcurrentHashMap锁进一步细化，结构类似于HashMap.哈希表+红黑树，锁当前桶的头结点,锁的个数进一步提升(锁个数会随着哈希表扩容而增加),支持的并发线程数进一步提升。
   使用CAS+synchronized来保证线程安全