JAVA学习 集合

预估数组的默认容量，避免扩容带来性能开销。

minCpacity ＝oldCpacity+1 添加数据前判断数组容量看是否需要扩容。

Arraylist grow()：
newCapacity = oldCpacity+oldCapacity>>1;
向右移1位 8421 近似于1.5倍扩容。

newCapacity - minCapacity ＜ 0;
扩容以后数组变小了？oldCapacity是1，右移一位是0，而minCapacity是2，相当于没有扩容，所以newCapacity ＝minCapacity。

newCapacity - MAX ARRAY SIZE ＞ 0;
1.5倍扩容超过了数组可容纳的最大值newCapacity为-1，超出范围的值，减掉正常范围的值，又回到正常值了，是正数，所以相减大于零。MAX ARRAY SIZE ＝ IntegerMaxValue - 8，此情况下的newCapacity可能是IntegerMaxValue - 7或 -6 等。

hugeCapacity()：(minCapacity ＞IntegerMaxValue) ? IntegerMaxValue:MAX ARRAY SIZE;
计算出来的容量大于最大数组长度，但仍为正数，新容量就给整数最大值，如果相等或小于就给数组长度最大范围

hashmap：通过key作hash运算与上数组的长度得到下标，其他节点得到一样的下标，则通过指针next连成链表，当链表过长，兼顾查询和插入的效率，链表会树化变成红黑树。
hashmap 的 key 可以为null，为 null 的 key 赋一个0值。

DefaultInitialCapacity; 数组的默认容量是16。
MaximumCapacity; 数组的最大容量是2的30次方。
TreefyThreshold＝8; 数组中链表长度超过8树化。
UNTreefyThreshold＝6; 树转链表。
MIN TreefyThreshold ＝64; 树化前要求数组的容量超过64，没有超过就先扩容，不树化。
Node<k,v>[] table; 储存node数据的数组。
DefaultLoadFactor=0.75; 默认的负载因子×数组容量＝临界值超过临界值数组扩容resize()。
FinalFloatLoadFactor; 可以自定义负载因子。

hashmap put():
tab为数组、p为头部节点、n为数组的长度、i是数组的下标、e是新加入的节点，不操作原数组数据都是取出来赋值。
判断tab为空，n为零，数组不存在、调用resize()数组初始化以后返回新数组给tab。
判断头节点p为空，则newNode作为头节点。
else头节点不为空，则判断新加入的节点的hash、key与头节点的hash、key是否一致，一致就覆盖掉value值。
elseif判断头节点是否是树，是就把节点加入到树中。
else p还不是树，判断如果p的下一个节点为空，则新加入的节点e连到p. next上。保留一个binCount，链上节点就自增1，达到了7时就将链表树化。
节点添加完以后再将p指向e，下次循环就不用循环整个链表了，直接在p. next上添加一个新节点。

hashmap的key的hash怎么算？
下标＝(数组的长度-1) & hash。hash是作异或运算、高位和低位位移共同参与运算，获得的二次幂是比结果大的值。高位与低位共同参与的原因是为了让数值大的和数值小的在数组里分布的范围更均匀。

hashmap的resize()扩容方法？
数组初始化、超过临界值扩容、树化前判断数组还没有64位先扩容不树化、通过位移扩容。

hashmap什么时候会树化？
数组长度是64且链表长度到8时会树化，为6时树会回退成链表。树化长度是8的泊松分布，添加到同一条链表的概率会随着链表长度变长而变小。

为什么选0.75为负载因子？
可以在hashmap的构造器中自定义负载因子。

LRU: least recently used. get key 获取node时判断有没有开启accessOrder，accessOrder初始化时在构造器中有没有定义成true，有会调用afterNodeAccess把获取的node，move node to last，和remove eldest Node.删掉以后，如果需要查询以前的数据，可以从服务器端数据库中查找。
可以重载构造器
new hashmap(initial Capacity, LoadFactor, accessOrder, max Capacity)
通过override protected boolean removeEldestEntry(first) return true; 来删除掉缓存中不常用的久远的节点。

linkedhashmap：有序的hashmap、有序的双向链表，数组的查询效率是O(1)，链表的查询效率是O(n)。难道有序就不用O(n)了吗。
Treemap有序的原因是实现了Comparable接口，重写了CompareTo()。

hashSet 和 entrySet有什么区别。?

hashmap 和 hashSet都是无序的，key 相同 value 就会被覆盖，所以 key 不同。
iterater 迭代器，判断是否有下一个 hasNext()，输出 next()。
hashmap 的 iterater:keySet() 返回 integers 集合，integers. iterater 获得每一个key，getkey()获得每一个value。

arraylist循环删除数据：
正序循环，需要指针回调。否则对于数组来说，如果数组下标对应的数据被删除了，后面的没有遍历过的数据会位移到前一个，然后会接着遍历，就有数据漏了没有遍历到。
或者可以逆序循环删除。

一般集合删除元素就用迭代器 iterater。

为什么调用 iterater 遍历以后就不能调用数组的 remove()？
JAVA代码不允许这样写。modCount 属于集合list的成员变量，expectedModCount 属于内部迭代器变量，iterater的remove()实际也是调用数组的remove()，但比数组多了expectedModCount＝modCount; 此操作，只有两个变量相等去调用next()前才不会报并发修改异常，就是为了避免循环删除数据，只删除数据，而不删除下标，数据往前位移以后有数据没有遍历到。

用Vector、list的子类实现线程安全，Vector几乎所有的方法都加synchronized，没加锁的方法如grow()也是被加锁的方法调用。
arraylist扩容是通过位移的1.5倍扩容，Vector是可以传具体扩容的大小，没传就+old capacity，2倍扩容。
用hashtable替代hashmap实现线程安全。hashtable的 key 和 value 都不允许为null，hashmap的key可以为null。hashmap计算下标的方式是高位与低位共同参与位移和异或运算，而hashtable计算下标的方式是取余。

CopyOnWriteList：读可以多线程读，写操作就上锁，只允许一个线程写，写时把原数组拷贝一份出来进行写操作，目的是不影响读，写完以后修改数组的引用指向，类似 ReentrantWriteLock。
源码add()：获取原数组的数据 getArray()、原数组的长度 len，创建新数组，新数组的长度是原数组的长度+1， 添加新数据 newElement[lens]=e，改变数组的引用指向。

Concurrenthashmap：只对链表头上锁，如果同时有好几个线程都是往数组的不同链表上添加数据则不会有线程安全问题，这样不用每个线程都排队，如果线程是往相同的链表上添加数据被阻塞的线程会采用cas自旋模式做补偿。

1.7的hashmap：头插、createEntry() 获取头节点保存，新创建的节点作为头节点指向的下一个是原来的头节点。
为什么1.7hashmap要头插？在链表头上添加可以提升读的效率，数组的时间复杂度是O(1)、链表的时间复杂度是O(n)，但数组会扩容rehash与新的数组长度计算下标、热点数据又被打乱了，头插变得没有意义，不如改为尾插降低复杂度。
1.8的hashmap尾插putVal()上文详细讲过。
1.7分段锁听不懂。
1.7版本的hashmap循环链表问题：

guava提供的不可变的集合来保证线程安全，集合只能创建时添加数据，创建完以后只能get() 或 reverse()，不能add()。

JUnit，测试类引入jar包，学会使用注解@Before @After @Test 和assert()，@Test可以代替main()运行函数，命名规范应该是一个类名加上Test。

arraylist 和 linkedlist性能对比：
arraylist：尾插效率高，头插效率低，每当从头添加或随机删除一个数据，数组都要整体位移，数据量越大位移耗费时间越多，尾删就可以。for循环遍历时间复杂度是O(1)。
linkedlist：头插尾插一样大差不差。遍历从头往中间找，从后往中间找，性能有所提升，但比起数组还是逊色。遍历用迭代器能提升效率，随机删除效率高，改变一下指向就可以了。
arraylist 和 linkedlist是用迭代器iterater删除数据。

jdk1.8以后接口类的所有属性、内部类都是静态的，可以有 defaulted 修饰的默认方法可以有方法体，抽象方法和默认方法都可以在实现类里重写。

函数式接口：
Consumer：传入数据以后操作没有返回值，可以理解成消费传入的数据。
Supplier：返回一个对象。
Predicte：做断言，条件返回true，不满足条件返回false。

树
唯一根、根的子树必须完整、对应的下一层有几个叶子叫度、最大层高叫树深。斜树只有左节点或只有右节点，像链表。满二叉树除了叶子都挂满两个数据。完全二叉树最后一层必须有左叶子。
二叉树的储存可以数组储存缺叶子的用null补齐，也可以链表储存，data、left、right。

从上到下，从左到右遍历。先出现的先打印叫先序遍历或前序遍历。第二次进入遍历到才打印的叫中序遍历，第三次遍历到才打印的叫后续遍历。

递归遍历树，为空时退出递归方法，在第一次遍历到时打印叫先序遍历，遍历完左子树时打印叫中序遍历，遍历完右子树才打印叫后序遍历。

栈结构遍历树，传入唯一根弹出时保留数据，先把右节点压入栈再把左节点压入栈，原因是如果先把唯一根和左节点弹出了右节点就丢失了，等到栈内没有数据了再停止弹出数据，打印弹出的数据。

队列结构层次遍历树，唯一根入队，队列不为空时一直出队，不过要先保存再出队，保存是为了让弹出的数据的左节点和右节点入队，出队时打印队列的数据。

二叉查找树是根的左子树所有节点小于根，根的右子树所有节点大于根。二叉树的查找类似于二分查找。没有值就返回空，找到了返回值，没有找到就往左子树右子树递归调用。

package review.Tree;

import javax.swing.tree.TreeNode;
import java.util.ArrayList;
import java.util.Stack;

public class Tree {

    private static class Node{
        Integer data;
        Node left;
        Node right;

        public Node(Integer data) {
            this.data = data;
        }
    }

    //递归遍历
    public static void prePrint(Node node){
        if (node == null){
            return;
        }
        System.out.print(node.data);
        prePrint(node.left);
        prePrint(node.right);

    }
    public static void inPrint(Node node){
        if (node == null){
            return;
        }

        prePrint(node.left);
        System.out.print(node.data);
        prePrint(node.right);

    }

    public static void postPrint(Node node){
        if (node == null){
            return;
        }

        prePrint(node.left);
        prePrint(node.right);
        System.out.print(node.data);

    }

    //栈结构遍历树
    public static void stackPrint(Node node){
        Stack<Node> stack = new Stack<>();
        stack.push(node);

        while (!stack.isEmpty()){
            node = stack.pop();
            System.out.println(node.data);

            if (node.right != null){
                stack.push(node.right);
            }

            if (node.left != null){
                stack.push(node.left);
            }

        }

    }

    //队列结构层次遍历树
    public static void QueuePrint(Node node){
        ArrayList arrayList = new ArrayList();
        arrayList.add(node);//我觉得是尾插
		
		//队列就像排队，先排到的先出去
        while (arrayList.size() > 0){
            node = (Node)arrayList.get(0);
            arrayList.remove(0);
            System.out.println(node.data);

            if (node.left != null){
                arrayList.add(node.left);
            }

            if (node.right != null){
                arrayList.add(node.right);
            }

        }

    }

    public static Node select(Node root,Integer target){
        if (root == null){
            return null;
        }else if (target == root.data){
            return root;
        }else if (target > root.data){
            return select(root.right,target);
        }else {
            return select(root.left,target);
        }

    }


    public static void main(String[] args) {
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);

//        prePrint(root);
//        inPrint(root);
//        postPrint(root);
//        stackPrint(root);
//        QueuePrint(root);
        System.out.println("select(root,2) = " + select(root, 2)); //null

    }


}

平衡二叉树符合二叉查找树的特点同时要求了左右子树之间不得超过1的层差。平衡二叉树比斜树查询效率高。斜树像链表结构得一个个去查找。平衡二叉树的插入可能会导致树旋转，如果树的层数很高会很麻烦。

红黑树是唯一根和空节点标记为黑色，红节点的父节点和孩子节点也标记为黑色，所有叶子节点加上两个空节点来保持平衡，从根节点到空节点经过的黑色节点数目相同，来保持平衡。两个根的子树层高差不能超过一半。无法想象。

B树是多叉树，B+树是所有叶子节点都再存一遍数据的多叉树。b数哈哈

流式编程