嗯 今天看下 LinkedList，這個 最后會總結寫 ArrayList 的區別吧
image
-
先看下構造函數
public LinkedList() { } public LinkedList(Collection<? extends E> c) { this(); addAll(c); }
// 咳咳 怎么說呢 沒想到你是這樣的構造函數 什么都不干
在看LinkedList 的增刪改查之前 我們得有一個認知 就是LinkedList 的 數據結構是 鏈表（從名字就看出來了），他的每個 節點 都是存在一個 內部類中
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;
}
}
Node 節點 可以看出 LinkedList 是 一個雙向鏈表 存了他自己 和 next 和 prev
接下去我們就可以 真正開始看 增刪改查了
老規矩看下 add
- 增 add() ，addAll()
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
// 構建 node 節點
final Node<E> newNode = new Node<>(l, e, null);
//將最新的add 放到 最后
last = newNode;
// 如果尾節點為空 新加入的變成 頭結點
if (l == null)
first = newNode;
else// 否則 之前的last 的 next 連接到新加入的節點
l.next = newNode;
size++;// 數組size 變大
modCount++; // 增加修改次數
}
- 刪 remove
根據對象
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
根據 對象刪除 比較簡答 直接去 equals()
根據 下 標刪除
public E remove(int index) {
// 判斷是否越界
checkElementIndex(index);
return unlink(node(index));
}
// 這段代碼用到了 二分法查找 出node 節點
Node<E> node(int index) {
// assert isElementIndex(index);
// 有是size>>1 這個意思就是 size/2 （ >> 效率高）
// index list的左半部分的時候
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;
}
}
// unlink 就是清楚所有 有關節點 的鏈接然后 刪除連接 節點前后 的 next 和prev 在相互連接
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
// 如果當前節點的 prev 為空 則當前節點的next 變成頭節點
if (prev == null) {
first = next;
} else {//否則 prev的 next 連接 當前節點的next
prev.next = next;
x.prev = null;
}
if (next == null) { //如果next 則 prev 變成last
last = prev;
} else { // 否則 next prev 連接 當前節點的prev
next.prev = prev;
x.next = null;
}
x.item = null; // 當前節點 全部連接置空 （提醒jvm GC ）
size--; // 減少 數據大小
modCount++; //增加修改次數
return element; // 彈出 當前節點的值
}
- 改 set
public E set(int index, E element) {
checkElementIndex(index);
// 查處
Node<E> x = node(index);
//
E oldVal = x.item;
// 修改
x.item = element;
//返回
return oldVal;
}
查 get
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
嗯 看起來都很簡單的樣子 從源碼來說 讓我看看其他的擴展
這得從昨天 貼的 最后一段代碼 說起 ArrayList 和 LinkedList遍歷的時候
從今天可以看出來 LinkedList get 是 二分法查找 而 ArrayList 的get 是 直接數組的下標取出來 當然是 ArrayList 遍歷快
我們在比較下 remove
回憶一下 ArrayList 增 是 調用底層本地 native 方法 整個數組 拷貝 移動的數組位置 之后 數組向前移動一位
但是LinkedList 增 移動的時候 就很簡單了 unlink 改變下 鏈表 移動元素 前后的 prev 和next 就好了 理論上來說 是Linked remove 快點
實驗下：
static final int N=50000;
static long timeListByPrev(List list){
long start=System.currentTimeMillis();
Object o = new Object();
for(int i=0;i<N;i++)
list.add(0, o);
return System.currentTimeMillis()-start;
}
static long timeListByLast(List list){
long start=System.currentTimeMillis();
Object o = new Object();
for(int i=0;i<N;i++)
list.add(i);
return System.currentTimeMillis()-start;
}
public static void main(String[] args) {
System.out.println("前置插入 ArrayList耗時："+timeListByPrev(new ArrayList()));
System.out.println("前置插入 LinkedList耗時："+timeListByPrev(new LinkedList()));
System.out.println("后置插入 ArrayList耗時："+timeListByLast(new ArrayList()));
System.out.println("后置插入 LinkedList耗時："+timeListByLast(new LinkedList()));
}
out:
前置插入 ArrayList耗時：288
前置插入 LinkedList耗時：4
后置插入 ArrayList耗時：4
后置插入 LinkedList耗時：3
可以看出 差距很大 四舍五入 差100倍 （本機測試 不代表任何基準）
