JDK源码分析– LinkedList

1 public class LinkedList<E>
2     extends AbstractSequentialList<E>
3     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
4 {
5 }

 1 //记录LinkedList当前节点数
 2 transient int size = 0;
 3 
 4 /**
 5  * Pointer to first node.
 6  * Invariant: (first == null && last == null) ||
 7  *            (first.prev == null && first.item != null)
 8  */
 9 //第一个节点
10 transient Node<E> first;
11 
12 /**
13  * Pointer to last node.
14  * Invariant: (first == null && last == null) ||
15  *            (last.next == null && last.item != null)
16  */
17 //最后一个节点
18 transient Node<E> last;

1 public LinkedList() {
2 }
3 
4 
5 public LinkedList(Collection<? extends E> c) {
6     this();
7     addAll(c);
8 }

 1 public boolean add(E e) {
 2 //将元素添加到链表末尾
 3     linkLast(e);
 4     return true;
 5 }
 6 void linkLast(E e) {
 7 　　//定义l节点，将尾节点暂存在该节点上
 8     final Node<E> l = last;
 9 　　//创建一个新节点，用于存储将要添加的元素，该节点前驱指向原先的尾节点l
10     final Node<E> newNode = new Node<>(l, e, null);
11 　　//重新赋值链表的为节点，更新为新创建的节点
12     last = newNode;
13 　　//如果尾节点为空，则说明该链表是一个空链表，那么需要为头节点初始化
14     if (l == null)
15         first = newNode; //此时链表只有一个节点，first和last是同一个节点
16     else
17         l.next = newNode; //将原先尾节点的后继指向新创建的节点
18 　　//链表长度自增
19     size++;
20 　　//操作数自增，用于迭代器迭代校验
21     modCount++;
22 }

 1 public void add(int index, E element) {
 2     //校验索引是否合法
 3     checkPositionIndex(index);
 4 
 5     //如果索引index和链表长度相同，那么相当于在链表为节点添加元素
 6     if (index == size)
 7 　　//将元素添加到为节点，同add()方法内部实现
 8         linkLast(element);
 9     else
10 　　/创建新节点，并插入到链表指定索引处
11         linkBefore(element, node(index));
12 }
13 
14 //获取原先索引为index的节点
15 Node<E> node(int index) {
16     // assert isElementIndex(index);
17     //如果索引indec位于链表前半段，则
18     if (index < (size >> 1)) {
19         Node<E> x = first;
20 　　//正向遍历找到索引为index的节点并返回
21         for (int i = 0; i < index; i++)
22             x = x.next;
23         return x;
24     } else {
25         Node<E> x = last;
26 　　//如果index位于链表后半段，则逆向遍历，查找索引为index的节点，并返回
27         for (int i = size - 1; i > index; i--)
28             x = x.prev;
29         return x;
30     }
31 }
32 
33 //插入新节点
34 //E e:将要插入的元素
35 // Node<E> succ 原先index索引处的节点
36 void linkBefore(E e, Node<E> succ) {
37     //获取index-1的节点（该节点将作为即将要插入节点的前驱）
38 　　final Node<E> pred = succ.prev;
39 　　//构造新节点，并初始化前驱节点为第index-1的节点，后继节点为之前第index的节点
40     final Node<E> newNode = new Node<>(pred, e, succ);
41 　　//修改原先index的前驱节点，指向新创建的节点
42     succ.prev = newNode;
43 　　//判断第index-1的节点，如果为空，则说明之前链表首节点为空，重新赋值首节点
44     if (pred == null)
45         first = newNode;
46     else
47 　　//将第index-1的节点后继指向新创建的节点
48         pred.next = newNode;
49 
50     size++;
51     modCount++;
52 }

 1 public E remove(int index) {
 2     //校验索引的合法性
 3     checkElementIndex(index);
 4 　　//移除当前索引处的节点, node(index)获取索引index处的节点
 5     return unlink(node(index));
 6 }
 7 private void checkElementIndex(int index) {
 8     if (!isElementIndex(index))
 9         throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
10 }
11 
12 unlink(Node<E> x) {
13     // assert x != null;
14 　　//暂存index处的节点
15     final E element = x.item;
16 　　//暂存index+1节点，后继节点
17     final Node<E> next = x.next;
18 　　//暂存第index-1节点，前驱节点
19     final Node<E> prev = x.prev;
20 
21 　　//1处理前驱：如果pre节点为空，则说明x就是首节点
22     if (prev == null) {
23 　　//直接将原先的后继next赋值到首节点上即可
24         first = next; 
25     } else {
26 　　//将index-1的后继指向index+1 
27         prev.next = next;
28 　　//删除index节点的前驱
29         x.prev = null;
30     }
31 
32     //2处理后继：如果next为空，说明x就是为节点
33     if (next == null) {
34 　　//直接将last赋值为原先节点的前驱
35         last = prev;
36     } else {
37 　　//将第index+1的前驱执行第index-1节点
38         next.prev = prev;
39         x.next = null;
40     }
41     //删除节点x的数据
42     x.item = null;
43 　　//链表长度-1
44     size--;
45     modCount++;
46     return element;
47 }