容器xxxxx

1.集合框架uml

为什么没有map？
首先Map提供的是键值对映射（即Key和value的映射），而collection提供的是一组数据（并不是键值对映射）。如果map继承了collection接口，那么所有实现了map接口的类到底是用map的键值对映射数据还是用collection的一组数据呢（就我们平常所用的hashMap、hashTable、treeMap等都是键值对，所以它继承collection完全没意义），而且map如果继承了collection接口的话还违反了面向对象的接口分离原则。
2.List
（1）ArrayList
查看内部主要数据：

  /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

#既然底层就是个数组，那为什么不直接使用数组？
第一、数组不支持扩容；第二、数组的类型可以没有约束，而arrayList使用泛型进行约束ArrayList，方便存取元素；

添加元素和扩容大流程：

（2）linikedList
使用内部类封装节点：

 private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

内部参数：维护了一个头节点和尾节点

transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

添加过程：默认是从尾部添加元素，实际上可以从头部，也可从尾部添加元素。

void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

（3）vector和Stack
底层实现
Vector底层一样是个数组，使用了sychronized关键字，相比arraylist是线程安全的；

Stack继承vector，添加了push，pop方法，又叫栈（先进后出，尾进尾出，最后一个进来，第一个出去）；

3.Map
（1）HashMap
用于存放键值对，键值均可以为空；底层数据结构为数组+链表+红黑树

#为什么需要hashMap hash的查询效率是O（1）（如果没有hash冲突）,而数组的查询时间复杂度即便是排序好的二分查找，其时间复杂度为O（logN）。使用与运算和hash值确定在数组上的位置。但是此种计算可能导致不同的存储对象存在相同的index位置（hashcode可能不唯一，即便唯一也可能计算出相同的index），因此使用了拉链法解决hash冲突。Hashmap内部的数组对象是永远装不满的，一定会空出至少（1-loadfactors）比列的位置。和数组相比，是使用内存换取性能。
#为啥要将链表转换为红黑树（待补充） 粗略的将链表边长后查找元素的效率会降低，红黑树相对更快；

基本字段：
Threshold：所有链表中的map数量的阈值；
Loadfactors：负载因子
Size：map总数；
关系：threshold=capacity*loadfactors;(capacity其实就是table数组的length)；
构造器：

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

对于指定容量的构造，需要重新计算数组大小

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);
    }

之所以要返回2的幂次方数目，是因为，因为这个值-1后的1最多，最能分摊，设想如果有0，那摩hash上该位上是0或者1的区别是没有的，将都在一个index上；

 /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

``添加过程和扩容机制：

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;
    }

整理以下：

扩容机制：
增加一倍容量，并完成数据的迁移；

/**
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     *
     * @return the table
     */
    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) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        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)
                        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;
                        do {
                            next = e.next;
                            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;
    }

大体过程整理如下：

其中需要关注的细节：
①计算hashcode
key----->key.hashcode()---------->hash=hash(hashcode)------------>index=hash&table.length-1
A.hashcode
基本的约定

1. 在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。
2. 如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生相同的整数结果。
3. 如果两个对象根据equals(Object)方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生不同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高Hash
   table的性能。

不同的对象是可能产生相同的hashcode的。
#为什么key一般使用String或者基本类型包装类？
因为hashcode已经重写过了，equals方法也重写了，并且散列更好；

#如果key使用其他引用类型的对象呢？
需要重写hashcode（）方法和equals方法（比较内容）；

②计算hash值
#为什么还要计算？
index=hash&table.length-绝大多数情况下length一般都小于2^16即小于6553。也就是说只能和低16位置运算，那么hashcode高16位的信息就会被屏蔽，造成更多的index冲突，因此将高16位和低16位异或，共同决定要和length与运算的低下16位信息；

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

③计算下标（桶位置）

i = (n - 1) & hash]

n-1的1最多以及hash的散列最终使得计算出来的index更加散列；

（2）TreeMap（红黑树）
private transient Entry<K,V> root

树的生成要依赖比较器：
private final Comparator<? super K> comparator;
①comparable和comparator接口的区别
Comparator:比较外部的对象，也可比较自己
int compare(T o1, T o2);
Comparable:自比较
Int compareTo(T t)
什么是红黑树？
（1）、每个节点都只能是红色或者黑色；
（2）、根节点是黑色；
（3）、每个叶节点(叶节点即指树尾端NIL或NULL节点)是黑的； 
（4）、如果一个结点是红的，则它两个子节点都是黑的。
（5）、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

如何理解（3）？

红黑树可以全黑吗？

（A）有了平衡二叉树为什么还需要红黑树呢，况且红黑树还没有它更平衡？
“二叉平衡树的严格平衡策略以牺牲建立查找结构(插入，删除操作)的代价，换来了稳定的O(logN) 的查找时间复杂度。但是这样做是否值得呢？
能不能找一种折中策略，即不牺牲太大的建立查找结构的代价，也能保证稳定高效的查找效率呢？ 答案就是：红黑树。”
通过五条规则的限制使得红黑树从根到叶子的最长路径不会超过最短路径的2倍（非完全平衡）

（B）红黑树与2-3-4树的关系
红黑树的本质是2-3-4树，而2-3-4树代码不好实现，则将2-3-4树的三种节点分别用三种不同模式的颜色组合代替，每棵红黑树对应一个2-3-4树，类似函数关系，（三节点的2种可能性造成的）；

特征：黑色在上，红色在下。
通过红找黑就可以将红黑树还原为2.3.4树

2.3.4树是黑色平衡的，只要保持黑色平衡，就能满足对应的红黑树五条规则
（C）红黑树的增删
当我们操作红黑树时，就要将其还原成2-3-4树来考虑
问题在于像以下情况，同一层次的节点存在一红一黑吗？这种情况2.34树似乎也并不能解释如何变色。
红黑树的添加：

添加所在的节点的父节点是红色，那必然是三节点，即使
①二节点：是黑色的，直接在后面添加红色节点，构成三节点
②三节点：红色的，添加成黑色的需要旋转和变色；
③四节点：再添加会分裂一个往上去，并且肯定是设置为红色，一旦其父节点是红色就需要调整到根节点并（会有旋转操作）
红黑树的删除：
二叉树的删除是用前后继点替代，在红黑树里也一样。我们继续映射到2-3-4树里进行讨论：
红黑树的被删除节点的前驱或者后驱节点在2-3-4树的叶节点？
①被删除节点是三节点或者四节点
不影响，如果为红，不影响；如果为黑，直接用红色的替代
②被删除节点为二节点，找兄弟借
a.若兄弟为三节点或者四节点，直接旋转借就行
b.若兄弟也为二节点，则（同损失）兄弟也变红一个父节点，知道俩兄弟共同的夫节点是红色时，将父亲节点改为黑色，补上损失的黑色，平衡；
c.如果父亲节点本身就是黑色呢？

知识铺垫： ①二叉树 生成规则：左节点小于根节点，右节点大于根节点；
删除：用前驱或者后继节点替代删除节点，处理前驱或者后继节点的子节点或者父节点

遍历 三种遍历：前序遍历、后序遍历、中序遍历；使用递归的思想？？



其他遍历方法：层序遍历
#如何计算树高

②平衡二叉树 任何一个节点的左子树与右子树都是平衡二叉树，并且高度之差的绝对值不超过 1。 生成规则：按照普通二叉树规则生成；
左旋右旋可以维持二叉树的性质； 一旦高度差超过1，采用旋转方法保持平衡； 如何检测高度差超过1？
方法1：每添加一次计算每个节点的子树高度差； a.如何哪些旋转的情形？





（把左右右左转化为左左右右边） 左左：直接右旋根节点 左右：先左旋根节点的左节点，再右旋根节点 右右：左旋根节点；
右左：先右旋根节点的右子节点，再左旋根节点

c.达到平衡的旋转方式是唯一的吗？

treeMap