集合知识点

List接口

由于数组存储数据时大小定好以后不能改变，所以通常用List代替数组
List中的常用实现类有ArrayList，LinkedList，Vector。

三者都实现了List接口，都存储有序的，可重复的数据
ArrayList是线程不安全的，它的执行效率高，底层使用Object[] elementData存储
LinkedList底层使用双向链表存储。如果需要频繁插入删除，效率比ArrayList高
Vector是线程安全的，执行效率低，底层使用Object[] elementData存储

Vector使用synchronized来进行同步

ArrayList源码
使用Object[] elementData存储，并且不会被序列化

transient Object[] elementData; // non-private to simplify nested class access

空参构造器将Object[] elementData初始化为{}，在第一次调用add方法时创建长度为10的数组（jdk7是一实例化就创建了）

 	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
   

使用add方法时，会判断是否超出了当前数组的长度，以确定是否扩容，扩容大小为原来的1.5倍，如果不行就扩为2倍，如果还不行就扩成最大长度了。

   public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
     private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

带参构造器，避免扩容，效率更高。

 public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

LinkedList源码

Node作为存储单位

 transient Node<E> first;
 transient Node<E> last;

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

add方法，将元素添加到最后一个

  public boolean add(E e) {
        linkLast(e);
        return true;
    }
        /**
     * Links e as last element.
     */
   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++;
    }

Set接口

存储无序、不可重复的数据
Set接口常用实现类：HashSet，LinkedHashSet，TreeSet
HashSet：主要实现类，是线程不安全的，可以存储null值
LinkedHashSet：HashSet子类，可以按照添加的顺序来遍历
TreeSet：可以按照添加对象的指定属性进行排序