Java集合

常用集合类

List  ArrayList -- 自动扩容的数组，有序可重复

        LinkedList -- 双向链表，有序（存取的先后顺序）可重复，随机添加删除元素效率较高

Set  HashSet -- 源码使用HashMa实现，无序不可重复，添加取元素不保证有序

        Treeset -- 源码使用TreeMap实现，不重复，按照一定规则进行排序

Map HashMap -- 底层是散列表（哈希表），数组＋单向列表/红黑树

        TreeMap -- 底层是红黑树，无序不可重复

ArrayList

初始化容量为10，自动扩容数组，扩为原先容量的1.5倍，

实例化数组时，默认创建一个长度为10的数组，增加元素其实也就是修改元素值，添加元素时会判断元素个数是否等于数组长度，相等时则会创建一个比原来长度大1.5倍的新数组，然后把原数组的元素复制到新数组，再进行添加，不相等时则直接将值放进数组中。

public void add(Object o) {
        int length = elements.length;
        if (size == length) {
            int newLength = size + (size >> 1);
            Object[] newEmts = new Object[newLength];
            System.arraycopy(elements, 0, newEmts, 0, length);
            elements = newEmts;
        }
        elements[size++] = o;
    }

LinkedList

双向链表，有一个名字为Node的内部类，如下

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

当添加元素时，会判断是否已经有数据了，通过成员变量的值是否为null来判断，没有元素（为null时）会创建一个节点，并将第一个和最后一个的成员变量都指向这个节点，如果有，则创建一个新的节点对象，将其的next属性或者prev属性指向变量值last，或者first变量值，然后将first或last的值指向这个新创建的节点。

 final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;

HashSet / HashMap

HashSet的构造方法都会创建HashMap对象，但是只保存key，随便传一个数给value;所以HashSet是不可重复的。

HashMap的entrySet()方法会将键值对封装成一个对象，并返回Set类型的值。

底层是散列表,根据传入的key得到hash值，然后找到数组下标，判断当前位置是否有元素，没有则添加进当前元素，有则比较key与hash值是否都相同，相同则改变value值，不同则看其的next是否为空，不为null则继续比较值，相同则改变值，不同则，比较下一个元素，循环上述操作。

下面是HashMap的添加元素的源代码，当链表长度大于8时，数组长度大于64，会将链表转换成红黑树，否则红黑树转为列表。

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        tab为Node类型的数组，p,结点对象，n,数组长度，i,下标
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        当tab为null或长度为0时，表示数组为空
        if ((tab = table) == null || (n = tab.length) == 0)
            将创建数组并赋值给tab，并将创建的数组长度赋值给n
            n = (tab = resize()).length;     
        //根据hash值得到数组下标，并判断当前位置是否有元素   
        if ((p = tab[i = (n - 1) & hash]) == null)
            没有元素，则将创建一个节点对象并放到此位置
            tab[i] = newNode(hash, key, value, null);
        //这种情况是当前位置有元素,p是当前元素
        else {
            //e表示的是节点对象，k是节点对象的key属性
            Node<K,V> e; K k;
            //判断当前元素的key和hash值是否与传进来的相同
            //相同则将当前位置元素赋值给e
            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) {
                    //将当前位置元素指向的下一个元素对象赋值给e，并判断是否为null
                    if ((e = p.next) == null) {   
                        //空则表示p没有下一个元素，当前链表只有一个元素     
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);//树化
                        break;
                    }
                    //如果hash和key一样，结束循环，当前e为下一元素
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))        
                        break;
                    //下一元素既不是空，hash和key又不相同，测将下一元素赋值给p，再次进行循环，比较下一个元素的下一个元素
                    p = e;
                }
            }
            //当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;
    }

TreeSet / TreeMap

底层是红黑树

红黑树（自平衡二叉树）为了解决二叉查找树的缺陷（某一枝条太长，而逐渐变成线性结构，效率低）而生
      红黑树,添加元素时，先判断树是否为空，空就直接创建一个树节点， 如果不为空就是有数据，再用循环比较器比较新添加的元素与集合中的元素，知道元素为null时就存进去，大的放右子节点，小的放左子节点,并进行旋转变色操作。

比较器Comparable与Comparator

集合进行排序时，会调用集合中元素的comparableTo()方法，根据其返回值进行排序，返回值小于0，则前排，大于0则后排，等于0则不排

class SuiBian implements Comparable<SuiBian> {    

    @Override
    public int compareTo(Per o) {
        return o.age - this.age == 0 ? 0 : o.age - this.age;
    }

comparator比较器，用于原类没实现Compatable接口并重写方法，或者原类的排序规则不符合需求时，comparator优先级大于comparable，所以能用comparable比较器，就不要用comparator，因为这样写扩展性高。

TreeSet ts1 = new TreeSet(new NoSComparator());//main方法中

class NoSComparator implements Comparator {//创建一个第三方选择器
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof NoS && o2 instanceof NoS) {
            // 要添加的元素
            NoS n1 = (NoS) o1;
            // 集合里的元素
            NoS n2 = (NoS) o2;
            return n1.count - n2.count == 0 ? 0 : (n1.count - n2.count);
        }
        return 0;
    }

}

一般采用下面这种方法进行Comparator编写

        TreeSet ts1 = new TreeSet(new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof NoS && o2 instanceof NoS) {
                    NoS n1 = (NoS) o1;
                    NoS n2 = (NoS) o2;
                    return n1.count - n2.count == 0 ? 0 : (n1.count - n2.count);
                }
                return 0;
            }

        });

泛型

参数化类型（可以添加任何类型的数据），将所操作的元素的数据类型当作参数，当没有传入泛型实参时，则默认是Object类型，当传入实参时（不能传入基本数据类型，只能传入引用数据类型），会限制元素类型的操作，所操作的数据元素只能是这个数据类型的，并且这样数据一致，不需要进行强转操作。比如ArrayList类，HashMap类