Collection，List接口相关介绍

Collection

public interface Collection<E> extends Iterable<E> 

• Collection实现子类可以存放多个元素，每个元素可以是Object
• 有些Collection的实现类可以存放重复的元素，有些不可以
• 有些Collection的实现类，有些是有序的，有些不是有序的
• Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

• Collection接口遍历元素方式1，使用Iterator（迭代器）
• Iterator对象成为迭代器，主要用于遍历Collection集合中的元素
• 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
• Iterator仅用于遍历集合，Iterator本身不存放对象（快捷键itit）
  
  在调用iterator.next()方法之前必须调用iterator.hasNext()进行检测。若不调用且下一条记录无效，直接调用it.next()会抛出异常
  增强for循环可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样，只能用于遍历集合或数组。（快捷键大写I）

List接口

• List接口是Collection接口的子接口 List.java
• List集合中的每个元素都有对应的顺序索引，即支持索引
• List集合中的每个元素都有其对应的顺序索引，即支持索引
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素

ArrayList

• 可以加入null，并且多个
• 是由数组来实现数据存储的
• ArrayList基本等同于Vector，除了ArrayList是线程不安全（执行效率高），多线程下不建议使用ArrayList

源码分析：
ArrayList中维护了一个Object类型的数组elementData。transient Object[] elementData（transient 表示瞬间，短暂的，该属性不会被序列化）

• 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍

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

 public boolean add(E e) {
 //确认大小够不够我添加一个数据，先确定是否要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //然后再执行赋值操作
        elementData[size++] = e;
        return true;
    }

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

//该方法确定minCapacity
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//如果elementData是{}
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 1 和 默认10 找一个最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //第二次添加时，elementData不是{}，直接返回
        return minCapacity;
    }

  private void ensureExplicitCapacity(int minCapacity) {
  //记录当前集合修改次数，防止有多个线程来修改它
        modCount++;

        // overflow-conscious code
        //当前最小容量 - 实际数组大小大于0. 10 - 0  > 0
        //第二次添加，2 - 10 < 0，不进行扩容
        if (minCapacity - elementData.length > 0)
        //如果elementData的大小不够就扩容
            grow(minCapacity);
    }

 private void grow(int minCapacity) {
        // overflow-conscious code
        //第一次是0
        //第二次扩容10
        int oldCapacity = elementData.length;
        //第一次是0
        //第二次扩容15
        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:
        //第一次扩容是十个null，使用扩容机制来确定要扩容到多大
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

• 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍
  比如初始化为8容量的数组，如果加到第9个就扩容为12

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

Vector

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Vector底层也是一个对象数组

protected Object[] elementData;

Vector是线程同步的，即线程安全的，Vector类的操作方法带有synchronized，在开发中需要线程同步安全时，考虑使用Vector

 public Vector() {
        this(10);
    }

 public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

  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;
        //扩容两倍 有参构造可以指定capacityIncrement
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

LinkedList

• 底层实现了双向链表和双端队列特点
• 可以添加任意元素（元素可以重复），包括null
• 线程不安全，没有实现同步

   public LinkedList() {
    }

此时LinkedList的属性first = null last = null

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

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

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

    public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

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