类集

类集(多线程+数据结构)-JDK1.2
1.ArrayList、LinkedList、Vector的关系与区别(源码)
a.ArrayList基于数组实现List，采用懒加载策略,当一次调用add方法时，数组才会初始化为10(默认值)。
ArrayList扩容为原先数组的1.5倍。ArrayList采用异步操作，线程不安全，性能较高。

b.Vector(JDK1.0)基于数组实现List，当产生Vector对象时，就初始化为大小为10的数组。扩容为原先数组的2倍。
Vector采用同步方法保证线程安全，性能低(读读互斥)。

c.LinkedList基于双向循环链表实现的List，采用异步处理，线程不安全。在任意位置插入或删除时考虑使用
LinkedList或需要使用队列的场合。

2.请描述fail-fast策略ConcurrentModificationException并发的修改异常

在迭代输出的过程中修改了集合的结构(remove、add)抛出此异常，为了保证多线程场景下多线程取得数据正确性。

如何产生:
modCount记录当前集合被修改次数
expectedModCount迭代器内部记录当前集合修改次数,当取得集合迭代器时赋值为当前modCount
modCount != expectedModCount
什么是快速失败策略:优先考虑异常情况，当异常产生时，直接抛出，程序终止。

如何解决:
a.迭代输出时尽量不要修改集合结构。
b.使用juc包下的线程安全集合如CopyOnWriteArrayList,ConcurrentHashMap(fail-safe集合)

3.Set与Map有什么关系
Set实际就是Map,Set将元素存储到了内部Map的Key，共享一个空的Object作为value.
3.1 hashcode与equals
hashcode:将任意一个对象按照特定的哈希算法变为整数(对象中所有属性值均参与运算)
equals:比较两个对象是否相等(属性值)
equals相等时，hashCode一定相等。
hashCode相等，equals不一定相等。(参考哈希表的设计)

3.2 如何实现第三方类的比较(内部排序 外部排序)
内部排序:Comparable
当一个类实现了Comparable接口，表示该类具备天然可比较特性
int compareTo(Object antherObj)
外部排序:Comparator(策略模式)
类本身不具备可比较的特性(人类)，专门有一个类实现了Comparator(福布斯、长寿村)来比较该类的大小(比较器)
int compare(Object obj1,Object obj2)

要想将自定义类存储到TreeSet(TreeMap)中，要么元素本身可比较(实现了Comparable接口)，
要么通过构造方法传入该类的比较器(实现了Comparator接口)

4.HashMap、Hashtable、TreeMap的关系与区别
a.底层结构
HashMap:哈希表+红黑树(JDk1.8,JDk1.8之前哈希表)
b.Hashtable:哈希表
c.TreeMap:红黑树
b.线程安全性
只有Hashtable线程安全(使用synchronized同步方法，读读互斥)
c.关于null
Hashtable key与value均不为null。HashMap key与value均可为null。
TreeMap key不为null，value可以为null

HashMap内部实现原理
a.元素到底在哪个数组下标位置存储:内部的哈希算法

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

整数之间的区别主要在高16位
异或运算将高16位与低16位都参与异或运算，减少哈希冲突
(h = key.hashCode()) ^ (h >>> 16)

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;
        // 当前哈希表对应的索引下标没有存储元素\
        // i = (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;
            // 要插入的元素与数组元素的key值完全相等，将value值替换为插入的值
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 此时要插入的元素与数组元素key值不等，按照红黑树形式插入节点
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            // 按照链表形式插入
            else {
                for (int binCount = 0; ; ++binCount) {
                    // binCount == 7
                    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;
    }

树化逻辑:
链表个数达到树化阈值(7),并且哈希表tab.length >= 64

JDK1.8为何要将链表树化?
当链表过长会导致查找性能降低(O(n)),因此将其树化可以大大提高查找速度(o(logn))

扩容:当前数组元素个数 > 容量 * 负载因子
负载因子:0.75
容量:默认16

为何容量必须为2^n:减少哈希冲突，让哈希数组每个索引下标都会被访问到
i = (n - 1) & hash

5.ConcurrentHashMap在JDK1.7与JDK1.8的区别

JDK1.7:
默认初始化为16个Segment,初始化后不会扩容.
每个Segement下面还是一个哈希表结构,可以扩容(扩容以Segement为单位)

Hashtable锁的是当前对象，即整个哈希表。(一张表，一把锁)
ConcurrentHashMap锁的是当前操作的Segment(一张表，16把锁,
将锁的粒度细化,不同Segment之间可以异步)

JDK1.8:
取消原先Segement的设计，现在的结构与HashMap相同.
锁的是哈希表的数组元素,将锁进一步细化,进一步提高读写效率.