ArrayList与LinkedList的简单比较

在Java的List类型集合中，ArrayList和LinkedList大概是最常用到的2个了，细看了一下它们的实现，发现区别还是很大的，这里简单的列一下个人比较关心的区别。

类声明

ArrayList

1 2 3 4

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

LinkedList

1 2 3

public class LinkedList<E>      extends AbstractSequentialList<E>      implements List<E>, Deque<E>, Cloneable, java.io.Serializable

二者的定义有些相近，除了都实现List、Cloneable和Serializable以外，继承的类不一样，以及接口有细微的区别。

1	public abstract class AbstractSequentialList<E> extends AbstractList<E>

AbstractSequentialList也继承自AbstractList，它只是多了一些实现的方法，参照API的doc，这个类用于按顺序访问的List的实现，所谓顺序访问（sequential access），可以与随即访问（random access）的ArrayList对比去理解。

Deque是一个双向（double ended queue）的Queue的接口，因为这个接口的区别，LinkedList里实现的方法要比ArrayList多一些。

元素存储方式

ArrayList：采用数组方式

1	private transient Object[] elementData;

LinedList：采用链表

1 2 3 4 5 6 7 8 9 10 11 12 13

private transient Entry<E> header = new Entry<E>( null , null , null );   private static class Entry<E> {      E element;      Entry<E> next;      Entry<E> previous;        Entry(E element, Entry<E> next, Entry<E> previous) {          this .element = element;          this .next = next;          this .previous = previous;      } }

很好理解，从字面都可以理解出来，一个是数组实现，一个是链表实现。

元素添加

二者都有几个add()方法，

void add(E item)  向滚动列表的末尾添加指定的项。
void add(E item, int index)  向滚动列表中索引指示的位置添加指定的项。

先看看ArrayList的实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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

对于add(E e)方法，非常简单，首先确保数组容量，然后直接赋值。在不需要扩充数组容量的情况下，效率非常高，而一旦需要数组扩容，代价就会上升：

1 2 3 4 5 6 7 8 9 10 11 12

public void ensureCapacity( int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) {      Object oldData[] = elementData;      int newCapacity = (oldCapacity * 3 )/ 2 + 1 ;          if (newCapacity < minCapacity)      newCapacity = minCapacity;          // minCapacity is usually close to size, so this is a win:          elementData = Arrays.copyOf(elementData, newCapacity); } }

 因为它需要将已有的数组复制到新的数组里去。由此便可以想到一个提高add()效率的方法，在一开始尽量设定一个合理的数组容量，那么可以有效地减少数组的扩容和大量的复制。

对于add(int index, E e)，比起add(E e)，多一个可能的复制操作，这样才能保证在合理的位置插入新的元素。

LinkedList的实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public boolean add(E e) { addBefore(e, header);      return true ; }   private Entry<E> addBefore(E e, Entry<E> entry) { Entry<E> newEntry = new Entry<E>(e, entry, entry.previous); newEntry.previous.next = newEntry; newEntry.next.previous = newEntry; size++; modCount++; return newEntry; }   public void add( int index, E element) {      addBefore(element, (index==size ? header : entry(index))); }   /**   * Returns the indexed entry.   */ private Entry<E> entry( int index) {      if (index < 0 || index >= size)          throw new IndexOutOfBoundsException( "Index: " +index+                                              ", Size: " +size);      Entry<E> e = header;      if (index < (size >> 1 )) {          for ( int i = 0 ; i <= index; i++)              e = e.next;      } else {          for ( int i = size; i > index; i--)              e = e.previous;      }      return e; }

粗略看起来要复杂一些，因为LinkedList同时还是一个Deque（JDK 1.6新添加的），所以它的实现也要兼顾双向队列。

下面从一个空的LinkedList开始，看看新的元素是如何添加进来的：

1 2 3 4 5 6 7

List<Integer> ints = new LinkedList<Integer>();   ints.add( 1 ); ints.add( 2 ); ints.add( 3 );   System.out.println(ints); //[1, 2, 3]

下面一步一步看List内部header和元素之间的关系：

• 初始化： header.element = null; header.next=header.previous=header 这里是一个环状的结构，自己的p和n指针都指向自己

• 添加第一个元素“1”:header.element=null;header.next=1;header.previous=1; 2个元素相互连接
• 添加第二个元素“2” 这里很明显看来了，是一个环状结构

• 添加第三个元素“3” 既然是一个环状，干脆用圆形显示好了，貌似画的不太圆。。。

这里总结一下两种的差别：

• 对于元素的add()来说，LinkedList要比ArrayList要快一些，因为ArrayList可能需要额外的扩容操作，当然如果没有扩容，二者没有很大的差别
• 对于元素的add(int, element),对于LinkedList来说，代价主要在遍历获取插入的位置的元素，而ArrayList的主要代价在于可能有额外的扩容和大量元素的移动
• 小结：对于简单的元素添加，如果事先知道元素的个数，采用预置大小的ArrayList要更好，反之可以考虑LinkedList

元素移除

 ArrayList的元素移除：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

public E remove( int index) { RangeCheck(index);   modCount++; E oldValue = (E) elementData[index];   int numMoved = size - index - 1 ; if (numMoved > 0 )      System.arraycopy(elementData, index+ 1 , elementData, index,               numMoved); elementData[--size] = null ; // Let gc do its work   return oldValue; }   public boolean remove(Object o) { if (o == null ) {          for ( int index = 0 ; index < size; index++)      if (elementData[index] == null ) {          fastRemove(index);          return true ;      } } else {      for ( int index = 0 ; index < size; index++)      if (o.equals(elementData[index])) {          fastRemove(index);          return true ;      }      } return false ; }   /*   * Private remove method that skips bounds checking and does not   * return the value removed.   */ private void fastRemove( int index) {      modCount++;      int numMoved = size - index - 1 ;      if (numMoved > 0 )          System.arraycopy(elementData, index+ 1 , elementData, index,                           numMoved);      elementData[--size] = null ; // Let gc do its work }

remove(int)和remove(Object)两种方式的返回值是有区别的哦

对于ArrayList来说，主要是的仍然会有元素的移动（这里就是数组的复制），虽然采用的是System的arrayCopy，但是本质上还是复制的思路。还有一点需要注意的是，remove(Object)对null值进行单独处理，这里也说明ArrayList是可以存取null的。

LinkedList元素移除：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

public E remove( int index) {       return remove(entry(index));   }     /**    * Returns the indexed entry.    */   private Entry<E> entry( int index) {       if (index < 0 || index >= size)           throw new IndexOutOfBoundsException( "Index: " +index+                                               ", Size: " +size);       Entry<E> e = header;       if (index < (size >> 1 )) {           for ( int i = 0 ; i <= index; i++)               e = e.next;       } else {           for ( int i = size; i > index; i--)               e = e.previous;       }       return e;   }   public boolean remove(Object o) {       if (o== null ) {           for (Entry<E> e = header.next; e != header; e = e.next) {               if (e.element== null ) {                   remove(e);                   return true ;               }           }       } else {           for (Entry<E> e = header.next; e != header; e = e.next) {               if (o.equals(e.element)) {                   remove(e);                   return true ;               }           }       }       return false ;   }

这里的实现就是典型的链表删除的实现，其中有几个细节需要提一下：

• modCount的处理，这个变量是用来存储List的修改的次数的，仅仅存储添加和删除的操作此书，用来在Iterator中判断List的状态和行为，防止不同步的修改，抛出ConcurrentModificationException
• 通过索引访问元素的实现entry(int)，这里有一个小细节，

   if (index < (size >> 1)) {

如果元素的位置在前半段，那么通过next指针查找，否则通过previous指针查找。这一行代码有2个值得学习的地方，第一查找的优化，根据位置判断查找的方向，第二移位操作的运用。不得不佩服Bloch的编程功底。

小结一下：

删除操作中，LinkedList更有优势，一旦找到了删除的节点，它仅仅只是断开链接关系，并没有元素复制移动的行为，而ArrayList不可避免的又要进行元素的移动。

元素索引

indexOf(Object o)  回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

ArrayList的实现：

1 2 3 4 5 6 7 8 9 10 11 12

public int indexOf(Object o) { if (o == null ) {      for ( int i = 0 ; i < size; i++)      if (elementData[i]== null )          return i; } else {      for ( int i = 0 ; i < size; i++)      if (o.equals(elementData[i]))          return i; } return - 1 ; }

LinkedList的实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public int indexOf(Object o) {      int index = 0 ;      if (o== null ) {          for (Entry e = header.next; e != header; e = e.next) {              if (e.element== null )                  return index;              index++;          }      } else {          for (Entry e = header.next; e != header; e = e.next) {              if (o.equals(e.element))                  return index;              index++;          }      }      return - 1 ; }

ArrayList：基于数组的遍历查找

LinkedList：基于链表的遍历查找

按照对象在内存中存储的顺序去考虑，数组的访问要比链接表快，因为对象都存储在一起。

遍历

基于以上的分析，可以得出，按照索引遍历，ArrayList是更好的选择，按照Iterator遍历，也许LinkedList会好一些。

反过来理解，如果是ArrayList，Iterator和index遍历都可以，如果是LinkedList，优先选择Iterator比较好。

其他

• 对于ArrayList和LinkedList， size() isEmpty() 这些都是常量计算，代价很低
• LinkedList实现了更多的方法，包括Queue，所以它也是一种队列
• 对于少量得元素临时存储，优先考虑ArrayList
• 频繁的添加和删除操作的时候，优先使用LinkedList
• 频繁的按索引访问遍历，优先使用ArrayList