Java04——LinkedList详细介绍(源码解析)和使用示例

一、LinkedList介绍

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList 是非同步的。

LinkedList构造函数：

// 默认构造函数
LinkedList()

// 创建一个LinkedList，保护Collection中的全部元素。
LinkedList(Collection<? extends E> collection)

LinkedList的API

LinkedList的API
boolean       add(E object)
void          add(int location, E object)
boolean       addAll(Collection<? extends E> collection)
boolean       addAll(int location, Collection<? extends E> collection)
void          addFirst(E object)
void          addLast(E object)
void          clear()
Object        clone()
boolean       contains(Object object)
Iterator<E>   descendingIterator()
E             element()
E             get(int location)
E             getFirst()
E             getLast()
int           indexOf(Object object)
int           lastIndexOf(Object object)
ListIterator<E>     listIterator(int location)
boolean       offer(E o)
boolean       offerFirst(E e)
boolean       offerLast(E e)
E             peek()
E             peekFirst()
E             peekLast()
E             poll()
E             pollFirst()
E             pollLast()
E             pop()
void          push(E e)
E             remove()
E             remove(int location)
boolean       remove(Object object)
E             removeFirst()
boolean       removeFirstOccurrence(Object o)
E             removeLast()
boolean       removeLastOccurrence(Object o)
E             set(int location, E object)
int           size()
<T> T[]       toArray(T[] contents)
Object[]     toArray()

AbstractSequentialList简介

在介绍LinkedList的源码之前，先介绍一下AbstractSequentialList。毕竟，LinkedList是AbstractSequentialList的子类。

AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数。这些接口都是随机访问List的，LinkedList是双向链表；既然它继承于AbstractSequentialList，就相当于已经实现了“get(int index)这些接口”。

此外，我们若需要通过AbstractSequentialList自己实现一个列表，只需要扩展此类，并提供 listIterator() 和 size() 方法的实现即可。若要实现不可修改的列表，则需要实现列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。

二、LinkedList数据结构

LinkedList的继承关系

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.AbstractSequentialList<E>
                     ↳     java.util.LinkedList<E>

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}

LinkedList与Collection的关系

三、 LinkedList源码解析(基于JDK1.7)

在阅读源码之前，我们先对LinkedList的整体实现进行大致说明：
    LinkedList实际上是通过双向链表去实现的。既然是双向链表，那么它的顺序访问会非常高效，而随机访问效率比较低。
    既然LinkedList是通过双向链表的，但是它也实现了List接口{也就是说，它实现了get(int location)、remove(int location)等“根据索引值来获取、删除节点的函数”}。

Q：LinkedList是如何实现List的这些接口的，如何将“双向链表和索引值联系起来的”？
    实际原理非常简单，它就是通过一个计数索引值来实现的。例如，当我们调用get(int location)时，首先会比较“location”和“双向链表长度的1/2”；若前者大，则从链表头开始往后查找，直到location位置；否则，从链表末尾开始先前查找，直到location位置。
   这就是“双向链表和索引值联系起来”的方法。

好了，接下来开始阅读源码(只要理解双向链表，那么LinkedList的源码很容易理解的)。

有关LinkedList在JDK1.6和JDK1.7的区别以及优化，参看 JDK1.7-LinkedList循环链表优化，这里列出是1.7的源码

其中 Node：

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;
        }
    }

总结：
1、 LinkedList 实际上是通过双向链表去实现的。
        它包含一个非常重要的内部类：Entry。Entry是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点，下一个节点。
2、 从LinkedList的实现方式中可以发现，它不存在LinkedList容量不足的问题。
3、 LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中。
4、 LinkedList实现java.io.Serializable。当写入到输出流时，先写入“容量”，再依次写入“每一个节点保护的值”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。
5、 由于LinkedList实现了Deque，而Deque接口定义了在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。

总结起来如下表格：

6、 LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：

队列方法       等效方法
add(e)        addLast(e)
offer(e)      offerLast(e)
remove()      removeFirst()
poll()        pollFirst()
element()     getFirst()
peek()        peekFirst()

7、LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：

栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()

• 增
• addFirst(e)和offerFirst(e): 查的, 说addXxx是继承自List的, offerXxx是来自Queue. 
• addLast(e)和offerLast(e)
• 获取: 获取,但不删除元素。
• getFirst()和peakFirst(): 如果集合为空, 前者抛异常, 后者获取null. 
• getLast()和peakLast(): 同上
• 删: 获取,且删除元素。
• removeFirst()和pollFirst(): 如果集合为空, 前者抛异常, 后者获取null. 
• remove()和poll(): 同上
• removeLast()和pollLast(): 同上

四、LinkedList遍历方式

LinkedList遍历方式

LinkedList支持多种遍历方式。建议不要采用随机访问的方式去遍历LinkedList，而采用逐个遍历的方式。
1、通过迭代器遍历。即通过Iterator去遍历。

for(Iterator iter = list.iterator(); iter.hasNext();)
    iter.next();

2、通过快速随机访问遍历LinkedList

int size = list.size();
for (int i=0; i<size; i++) {
    list.get(i);        
}

3、通过另外一种for循环来遍历LinkedList

for (Integer integ:list) 
    ;

4、通过pollFirst()来遍历LinkedList

while(list.pollFirst() != null)
    ;

5、通过pollLast()来遍历LinkedList

while(list.pollLast() != null)
    ;

6、通过removeFirst()来遍历LinkedList

try {
    while(list.removeFirst() != null)
        ;
} catch (NoSuchElementException e) {
}

7、通过removeLast()来遍历LinkedList

try {
    while(list.removeLast() != null)
        ;
} catch (NoSuchElementException e) {
}

测试这些遍历方式效率的代码如下：

/**
 * linkedList 
 * @ClassName: LinkedList_test_1
 * @Description:
 * @author Xingle
 * @date 2014-5-20 上午9:48:33
 * 
 */
public class LinkedList_test_1 {

    public static void main(String[] args) {

        // 通过Iterator遍历LinkedList
        iteratorLinkedListThruIterator((LinkedList<Integer>) getLinkedList());
        // 通过快速随机访问遍历LinkedList
        iteratorLinkedListThruForeach((LinkedList<Integer>) getLinkedList());
        // 通过for循环的变种来访问遍历LinkedList
        iteratorThroughFor2((LinkedList<Integer>) getLinkedList());
        // 通过PollFirst()遍历LinkedList
        iteratorThroughPollFirst((LinkedList<Integer>) getLinkedList());
        // 通过PollLast()遍历LinkedList
        iteratorThroughPollLast((LinkedList<Integer>) getLinkedList());
        // 通过removeFirst()遍历LinkedList
        iteratorThroughRemoveFirst((LinkedList<Integer>) getLinkedList());
        // 通过removeLast()遍历LinkedList
        iteratorThroughRemoveLast((LinkedList<Integer>) getLinkedList());
    }

    /**
     * 通过RemoveLast()来遍历LinkedList
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:59:11
     */
    private static void iteratorThroughRemoveLast(LinkedList<Integer> list) {
        String name = "iteratorThroughRemoveFirst:";
        if (list == null)
            return;
        long start = getCurrentTime();
        try {
            while (list.removeLast() != null)
                ;
        } catch (NoSuchElementException e) {

        }
        long end = getCurrentTime();
        long interval = end - start;
        getPrint(name, interval);

    }

    /**
     * 通过RemoveFirst()来遍历LinkedList
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:58:36
     */
    private static void iteratorThroughRemoveFirst(LinkedList<Integer> list) {
        String name = "iteratorThroughRemoveFirst:";
        if (list == null)
            return;
        long start = getCurrentTime();
        try {
            while (list.removeFirst() != null)
                ;
        } catch (NoSuchElementException e) {
        }
        long end = getCurrentTime();
        long interval = end - start;
        getPrint(name, interval);

    }
    
    

    /**
     * 通过pollLast()来遍历LinkedList
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:57:37
     */
    private static void iteratorThroughPollLast(LinkedList<Integer> list) {
        String name = "iteratorThroughPollLast:";
        if (list == null)
            return;
        long start = getCurrentTime();
        while (list.pollLast() != null)
            ;
        long end = getCurrentTime();
        long interval = end - start;
        getPrint(name, interval);

    }

    /**
     * 通过pollFirst()来遍历LinkedList
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:48:59
     */
    private static void iteratorThroughPollFirst(LinkedList<Integer> list) {
        String name = "iteratorThroughPollFirst:";
        if (list == null)
            return;
        long start = getCurrentTime();
        while (list.pollFirst() != null)
            ;
        long end = getCurrentTime();
        long interval = end - start;
        getPrint(name, interval);
    }

    /**
     * 
     * @Description:
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:54:10
     */
    private static void getPrint(String name, long interval) {
        System.out.println(name + interval + " ms");

    }

    /**
     * 获取当前时间
     * @Description:
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:50:29
     */
    private static long getCurrentTime() {
        long start = System.currentTimeMillis();
        return start;
    }

    /**
     * 通过快速随机访问遍历LinkedList
     * 
     * @Description:
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:32:33
     */
    private static void iteratorThroughFor2(LinkedList<Integer> list) {
        String name = "iteratorLinkedListByForeachRandomAccess:";
        if (list == null)
            return;
        long start = getCurrentTime();
        int size = list.size();
        for (int i = 0; i < size; i++) {
            list.get(i);
        }
        long end = getCurrentTime();
        long interval = end - start;
        getPrint(name, interval);
    }

    /**
     * 通过另外一种for循环来遍历LinkedList
     * 
     * @Description:
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:32:31
     */
    private static void iteratorLinkedListThruForeach(LinkedList<Integer> list) {
        String name = "iteratorThroughForEach:";
        if (list == null)
            return;
        long start = getCurrentTime();
        for (Integer i : list)
            ;
        long end = getCurrentTime();
        long interval = end - start;
        getPrint(name, interval);
    }

    /**
     * 通过快迭代器遍历LinkedList
     * 
     * @Description:
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:32:23
     */
    private static void iteratorLinkedListThruIterator(LinkedList<Integer> list) {
        String name = "iteratorLinkedListThruIterator:";
        if (list == null)
            return;
        long start = getCurrentTime();

        for (Iterator<Integer> iter = list.iterator(); iter.hasNext();)
            iter.next();
        long end = getCurrentTime();
        long interval = end - start;
        getPrint(name, interval);
    }

    /**
     * 
     * @Description:
     * @param
     * @return
     * @author xingle
     * @data 2014-5-22 上午11:31:58
     */
    private static Object getLinkedList() {
        LinkedList<Integer> ls = new LinkedList<>();
        for (int i = 0; i < 100000; i++)
            ls.addLast(i);

        return ls;
    }

}

执行结果：

iteratorLinkedListThruIterator:13 ms
iteratorThroughForEach:9 ms
iteratorLinkedListByForeachRandomAccess:6886 ms
iteratorThroughPollFirst:7 ms
iteratorThroughPollLast:7 ms
iteratorThroughRemoveFirst:5 ms
iteratorThroughRemoveFirst:5 ms

由此可见，遍历LinkedList时，使用removeFist()或removeLast()效率最高。但用它们遍历时，会删除原始数据；若单纯只读取，而不删除，应该使用第3种遍历方式。
无论如何，千万不要通过随机访问去遍历LinkedList！

Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例