ArrayList与LinkedList比较
ArrayList与LinkedList比较
1.实现方式
ArrayList内部结构为数组，定义如下：
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData; // non-private to simplify nested class access
LinkedList内部结构为双向循环链表，定义如下：
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
// Node节点定义
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;
}
}
2.使用场景
ArrayList适用于随机访问
LinkedList适用于于随机位置增加、删除
3.插入删除
ArrayList在插入删除时需要移动index后面的所有元素
LinkedList在插入删除时只需遍历，不需要移动元素
4.随机访问
ArrayList支持通过下标访问元素，效率高
LinkedList每次访问通过头尾遍历，效率低
5.空间占用
ArrayList因为有扩容操作，在尾部预留有额外空间，每次扩容为150%，造成一定的空间浪费(初始大小为10)
LinkedList虽然没有浪费空间，但是每个元素都存储在Node
6.遍历方式
ArrayList可以使用for循环，forEach，iterator
LinkedList一般使用forEach，iterator
7.继承接口
ArrayList继承了RandomAccess接口，RandomAccess是一个标记接口，用于标明实现该接口的List支持快速随机访问，主要目的是使算法能够在随机和顺序访问的List中性能更加高效（在Collections二分查找时）。如果集合类实现了RandomAccess，则尽量用for循环来遍历，没有实现则用Iterator进行遍历。
LinkedList继承了Deque
8.性能分析
| 操作 | ArrayList | LinkedList |
|---|---|---|
| get(index) | O(1) | O(n) |
| add() | O(1) | O(1) |
| add(index) | O(n) | O(n) |
| remove() | O(n) | O(n) |
可以发现，LinkedList的add(index)，和remove()的复杂度也是O(n)，与ArrayList并没有差别，这是因为在增删之前需要先得到增删元素的位置，然后才能进行增删，然而LinkedList只能通过遍历来得到位置，因此复杂度为O(n)，并不是O(1)。
- 末端插入，虽然二者都是O(1)，但是LinkedList每次插入都要new一个对象。因此，当数据量小时，LinkedList速度快，随着数据量的增加，ArrayList速度更快。
- 随机插入
LinkedList对于插入有一个优化：当插入位置小于(size/2)时从头遍历，当插入位置大于(size/2)时，从尾遍历。
2.1 在前半段随机插入，一般来说，此时的LinkedList效率高于ArrayList。
2.2 在后半段随机插入，此时很难判断，因为在后半段，ArrayList的copy()消耗减少，而对于LinkedList来说效率不变，因此二者的性能相差不大。
代码验证，使用一个大小为1000000的List，向其中插入500000条数据，验证在不同插入位置List的性能
| 耗时 | ArrayList | LinkedList |
|---|---|---|
| 插入位置：末尾 | 0.034s | 0.034s |
| 插入位置：999999 | 17.166s | 447.135s |
| 插入位置：500001 | 120.862s | 1024.761s |
| 插入位置：1 | 307.608s | 0.045s |
| 插入位置：0 | 381.185s | 0.039s |
| 插入位置：250000 | 240.943s | 621.257s |
| 插入位置：0,2,4,6... | 63.837s | 692.319s |
总结：只有当频繁在List前端位置进行增删操作，才选用LinkedList。一般情况，都选用ArrayList。
测试代码：
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Test
*/
public class Test {
//在末端插入
public static void addTest(List list, int num) {
long startTime = System.currentTimeMillis();
for(int i=0; i<num; i++) {
int a = (int) Math.round(Math.random()*num);
list.add(a);
}
long endTime = System.currentTimeMillis();
System.out.println("addTime: " + (endTime-startTime)/1000.0 + "s size:" + list.size());
}
// 在指定位置插入
public static void insertTest(List list, int num, int index) {
long totalTime=0;
long startTime=0;
long endTime=0;
startTime = System.currentTimeMillis();
for(int i=0; i<num; i++) {
int a = (int) Math.round(Math.random()*num);
startTime = System.currentTimeMillis();
list.add(index, a);
endTime = System.currentTimeMillis();
totalTime += (endTime-startTime);
}
System.out.println("insertTime: " + (totalTime)/1000.0 + "s size:" + list.size());
}
// 间隔插入
public static void insertTest(List list, int num) {
long totalTime=0;
long startTime=0;
long endTime=0;
for(int i=0; i<num; i++) {
int a = (int) Math.round(Math.random()*num);
startTime = System.currentTimeMillis();
list.add(2*i, a);
endTime = System.currentTimeMillis();
list.remove(2*i);
totalTime += (endTime-startTime);
}
System.out.println("insertTime: " + (totalTime)/1000.0 + "s size:" + list.size());
}
public static void main(String[] args) {
ArrayList<Integer> array = new ArrayList<Integer>();
LinkedList<Integer> link = new LinkedList<Integer>();
int num = 1000000;
int index = 250000;
//Test.addTest(link, num);
//Test.addTest(link, 500000);
//Test.insertTest(link, 500000, index);
//Test.insertTest(link, 500000);
Test.addTest(array, num);
//Test.addTest(array, 500000);
//Test.insertTest(array, 500000, index);
Test.insertTest(array, 500000);
}
}
