深入理解系列之JAVA数据结构（2）——LinkedList

深入理解系列之JAVA数据结构（2）——LinkedList
https://blog.csdn.net/u011552404/article/details/79834907?spm=1001.2014.3001.5502

1、LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
2、LinkedList相对于ArrayList来说，是可以快速添加，删除元素，ArrayList添加删除元素的话需移动数组元素，可能还需要考虑到扩容数组长度。
3、 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque接口，即能将LinkedList当作双端队列使用。 LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
4、 LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
5、 LinkedList 是非同步的。

同样，首先还是看下linkedList的属性：

public class LinkedList<E>  
    extends AbstractSequentialList<E>  
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{     
    //当前有多少个节点  
    transient int size = 0;  
    //第一个节点  
    transient Node<E> first;  
    //最后一个节点  
    transient Node<E> last;  1
2
3
4
5
6
7
8
9

其中使用transient修饰的参数指的是序列化的时候忽略该参数字段，使得该参数只能停留在内存中而不会被持久化在硬盘中或者传输到网络中！

链表相对来说就是节点的连接问题，在学数据结构的时候应该都比较熟悉，所以只有两个问题。

问题一、集合参数构造器的原理？

类似于ArrayList，默认构造函数什么都没做，即初始化一个空链表，只有在添加数据的时候才new一个新节点；传递集合的构造函数也是类似，首先把集合转变为一个数组，然后再遍历数组把各个数据连接起来，看源码：

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;  
}  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

问题二、获取特定位置的索引是怎么做的？

由于链表是双向链表，类参数维护的有一个节点数量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;  
    }  
}  1
2
3
4
5
6
7
8
9
10
11
12
13

其他：

1、同样，链表也会维护一个modCount！所以在使用迭代器的时候同样会出现ConcurrentModificationException异常！
2、链表维护的还有first和last节点，所以获取第一个节点和最后一个节点很方便；
3、链表有方法push其实就是调用addFirst(e)方法，pop调用的就是removeFirst()方法