LinkedList
- 優點:插入、刪除元素效率高
- 缺點:遍歷數據效率低。
本文基於JDK1.8.131的源碼分析(其他版本的源碼,不做表述)。
數據結構
底層實現,雙向鏈表
1.構造方法
構造方法以及涉及到的方法:
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
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;
}
}
與ArrayList不同,LinkedList有兩個構造方法,一個無參,一個是傳入一個集合的參數。無參的沒有初始化什麼東西;傳入集合參數的構造方法,裏面使用addAll方法將參數添加到LinkedList集合中了。在這裏同樣分析添加的方法(add(E e)),其他方法先不看。
2.添加元素方法
add(E e)方法以及涉及到的方法:
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
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;
}
}
當使用LinkedList集合添加元素的時候,本質上並不是直接添加這個元素到集合中,而是對這個元素進行了一次封裝,將其封裝成Node節點,再將Node添加到集合。這樣看來,LinkedList集合是將每一個元素都看成了Node,添加元素的過程也是添加Node過程。
前面說過,LinkedList是雙向鏈表,他的每個節點都保存着Node<E> prev和Node<E> next(即每個節點都保存着指向前一個和後一個Node<E>的地址引用),這使得我們可以從第一個Node<E>的節點,一直查找next的節點,這樣就能對整個隊列進行正序遍歷(同樣可以從最後的一個節點,一直查找prev的節點,就可以從後到前進行倒序遍歷)。
上邊的添加元素的方法,首先將這個元素e封裝成Node<E> newNode ,因爲是將元素添加到鏈表的尾部,所以這個new Node的第三個參數傳入null;其次將last賦值給l變量,這個last(全局變量)指的是鏈表的最後一個節點,因爲要在尾部添加新的節點,所以last指向newNode節點(這裏有個if else 判斷,這個情況是size是0的時候,LinkedList添加第一個元素,first和last都指向newNode);最後是維護鏈表的大小(size)。
3.刪除方法
刪除方法remove(int):
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
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;
}
}
E unlink(Node<E> x) {
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
在刪除元素的時候,會首先檢查index的大小是否正好在LinkedList的size內(否則會拋出IndexOutOfBoundsException異常);其次linkedList會先找出元素所在的那個節點;最後將這個節點進行刪除。
node(int)方法按index查找節點;會先根據index與linkedList size的一半比較大小,如果小於,就從頭開始查找;大於就從尾部開始查找(與之前的方法相比,jdk8做了優化)。
刪除方法(unlink)。鏈表中的刪除,可以理解爲解除關聯。比如1、2、3;三個元素,刪除2這個元素,只需要將1元素的next節點指向3,將3元素的prev指向1,再把2所在的節點的元素置空即可。unlink方法大意如此。
從上面分析add(e)和remove(index)方法,也可以看出添加刪除的效率要比ArrayList高,因爲LinkedList不需要維護角標,元素的位置不需要移動。
addAll和removeAll不再贅述分析,這兩個方法和我們分析上面的原理一致。
附錄:
ArrayList與LinkedList效率差別
@Test
public void testLV(){
long a = System.currentTimeMillis();
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("1");
linkedList.add("2");
for (int i =0;i< 1000000;i++){
linkedList.add(1,"A "+i);
}
long b = System.currentTimeMillis();
System.out.println(b -a);
long c = System.currentTimeMillis();
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("1");
arrayList.add("2");
for (int i =0;i< 1000000;i++){
arrayList.add(1,"A "+i);
}
long d = System.currentTimeMillis();
System.out.println(d - c);
}
每次插入都從1的位置插入。
結果:
第一次
LinkedList使用時間: 193
ArrayList使用時間: 127495
第二次
LinkedList使用時間: 179
ArrayList使用時間: 128867
第三次
LinkedList使用時間: 184
ArrayList使用時間: 130904
插入的數據越多,ArrayList維護的角標也越多,所以效率低。