JDK源码阅读（四）、ArrayList&LinkedList

一、ArrayList与LinkedList对比

          ArrayList内部采用可变数组存储数据，所谓可变，就是数组的长度不是固定的，当添加数据到达上限的时候，会增长为原来的1.5倍。ArrList适合数据的随机读取，不适合大数据量数据的删除与，因为删除的话会进行数组的复制。

          LinkedList内部采用链表进行数据的存储，这也意味着LinkedList适合数据的增删，但是不适合数据的随机读取，因为这会遍历链表进行数据位置的查找。

二、一些关键的代码

ArrayList:

 ```java
     /**添加元素的时候会先尝试进行数组的扩容，
       扩容方式是当前数组长度+1是否超出当前的数组长度，如果超出就进行扩容，扩容大小为原来的1.5倍
     
     */
     public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
 /**
 * 删除满足指定条件的元素，
 这里面使用了bitSet，将需要删除元素的指定位置1，
     bitSet中的nextClearBit作用是从指定位置开始，找到下一个指定位是0的元素位置，也就是找到下一个需要保留的元素
 *
 */
    @Override
    public boolean removeIf(Predicate<? super E> filter){
            Objects.requireNonNull(filter);
            // figure out which elements are to be removed
            // any exception thrown from the filter predicate at this stage
            // will leave the collection unmodified
            int removeCount=0;
    final BitSet removeSet=new BitSet(size);
    final int expectedModCount=modCount;
    final int size=this.size;
            for(int i=0;modCount==expectedModCount&&i<size; i++){
    @SuppressWarnings("unchecked") final E element=(E)elementData[i];
            if(filter.test(element)){
            removeSet.set(i);
            removeCount++;
            }
            }
            if(modCount!=expectedModCount){
            throw new ConcurrentModificationException();
            }
    
    // shift surviving elements left over the spaces left by removed elements
            final boolean anyToRemove = removeCount > 0;
            if (anyToRemove) {
             final int newSize = size - removeCount;
            for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
            i = removeSet.nextClearBit(i);
            elementData[j] = elementData[i];
            }
            for (int k=newSize; k < size; k++) {
            elementData[k] = null;  // Let gc do its work
            }
            this.size = newSize;
            if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
            }
            modCount++;
            }
    
            return anyToRemove;
    }   
    
/**
 * 删除数组中不用的位置
 */
public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
        elementData = (size == 0)
        ? EMPTY_ELEMENTDATA
        : Arrays.copyOf(elementData, size);
        }
}

/**
 *  决定下一次扩容的初始值
 */
private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
}
/**
 *   判断是否进行扩容
 */
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
/**
 *  进行扩容操作
 */
private void grow(int minCapacity) {
        // 获得数组的长度
        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);
}
/**
 * set只能在数组当前的范围内添加，不能追加
 */
public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
}
/**
 * 在指定位置添加元素，add可以在数组的尾部进行元素的添加，使数组长度加一
 */
public void add(int index, E element) {
        /**
         * 添加元素之前先判断范围是否合适
         */
        rangeCheckForAdd(index);
        /**
         * 判断是否可以扩容
         */
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将elementData中index之后的内容添加到elementData  index+1之后去
        System.arraycopy(elementData, index, elementData, index + 1,
        size - index);
        elementData[index] = element;
        size++;
}
/**
 * 两个方法都是调用同一个方法，
 * batchRemove(Collection<?> c, boolean complement)，
 * complement为true，表示只保存指定集合的元素，为false，删除指定集合中的元素。
 * ，但是这个方法的效率并不高
 */

/**
 * 删除指定集合中存在的元素
 */
public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
}
/**
 * 保存指定集合中的元素
 */
public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
}
/**
 * complement为true，则表示保留指定集合元素元素
 *
 * complement为false，表示删除指定集合元素
 *
 * 效率不高，因为它有两层for循环：
 *        外层是for循环，
 *         内层是c.contains也会遍历集合查询指定元素是否存在
 */
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
        for (; r < size; r++)
        if (c.contains(elementData[r]) == complement)
        elementData[w++] = elementData[r];
        } finally {
        /**
         *
         */
        if (r != size) {
        System.arraycopy(elementData, r,
        elementData, w,
        size - r);
        w += size - r;
        }
        if (w != size) {
        // clear to let GC do its work
        for (int i = w; i < size; i++)
        elementData[i] = null;
        modCount += size - w;
        size = w;
        modified = true;
        }
        }
        return modified;
}
/**
 * 删除指定位置的元素
 *  通过源码可以看出，删除元素后，会进行数组的复制。
 *   所以arrayList不适合存放删除频繁的数据
 */
public E remove(int index) {
        //先进行范围检测
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
        numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
}
/**
 * 获取指定位置的元素，通过源码看出，arrayList适合元素的读取
 */
public E get(int index) {
        rangeCheck(index);

        return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}

LinkedList:

    Node<E> node(int index) {//进行指定位置数据的查找
       //判断数据在前半部分还是后半部分
        if (index < (size >> 1)) {
            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;
        }
    }
/**
 * 添加元素，相比于arrayList，不适合进行数据的读出，
 * 因为它会遍历整个链表进行查询
 */
public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
}
    Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
    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;
}
/***
 * 删除指定位置的元素，先遍历找到位置，然后删除这个节点。
 * 在大数据量的情况下， 有更高的效率
 */
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
}   

总结： 

        由于两者代码实现比较简单，所以直接比较看了一下。如果有不对的请大佬指出了~~