Java LinkedList的实现原理

LinkedList是Java List类型的集合类的一种实现，此外，LinkedList还实现了Deque接口。本文基于Java1.8，对于LinkedList的实现原理做一下详细讲解。下面就随动力节点java培训机构看看java linkedlist的实现原理。

　　(Java1.8源码：http://docs.oracle.com/javase/8/docs/api/)

　　一、java LinkedList实现原理总结

　　Java LinkedList的实现原理总结如下：

　　1、数据存储是基于双向链表实现的。

　    2、插入数据很快。先是在双向链表中找到要插入节点的位置index，找到之后，再插入一个新节点。 双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。

　　3、删除数据很快。先是在双向链表中找到要插入节点的位置index，找到之后，进行如下操作：node.previous.next = node.next;node.next.previous = node.previous;node = null 。查找节点过程和插入一样。

　　4、获取数据很慢，需要从Head节点进行查找。

　　5、遍历数据很慢，每次获取数据都需要从头开始。

　　二、ArrayList的实现原理详解

　　1、LinkedList概述

　　List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素(包括 null)。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

　　此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

　　所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表(从靠近指定索引的一端)。

　　注意：此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。(结构修改指添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。)这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：

　　List list = Collections.synchronizedList(new LinkedList(...));

　　此类的 iterator 和 listIterator 方法返回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任意发生不确定行为的风险。

　　注意：迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何硬性保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

2、LinkedList的实现

Java代码：private transient Entryheader = new Entry(null, null, null);   

　　这个成员变量是LinkedList的关键，它在链表中没有实际数据意义，是链表的标示(通俗一点就是链表的第一个无意义的元素)，而且被修饰为transient，标示着他不会被序列化。header也可以当做队列末尾的元素，因为是双向列表，所以header.next末尾元素后边的元素就成了队首元素，header.previous就是队尾元素了，看一下它的添加方法。

Java代码

public void addFirst(E paramE) {  

    addBefore(paramE, this.header.next);//队首  

}  

public void addLast(E paramE) {  

    addBefore(paramE, this.header);//队尾  

}  

以上两个方法都利用addBefore方法将元素添加到指定对象之前。

 addFirst向队头加元素，将元素paramE添加到header.next-队首元素之前；

 addLast向队尾加元素，将元素paramE添加到header之前；

        再看一下addBefore(E e,Entryentry)函数：

Java代码

/*** 

 * 要添加的元素：paramE 

 * 目标对象：paramEntry 

 */  

private EntryaddBefore(E paramE, EntryparamEntry)  

{  

    //要添加的对象  

    Entry localEntry = new Entry(paramE, paramEntry, paramEntry.previous);  

    /*** 

     * localEntry.previous = paramEntry.previous 

     * 目标对象的前一元素的后一元素（localEntry.previous.next）设置为要添加的对象 

     */  

    localEntry.previous.next = localEntry;  

    /*** 

     * localEntry.next = paramEntry 

     * 目标对象的前一元素（localEntry.next.previous）设置为要添加的对象 

     */  

    localEntry.next.previous = localEntry;  

    this.size += 1;  

    this.modCount += 1;  

    return localEntry;  

}  

链表的基本特性是插入速度快，遍历速度慢，下面两个方法可以反映这个特点：

Java代码 

public int indexOf(Object paramObject) {  

    int i = 0;  

    Entry localEntry;  

    /*** 

     * 遍历规则：从头到尾，序列呈升序状态 

     */  

    if (paramObject == null)  

        for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {  

            if (localEntry.element == null)  

                return i;  

            i++;  

        }  

    else {  

        for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {  

            if (paramObject.equals(localEntry.element))  

                return i;  

            i++;  

        }  

    }  

    return -1;  

}  

public int lastIndexOf(Object paramObject) {  

    int i = this.size;  

    Entry localEntry;  

    /*** 

     * 遍历规则：从尾到头，序列呈降序状态 

     */  

    if (paramObject == null) {  

        for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {  

            i--;  

            if (localEntry.element == null)  

                return i;  

            }  

    }else {  

        for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {  

            i--;  

            if (paramObject.equals(localEntry.element))  

                return i;  

        }  

    }  

    return -1;  

}  

值得注意的是，链表插入数据速度快的说法是相对的，在数据量很小的时候，ArrayList的插入速度不仅不比LinkedList慢，而且还快很多（本文不作介绍，读者可自行测试），只有当数据量达到一定量，这个特性才会体现出来，这需要开发者明确需求场景。

LinkedList的方法entry(int index)类似ArrayList的get(int index)：

Java代码

/*** 

 * 根据序号获取Entry对象 

 */  

private Entryentry(int paramInt) {  

    if ((paramInt < 0) || (paramInt >= this.size)) {  

        throw new IndexOutOfBoundsException("Index: " + paramInt + ", Size: " + this.size);  

    }  

    Entry localEntry = this.header;  

    int i;  

    /*** 

     * 二分法：目标序号小于Size的1/2，则从头到尾 

     *             如果大于Size的1/2，则从尾到头 

     */  

    if (paramInt < this.size >> 1) {  

        for (i = 0; i <= paramInt; i++)  

            localEntry = localEntry.next;  

    } else {  

        for (i = this.size; i > paramInt; i--)  

            localEntry = localEntry.previous;  

    }  

    return localEntry;  

}  

LinkedList还提供了降序迭代器，如下：

Java代码

public IteratordescendingIterator()   {  

        return new DescendingIterator(null);  

    }  

关于降序迭代的具体实现可以看看源码，很简单

LinkedList是针对链表操作的一个比较全的实现，对于频繁的数据插入有较高效率，研究其具体实现可更有利于准确的使用它。该类的toArray、clone以及其他一些方法很值得参考。

3、LinkedList.Entry

LinkedList的内部类Entry是实现Deque接口的基本操作单元，其结构如下：

Java代码

private static class Entry  

{  

    E element;  

    Entrynext;  

    Entryprevious;  

    /*** 

     * 构造方法：目标对象paramE将被放置在paramEntry1之前，paramEntry2之后 

     */  

    Entry(E paramE, EntryparamEntry1, EntryparamEntry2)  

    {  

        this.element = paramE;  

        this.next = paramEntry1;  

        this.previous = paramEntry2;  

    }  

}

4、内部迭代器：ListItr

虽然上层父类AbstractList已经实现了迭代器，但LinkedList的直接父类AbstractSequentialList给子类重新定义个一个需要实现的迭代器的抽象方法，代码如下：

Java代码  

public abstract class AbstractSequentialListextends AbstractList{  

    /*** 

     * 返回子类实现的迭代器 

     */  

    public Iteratoriterator() {  

        return listIterator();  

    }  

    public abstract ListIteratorlistIterator(int paramInt);  

}  

此处实现的迭代器内部机制跟AbstractList基本一致。

此类的迭代器的实现机制可以通过ListItr的remove方法来分析，同时也可分析Java对双端队列的处理办法。

Java代码

/*** 

 * 当前指针位置：this.next 

 * 当前所操作的对象：this.lastReturned 

 */  

public void remove() {  

    checkForComodification();  

    LinkedList.Entry localEntry = this.lastReturned.next;  

    try {  

        LinkedList.this.remove(this.lastReturned);  

    } catch (NoSuchElementException localNoSuchElementException) {  

        throw new IllegalStateException();  

    }  

    /*** 

     * 当链表的size为0，指针会指向this.header，其他方法（如set方法）将以此判断当前操作对象的状态 

     */  

    if (this.next == this.lastReturned)  

        this.next = localEntry;  

    else  

        this.nextIndex -= 1;  

    /*** 

     * 调用LinkedList.this.remove(E)之后 

     * 当前操作对象this.lastReturned指向的对象被设置为this.header（原对象为null） 

     * 指针移动到this.lastReturned.next 

     */  

    this.lastReturned = LinkedList.this.header;  

    //修改次数加1  

    this.expectedModCount += 1;  

}  

以上就是动力节点java培训机构小编介绍的“Java LinkedList的实现原理”的内容，希望能够帮助到大家，更多java最新资讯请继续关注动力节点java培训机构官网，每天会有精彩内容分享与你。

相关免费视频教程推荐

java LinkedList视频教程下载：http://www.bjpowernode.com/xiazai/2483.html