JDK源码解析之ArrayList和LinkedList

共同点：

两者都实现了List<E>、Cloneable、Serializable接口,说明二者都可以序列化，但是需要注意使用subList方法用于获取部分list时由于返回的对象是SubList<E>，SubList<E>这个类没有实现序列化，如果此时进行序列化时就会抛出异常；具体的源码实现如下：

public List<E> subList(int fromIndex, int toIndex) {
return new SubList<E>(this, fromIndex, toIndex);
}

不同点：

1.数据结构不同，ArrayList采用数组的形式存储，其有两个构造方法，开发者可以指定数组大小，默认构造函数大小为10

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

public ArrayList() {
this(10);
}

个人建议初始化时最好能预判判断存储的大小，使用第一种方法初始化，避免空间浪费和扩容造成效率低下，如果容量不够，新增数据时会进行扩容，新建一个数组存放数据；扩容大小为原大小的一半加1，具体实现如下：

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

2. LinkedList采用链表存储数据，jdk1.6中采用双向循环链表存放，头结点为null,不存放数据，其节点为Entry<E>,初始化size为0，构造方法如下：

private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0;

/**
* Constructs an empty list.
*/
public LinkedList() {
header.next = header.previous = header;
}

 jdk1.7采用不带头结点的普通链表存储，具体的实现感兴趣可以看一下源码

3.两者的数据结构不同导致了不同操作的效率不同，接下来基于常用方法分析一下两者效率：

 a.对于基本的add(E e)操作，两者效率相同，前提是ArrayList不需要扩容情况下

 b.对于指定位置添加add(int index,E e)、romove(int index)操作，ArrayList需要进行数组的内容移动，而LinkedList只需要在指定位置添加一下新节点，变换一下指针即可，具体实现如下：

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

LinkedList源码

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

c.对于remove(Object o)，二者都需要遍历进行查询，ArrayList查找到删除完节点后，还需要将其后的节点进行移动，LinkedList只需要改变一下指针指示即可，具体实现如下：

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

LikedList源码

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

private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();

E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}

总结：

1. 对于顺序添加读取，建议使用ArrayList且提前初始化好大小

2. 对于指定位置添加和删除，建议使用LinkedList，特别是位置比较靠前的新增和删除

3. 二者都是线程不安全的

4. subList方法的使用注意序列化问题，此处有坑