java语言基础--集合学习，ArrayList和Linkedlist

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    private static final long serialVersionUID = 8683452581122892189L;
    //默认初始容量
    private static final int DEFAULT_CAPACITY = 10;
    //默认构造函数的空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //瞬态(在采用Java默认的序列化机制的时候，被该关键字修饰的属性不会被序列化)的数组，真正存放元素的数组
    transient Object[] elementData; // non-private to simplify nested class access
    //elementData存放元素的数量，这里和容量不一样
    private int size;
}

    public ArrayList(int initialCapacity) {
        super();//即父类protected AbstractList() {}
        if (initialCapacity < 0)throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        this.elementData = new Object[initialCapacity];//创建一个容量为initialCapacity的空的（但是size==0）对象数组
    }

    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;//将空数组赋值给elementData
    }

    public ArrayList(Collection<? extends E> c) {
        //调用Collection.toArray()方法得到一个对象数组，并赋值给elementData
        elementData = c.toArray();
        //设置size的值
        size = elementData.length;
        //c.toArray()如果没有返回Object[]时，利用Arrays.copyOf 来复制集合c中的元素到elementData数组中
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;//将数组元素追加到末尾,并修改size
        return true;
    }
    
    private void ensureCapacityInternal(int minCapacity) {
        //根据EMPTY_ELEMENTDATA  判断数组是否是用默认构造函数初始化的,(这里不考虑ArrayList(Collection<? extends E> c)这种情况是因为，minCapacity是肯定大于c的size的)
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;///如果确定要扩容，会修改modCount 
        
        // 如果传入的数大于数组原容量 则开始扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        //
        int oldCapacity = elementData.length;
        //扩容为原来的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //取1.5倍的容量和传入的扩容系数的最大值
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//这里的 MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //最大返回 Integer.MAX_VALUE
    private static int hugeCapacity(int minCapacity) {
        // overflow
        if (minCapacity < 0) throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
    }

    public void add(int index, E element) {
        rangeCheckForAdd(index);//范围检查

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将index开始的数据 向后移动一位
        System.arraycopy(elementData, index, elementData, index + 1,size - index);
        elementData[index] = element;
        size++;
    }
    
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        //扩容准备
        ensureCapacityInternal(size + numNew);  
        // 复制数组 ，并载入数据
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    public E get(int index) {
        rangeCheck(index);//范围检查

        return elementData(index);//下标获取数据
    }    

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    transient int size = 0;//集合元素数量

    transient Node<E> first; //头部节点

    transient Node<E> last;//尾部节点

   public LinkedList() {}

    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);//将集合c所有元素插入链表中
    }

　　//双向链表
　　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;
        }
    }

    //尾部插入新节点
    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)//如果原尾部节点为null  则将当前节点设置为链表的首节点
            first = newNode;
        else//否则将当前节点设置为原尾部节点的后节点
            l.next = newNode;
        size++;
        modCount++;
    }