Java中有哪些容器（集合类）？

Java集合类主要由Collectiont接口和 Map接口派生。 Collection接口派生出Set、List、Queue接口。
四个接口分为四大类集合： Set表示无序集合、List有序集合、Queue先进先出队列、Map 键值对集合
这些接口常见是实现类有HashSet、TreeSet、ArrayList、 LinkedList、 ArrayDeque、HashMap、 TreeMap

Java容器中线程安全和线程不安全的集合类

安全的只有Vector、Hashtable。 比较古老、性能很差
不如用Collections工具类的synchronizedCollection()方法，把不安全的集合类包装成安全的集合类
JDK5开始引入了concurrent包，提供了大量支持高效并发访问的集合类，既能保证线程安全，又能保证良好的访问性能。

Map接口的实现类及区别

HashMap、 LinkedHashMap、TreeMap、ConcurrenHashMap
HashMap 和 LinedHashMap 键值能存 null ，其他的不行
对于不需要排序的场景，优先使用HashMap，如果需要线程安全可以用ConcurrentHashMap，其性能好于Hashtable。

对于需要记住插入顺序的场景用LinkedHashMap、对于需要Key排序的场景选中TreeMap，
如果需要线程安全也可以用Collections工具类将上述实现类包装成安全的Map

HashMap源码分析

HashMap的底层数据结构是数组+链表，如果链表长度达到8，链表会转化为红黑树
底层使用Set集合存储entry

put 源码 及存储过程分析

    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;
        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;
            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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

map的存储过程为：

1. 首先获取Node数组 table对象，如果table为null则调用resize()扩容
2. 计算索引下标，判断数组指定索引下的节点是否为null，如果为null就new 出来一个单向链表赋值给这个节点
3. 若索引下标节点不为null，判断此节点的key与插入key是否相等，先判断hash再判断equals， 相同直接替换
4. 如果不同的话就看看节点是不是红黑树，是的话用红黑树的插入
5. 不是红黑树，也不同就遍历节点插入，如果插入后链表节点数大于8，就把链表变成红黑树。
6. 最后判定数组需不需要扩容，需要的话就进行resize()

hash值计算

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
1
2
3
4

HashMap计算Hash值不是简单的直接用Object的Hash值，而是将这个Hash值异或上它无符号右移16位 h = hahsCode() ^ (h >>>16)
也就是把HashCode的高16位移位到第位进行异或运算。这样做的原因是HashCode的差异主要再高位，而通过hash值计算索引位置时会忽略掉高位信息，所有用异或把高位信息也保存下来，减少hash碰撞

索引计算

(n - 1) & hash
1

这么做使得计算出的索引一定在数组界限内

扩容 resize() 方法

触发扩容的三个条件： ①数组为空、②链表长度达到8，且数组长度小于64 则扩容、 ③数组中元素超过阈值（默认0.75）则扩容

扩容过程：

1. 判断数组大小是否到了极限 默认 2的30次方，到极限了就不扩容了
2. 如果老数组为空就扩容就扩为初始容量， 否则就扩两倍，因为用位移计算容量效率很高
3. 扩容完之后需要迁移数据，所有元素重新分配，在迁移数据的过程中，不会重新计算每一个key的Hash值，如果hash值 & 旧数组大小 等于0， 索引不变，
   如果为1 新索引为旧索引+旧数组大小。 这样由于新产生的一位是0或者是1 是随机的，这样就把产生冲突的节点均匀分布到新的槽里了

为什么用红黑树，不用二叉树或B树

B/B+树多用于外存上
HashMap本来是数组+链表的形式，链表由于其查找慢的特点，所以需要被查找效率更高的树结构来替
换。
如果用二叉树的话，极端情况二叉树只有一边子树可能会变成单链表的形状。
如果用B/B+树的话，在数据量不是很多的情况下，数据都会“挤在”一个结点里面，这个时候遍历效率就退化成了链表。

HashMap中的循环链表是如何产生的

在多线程下，当重新调整HashMap的大小的时候，如果两个线程都发现要resize(), 他们同时尝试调整大小的过程中，存储在链表中的元素次序会反过来。因为迁移数据到新的位置的时候，HashMap是用的头插法，防止尾部遍历。 两个线程竞争就可能导致循环链表。

说说你对红黑树的见解

待补充