【17期】什么情况用ArrayList or LinkedList呢?

ArrayList 和 LinkedList 是 Java 集合框架中用来存储对象引用列表的两个类。ArrayList 和 LinkedList 都实现 List 接口。先对List做一个简单的了解：

列表（list）是元素的有序集合，也称为序列。它提供了基于元素位置的操作，有助于快速访问、添加和删除列表中特定索引位置的元素。List 接口实现了 Collection 和 Iterable 作为父接口。它允许存储重复值和空值，支持通过索引访问元素。

下面以增加和删除元素为例比较ArrayList和LinkedList的不同之处：

增加元素到列表尾端

在ArrayList中增加元素到队列尾端的代码如下：

public boolean add(E e) {
    ensureCapacity(size + 1); //确保内部数组有足够的空间
    elementData[size++] = e; //将元素加入到数组的末尾，完成添加
    return true;
}

ArrayList中add()方法的性能决定于ensureCapacity()方法。ensureCapacity()的实现如下：

public vod ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) { //如果数组容量不足，进行扩容
        Object[] oldData = elementData;
        int newCapacity = (oldCapacity * 3) / 2 + 1; //扩容到原始容量的1.5倍
        if (newCapacitty < minCapacity) //如果新容量小于最小需要的容量，则使用最小
            //需要的容量大小
            newCapacity = minCapacity; //进行扩容的数组复制
        elementData = Arrays.copyof(elementData, newCapacity);
    }
}

可以看到，只要ArrayList的当前容量足够大，add()操作的效率非常高的。只有当ArrayList对容量的需求超出当前数组大小时，才需要进行扩容。扩容的过程中，会进行大量的数组复制操作。而数组复制时，最终将调用System.arraycopy()方法，因此add()操作的效率还是相当高的。

LinkedList 的add()操作实现如下，它也将任意元素增加到队列的尾端：

public boolean add(E e){
    addBefore(e,header);//将元素增加到header的前面
    return true;
}

其中addBefore()的方法实现如下：

private Entry addBefore(E e, Entry entry) {
    Entry newEntry = new Entry(e, entry, entry.previous);
    newEntry.provious.next = newEntry;
    newEntry.next.previous = newEntry;
    size++;
    modCount++;
    return newEntry;
}

可见，LinkeList由于使用了链表的结构，因此不需要维护容量的大小。从这点上说，它比ArrayList有一定的性能优势，然而，每次的元素增加都需要新建一个Entry对象，并进行更多的赋值操作。在频繁的系统调用中，对性能会产生一定的影响。

增加元素到列表任意位置

除了提供元素到List的尾端，List接口还提供了在任意位置插入元素的方法：void add(int index,E element);

由于实现的不同，ArrayList和LinkedList在这个方法上存在一定的性能差异，由于ArrayList是基于数组实现的，而数组是一块连续的内存空间，如果在数组的任意位置插入元素，必然导致在该位置后的所有元素需要重新排列，因此，其效率相对会比较低。

以下代码是ArrayList中的实现：

public void add(int index, E element) {
    if (index > size || index < 0) {
        throw new IndexOutOfBoundsException("Index:" + index + ",size: " + size);
    }
    ensureCapacity(size + 1);
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

可以看到每次插入操作，都会进行一次数组复制。而这个操作在增加元素到List尾端的时候是不存在的，大量的数组重组操作会导致系统性能低下。并且插入元素在List中的位置越是靠前，数组重组的开销也越大。

而LinkedList此时显示了优势：

public void add(int index, E element) {
    addBefore(element, (index == size ? header : entry(index)));
}

可见，对LinkedList来说，在List的尾端插入数据与在任意位置插入数据是一样的，不会因为插入的位置靠前而导致插入的方法性能降低。

删除任意位置的元素

对于元素的删除，List接口提供了在任意位置删除元素的方法：

public E remove(int index);

对ArrayList来说，remove()方法和add()方法是雷同的。在任意位置移除元素后，都要进行数组的重组。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 remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

Node node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) { //要删除的元素位于前半段
        Node x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

在LinkedList的实现中，首先要通过循环找到要删除的元素。如果要删除的位置处于List的前半段，则从前往后找；若其位置处于后半段，则从后往前找。因此无论要删除较为靠前或者靠后的元素都是非常高效的；但要移除List中间的元素却几乎要遍历完半个List，在List拥有大量元素的情况下，效率很低。

容量参数

容量参数是ArrayList和Vector等基于数组的List的特有性能参数。它表示初始化的数组大小。当ArrayList所存储的元素数量超过其已有大小时。它便会进行扩容，数组的扩容会导致整个数组进行一次内存复制。因此合理的数组大小有助于减少数组扩容的次数，从而提高系统性能。

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

ArrayList提供了一个可以制定初始数组大小的构造函数：

public ArrayList(int initialCapacity) 

现以构造一个拥有100万元素的List为例，当使用默认初始化大小时，其消耗的相对时间为125ms左右，当直接制定数组大小为100万时，构造相同的ArrayList仅相对耗时16ms。

JDK1.7

• 当实例化ArrayList时，创建长度为10的object[ ] ;
• 当add添加到11个的时候，扩容，扩容为原来的1.5倍;
• 将原来的数据复制到新的数组中;
• 建议使用new ArrayList(int capacity)直接声明数组的大小;

JDK1.8

• 当实例化时，创建object[ ] ,初始化为 { }，并没有长度。
• 当添加第一个元素时，创建长度为10的数组。
• 当add添加到11个的时候，扩容，扩容为原来的1.5倍;
• 将原来的数据复制到新的数组中;

遍历列表

遍历列表操作是最常用的列表操作之一，在JDK1.5之后，至少有3中常用的列表遍历方式：

• forEach操作
• 迭代器
• for循环

String tmp;
long start=System.currentTimeMills();    //ForEach 
for(String s:list){
    tmp=s;
}
System.out.println("foreach spend:"+(System.currentTimeMills()-start));
start = System.currentTimeMills();
for(Iterator it=list.iterator();it.hasNext();){    
   tmp=it.next();
}
System.out.println("Iterator spend;"+(System.currentTimeMills()-start));
start=System.currentTimeMills();
int size=;list.size();
for(int i=0;i