6.Java集合-LinkedList实现原理及源码分析

Java中LinkedList的部分源码（本文针对1.7的源码）

LinkedList的基本结构

　　jdk1.7之后，node节点取代了 entry ，带来的变化是，将1.6中的环形结构优化为了直线型链表结构，从双向循环链表变成了双向链表

　　在LinkedList中，我们把链子的“环”叫做“节点”，每个节点都是同样的结构。节点与节点之间相连，构成了我们LinkedList的基本数据结构，也是LinkedList的核心。

　　我们再来看一下LinkedList在jdk1.6和1.7之间结构的区别

LinkedList的构造方法

　　LinkedList包含3个全局参数，size存放当前链表有多少个节点。

　　first为指向链表的第一个节点的引用

　　last为指向链表的最后一个节点的引用

LinkedList的构造方法有两个，一个是无参构造，一个是传入Collection对象的构造

// 什么都没做，是一个空实现  
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);  
    // 将给定的Collection对象转为Object数组  
    Object[] a = c.toArray();  
    int numNew = a.length;  
    // 数组为空的话，直接返回false  
    if (numNew == 0)  
        return false;  
    // 数组不为空  
    Node<E> pred, succ;  
    if (index == size) {  
        // 构造方法调用的时候，index = size = 0，进入这个条件。  
        succ = null;  
        pred = last;  
    } else {  
        // 链表非空时调用，node方法返回给定索引位置的节点对象  
        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; // 将当前链表最后一个节点赋值给last  
    } else {  
        // 链表非空时，将断开的部分连接上  
        pred.next = succ;  
        succ.prev = pred;  
    }  
    // 记录当前节点个数  
    size += numNew;  
    modCount++;  
    return true;  
}  

注：Node是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;  
    }  
}

　　

　　对与两种构造方法，总结起来，可以概括为：无参构造为空实现。有参构造传入Collection对象，将对象转为数组，并按遍历顺序将数组首尾相连，全局变量first和last分别指向这个链表的第一个和最后一个。

 

 LinkList部分方法分析

　　addFirst/addLast分析

public void addFirst(E e) {  
    linkFirst(e);  
}  
  
private void linkFirst(E e) {  
    final Node<E> f = first;  
    final Node<E> newNode = new Node<>(null, e, f); // 创建新的节点，新节点的后继指向原来的头节点，即将原头节点向后移一位，新节点代替头结点的位置。  
    first = newNode;  
    if (f == null)  
        last = newNode;  
    else  
        f.prev = newNode;  
    size++;  
    modCount++;  
} 　

　　加入一个新的节点，看方法名就能知道，是在现在的链表的头部加一个节点，既然是头结点，那么头结点的前继必然为null，所以这也是Node<E> newNode = new Node<>(null, e, f);这样写的原因。

　　之后将first指向了newNode ，指定这个节点以后就就是我们的头结点

　　之后对原来头节点进行了判断，若在插入元素之前头结点为null，则当前加入的元素就是第一个几点，也就是头结点，所以当前的状况就是：头结点=刚刚加入的节点=尾节点。

　　若在插入元素之前头结点不为null，则证明之前的链表是有值的，那么我们只需要把新加入的节点的后继指向原来的头结点，而尾节点则没有发生变化。这样一来，原来的头结点就变成了第二个节点了。达到了我们的目的。

　　addLast方法在实现上是个addFirst是一致的，这里就不在赘述了。有兴趣的朋友可以看看源代码。

　　其实，LinkedList中add系列的方法都是大同小异的，都是创建新的节点，改变之前的节点的指向关系。仅此而已。

　　getFirst/getLast方法分析

public E getFirst() {  
    final Node<E> f = first;  
    if (f == null)  
        throw new NoSuchElementException();  
    return f.item;  
}  
  
public E getLast() {  
    final Node<E> l = last;  
    if (l == null)  
        throw new NoSuchElementException();  
    return l.item;  
}

　　get方法分析（node方法的调用）

public E get(int index) {  
    // 校验给定的索引值是否在合理范围内  
    checkElementIndex(index);  
    return node(index).item;  
}  
  
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;  
    }  
}  

　　注：关键在于，判断给定的索引值，若索引值大于整个链表长度的一半，则从后往前找，若索引引用值小于整个链表长度的一半，则从前往后找。这样就可以保证，不管链表的长度有多大，搜索的时候最多只搜索链表长度的一半就可以找打，大大提升了效率

　　removeFirst/removeLast方法分析

public E get(int index) {  
    // 校验给定的索引值是否在合理范围内  
    checkElementIndex(index);  
    return node(index).item;  
}  
  
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;  
    }  
}  

　　摘掉头结点，将原来的第二个节点变为头结点，改变first的指向，若之前仅剩一个节点，移除之后全部置为null

　　对于LinkList的其他方法，大致上都是包装了以上这几个方法

关于集合的一个小补充：

　　在ArrayList，LinkedList，HashMap等等的增、删、改方法中，我们总能看到modCount的身影，modCount字面意思就是修改次数，但为什么要记录modCount的修改次数呢？

　　大家发现一个公共特点没有，所有使用modCount属性的集合全是线程不安全的，这是为什么呢？说明modCount 可能和线程安全有关

　　

　　阅读源码，发现这玩意只有在本数据结构对应的迭代器中才使用，以HashMap为例：

　　

private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;        // next entry to return
        int expectedModCount;   // For fast-fail
        int index;              // current slot
        Entry<K,V> current;     // current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }

        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

　　由以上代码可以看出，在一个迭代器初始的时候会赋予它调用这个迭代器的对象的mCount，如果在迭代器遍历的过程中，一旦发现这个对象的mcount和迭代器存储的mcount 不一样，那就抛出异常

        所以在以下情况下，会抛出异常：1.单线程的情况下，使用迭代器对象进行遍历，但是在修改长度，使用的是对象本身，对象的mcount产生变化，但是迭代器的mcount不变，差异产生，抛出异常

        2.多线程情况下，且集合为共享变量，那么在使用迭代器遍历的时候，如果其他线程修改对象本身的mcount，那么也会产生差异，抛出异常

　　下面详细解释：

　　Fail-Fast机制

　　我们知道java.util.HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓的fail-fast策略。这一策略在源码中的实现是通过 modCount 域，modCount顾名思义就是修改次数，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。在迭代过程中，判断 modCount跟expectedModCount是否相等，如果不相等就表示，我还在迭代呢，就有其他线程对Map进行了修改，注意到 modCount 声明为 volatile，保证线程之间修改的可见性。

　　所以在这里和大家建议，当大家遍历那些非线程安全的数据结构时，尽量使用迭代器