List（ArrayList，Vector，LinkedList）

一、Collection常用方法：

（1）add():元素按顺序添加，与存放顺序一致，可以重复，可以存放null，支持索引（从0开始）。默认是在最后添加，如果有index，在index位置添加。

（2）addAll(Collection)：添加元素可以是集合。removeAll()、containsAll()也是同理。

（3）remove():参数可以是index，按照索引移除，也可以是object，按照对象移除。

（4）contains(Object)：查找是否包含某个元素

（5）size()、isEmpty()、clear()

List常用方法：add()/addAll()、indexOf(object)元素第一次出现的位置、lastIndexOf()、get()、

set(index,object)把第index位置的元素换成object，index一定要存在。 subList(start，end)返回[start,end)的子集合。

二、List的三种遍历方式

（1）迭代器Iterator遍历：

所有实现了Iterable接口的类都有一个iterator()方法返回一个Iterator的对象。

迭代器本身是不存放对象的，只是用于对象的遍历。

next()方法执行后：指针下移，并返回指针下移后所指的对象。在调用next方法之前，首先调用hasNext()方法判断时候还有元素。指针一开始指向第一个元素的前一个位置，遍历完成后指向最后一个元素。如果要再次遍历，再次调用iterator()方法，将指针置于初始位置。

Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

（2）增强for循环：底层仍然使用的是迭代器

for (Object o :list) {
            System.out.println(o);
        }

（3）普通循环遍历：

for (int i=0 ; i<list.size() ; i++){

        Object o = list.get(i);

}

三、ArrayList：

（1）注意事项：底层由对象数组存储元素；基本等同于Vector，但是线程不安全，效率较高

transient表示该属性不会被序列化，synchronized表示支持线程同步，互斥

（2）底层源码（扩容机制）

List list = new ArrayList();//创建一个新ArrayList

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

for(int i=0;i<10;i++){ //向其中添加元素
    list.add(i);
}

要添加元素，首先得有足够的容量能放进去。因此要求出当前所需的最小容量（如果当前数组为空，就将默认10作为最小容量，否则就是当前元素个数加1），然后将最小容量和数组长度比较，如果小于当前数组长度，则无需扩容直接存放，否则，需要扩容：扩容到原数组长度的1.5倍长度，如果原长度为0，则扩容长度为10，之后将数组元素使用Arrays.copyOf()将元素赋值【使用这个方法是能够保证原数组保留的】

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 首先对容量判断，保证能添加新的元素
        elementData[size++] = e;
        return true;
    }

private void ensureCapacityInternal(int minCapacity) {//确定一个当前存放后需要的最小容量
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//如果当前数组为空数组
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//最小容量取默认10
        }

        ensureExplicitCapacity(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);//新的数组长度是原来长度的1.5倍
        if (newCapacity - minCapacity < 0)//如果原来长度为0，新数组长度取10
            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);//将原数组复制到新数组，剩余位置为null
    }

四、Vector源码：

List list = new Vector();

public Vector() {
        this(10); //直接调用初始容量为10的构造器
    }

public Vector(int initialCapacity) {
        this(initialCapacity, 0); 
    }

public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity]; //本质也是一个对象数组
        this.capacityIncrement = capacityIncrement; //这里传入的是0
    }

for(int i=0;i<11;i++){
    list.add(i);
}

public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1); //保证能够将新元素放进去
        elementData[elementCount++] = e;
        return true;
    }

private void ensureCapacityHelper(int minCapacity) {
        // 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 + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
//这里的capacityIncrement为0，所以扩容为原来长度的2倍
        if (newCapacity - minCapacity < 0)//如果扩容后长度还是不够
            newCapacity = minCapacity;//就让新长度等于当前所需的最小长度
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);//将原数组复制到新数组中
    }

 

五、LinkedList：底层实现是双向链表

 添加和删除的效率较高，线程不安全，没有实现同步

底层实现：

List list = new LinkedList();

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;
transient Node<E> first;
transient Node<E> last;

list.add(1);//添加第一个元素

public boolean add(E e) {
        linkLast(e);
        return true;
    }

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

list.remove(1);   在执行删除方法之前，首先会判断index是否在合理的范围内。下列方法中一个指针指向被删元素的前一个，一个指向后一个，然后分别判空与否，处理很好

E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

list.set(index , a); //首先判断index是否合法，然后找到该位置，

Node<E> node(int index) {//找对应index位置的元素
        // assert isElementIndex(index);

        if (index < (size >> 1)) {//这里先将index和size/2比较，然后决定从前开始找还是从后开始找
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

找到该位置后，更换元素

public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }