LinkedList源码解读

---

title: LinkedList源码解读 tags:

• JCF
• LinkedList
• Queue
• Deque categories: jcf date: 2017-09-30 11:43:57

---

List中除了ArrayList我们最常用的就是LinkedList了。

LInkedList与ArrayList的最大区别在于元素的插入效率和随机访问效率

可以参考最熟悉的ArrayList

惯例发出类图

大概出乎大家意料的是LinkedList除了是List还是Queue。

Java 在1.5引入了Queue容器在1.6引入了Deque容器

我们看一下Deque具体多了那些接口

A collection designed for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, extraction, and inspection operations. Each of these methods exists in two forms: one throws an exception if the operation fails, the other returns a special value (either null or false, depending on the operation). The latter form of the insert operation is designed specifically for use with capacity-restricted Queue implementations; in most implementations, insert operations cannot fail.

	Throws exception	Returns special value
Insert	add(e)	offer(e)
Remove	remove()	poll()
Examine	element()	peek()

Deque在Queue的基础上增加了双端操作的方法

A linear collection that supports element insertion and removal at both ends. The name deque is short for "double ended queue" and is usually pronounced "deck". Most Dequeimplementations place no fixed limits on the number of elements they may contain, but this interface supports capacity-restricted deques as well as those with no fixed size limit.

This interface defines methods to access the elements at both ends of the deque. Methods are provided to insert, remove, and examine the element. Each of these methods exists in two forms: one throws an exception if the operation fails, the other returns a special value (either null or false, depending on the operation). The latter form of the insert operation is designed specifically for use with capacity-restricted Deque implementations; in most implementations, insert operations cannot fail.

The twelve methods described above are summarized in the following table:

	First Element (Head)	Last Element (Tail)
	Throws exception	Special value	Throws exception	Special value
Insert	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
Remove	removeFirst()	pollFirst()	removeLast()	pollLast()
Examine	getFirst()	peekFirst()	getLast()	peekLast()

This interface extends the Queue interface. When a deque is used as a queue, FIFO (First-In-First-Out) behavior results. Elements are added at the end of the deque and removed from the beginning. The methods inherited from the Queue interface are precisely equivalent to Deque methods as indicated in the following table:

Queue Method	Equivalent Deque Method
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

Deques can also be used as LIFO (Last-In-First-Out) stacks. This interface should be used in preference to the legacy Stack class. When a deque is used as a stack, elements are pushed and popped from the beginning of the deque. Stack methods are precisely equivalent to Deque methods as indicated in the table below:

Stack Method	Equivalent Deque Method
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

Note that the peek method works equally well when a deque is used as a queue or a stack; in either case, elements are drawn from the beginning of the deque.

队列（主要是阻塞 有界/无界 队列）和双向队列的出现为生产者消费者模式提供了极好的实现（设想如果需要各种唤醒等操作，Java也不会有今天这种规模的生态圈）

来看一下LinkedList的构造函数

    /**
     * Constructs an empty list.
     */
    public LinkedList() {
    }
     
    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param  c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
复制代码

基本上非常轻量级没有太多的初始化工作，并且由于并非使用数组来做实现因此也不存在一些负载因子来影响性能的参数

基本上就是较为经典的链表实现的过程

    /**
     * Links e as first element.
     */
    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++;
    }
     
    /**
     * Links e as last element.
     */
    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++;
    }
复制代码

基于双向队列封装了两端特殊的API 同时由于实现了Deque因此也提供了一个反序的迭代器(支持反序迭代)

    /**
     * @since 1.6
     */
    public Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }
     
    /**
     * Adapter to provide descending iterators via ListItr.previous
     */
    private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());
        public boolean hasNext() {
            return itr.hasPrevious();
        }
        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
    }
复制代码

由于支持双向迭代，因此数据结构必须是双向链表，包含next指针和prev指针

    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;
        }
    }
复制代码

由于这种结构因此请不要使用如下迭代方式

    for(int i = 0 ; i < size ; i++) {
     system.out.println(list.get(i));
    }
复制代码

具有良好的插入和删除特性

这也是上篇文章中利用LinkedList来作为性能改善的原因