java集合中LinkedList源码浅析

最新推荐文章于 2022-10-08 10:43:27 发布
最新推荐文章于 2022-10-08 10:43:27 发布
阅读量824 收藏
点赞数
分类专栏： java编程思想 java集合 文章标签： LinkedList源码分析 java集合链表 java中LinkedList 源码分析 LinkedList

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

链表操作优点：1.因为每个结点记录下个结点的引用，则在进行插入和删除操作时，只需要改变对应下标下结点的引用即可

              缺点：1.要得到某个下标的数据，不能通过下标直接得到，需要遍历整个链表。

但是在3，4W条数据下，JDK中的ArrayList何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。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。


LinkedList的声明

[java] view plain copy print ?
  1. public class LinkedList<E>  
  2.     extends AbstractSequentialList<E>  
  3.     implements List<E>, Deque<E>/*这是双端队列接口，这个接口扩展了Queue接口，提供了更多的方法，比如push,pop等*/, Cloneable, java.io.Serializable  
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>/*这是双端队列接口，这个接口扩展了Queue接口，提供了更多的方法，比如push,pop等*/, Cloneable, java.io.Serializable

所以LinkedList可以被用作Stack,Queue和Deque

 

来看一下链表结点的 定义

[java] view plain copy print ?
  1. private static class Entry<E> {  
  2.     E element;  
  3.     Entry<E> next;  
  4.     Entry<E> previous; //由此可以看出LinkedList是一个双向链表  
  5.    
  6.     Entry(E element, Entry<E> next, Entry<E> previous) {  
  7.         this.element = element;  
  8.         this.next = next;  
  9.         this.previous = previous;  
  10.     }  
private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous; //由此可以看出LinkedList是一个双向链表
 
    Entry(E element, Entry<E> next, Entry<E> previous) {
        this.element = element;
        this.next = next;
        this.previous = previous;
    }

LinkedList中声明了下面两个实例变量：

//头结点，起标记作用，并不记录元素

private transient Entry<E> header = new Entry<E>(null, null, null);

//链表的大小 ，即链表中元素的个数

    private transient int size = 0;

 

我们可以看到这两个 就是都被声明成了transient，所以在序列化的过程中会忽略它们，但是LinkedList提供的序列化方法writeObject(java.io.ObjectOutputStream s)中却序列化了size，并且将除header之外的所有结点都 写到序列化文件中了，那为什么要把size声明成transient呢，不解。。求解释。。

 

几个重要的方法：

[java] view plain copy print ?
  1. /** 
  2.      * Returns the indexed entry. 
  3.     根据给定的索引值离表头近还是离表尾近决定从头还是从尾开始遍历 
  4.      */  
  5.     private Entry<E> entry(int index) {  
  6.         if (index < 0 || index >= size)  
  7.             throw new IndexOutOfBoundsException("Index: "+index+  
  8.                                                 ", Size: "+size);  
  9.         Entry<E> e = header;  
  10.         if (index < (size >> 1)) { //如果较靠近有表头  
  11.             for (int i = 0; i <= index; i++)  
  12.                 e = e.next;  
  13.         } else { //较靠近表尾  
  14.             for (int i = size; i > index; i--)  
  15.                 e = e.previous;  
  16.         }  
  17.         return e;  
  18. }  
/**
     * Returns the indexed entry.
	根据给定的索引值离表头近还是离表尾近决定从头还是从尾开始遍历
     */
    private Entry<E> entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) { //如果较靠近有表头
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else { //较靠近表尾
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
}

[java] view plain copy print ?
  1. /**  
  2. *将元素e添加到entry结点之前  
  3. */  
  4. private Entry<E> addBefore(E e, Entry<E> entry) {  
  5.     Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);  
  6.     newEntry.previous.next = newEntry; //将新结点与前后结点相连接   
  7.     newEntry.next.previous = newEntry;  
  8.     size++;  
  9.     modCount++;  
  10.     return newEntry;  
  11.     }  
  12.   
  13.   
  14. /** 
  15. *删除给定的结点e 
  16. */  
  17.     private E remove(Entry<E> e) {  
  18.     if (e == header)  
  19.         throw new NoSuchElementException();  
  20.   
  21.         E result = e.element;  
  22.     e.previous.next = e.next;  
  23.     e.next.previous = e.previous;  
  24.         e.next = e.previous = null;  
  25.         e.element = null;  
  26.     size--;  
  27.     modCount++;  
  28.         return result;  
  29.     }  
  30.   
  31.   
  32.   
  33. /**  
  34. *从表头开始遍历，返回此元素在表中的第一个位置 
  35.      */  
  36.     public int indexOf(Object o) {  
  37.         int index = 0;  
  38.         if (o==null) { //如果传入的元素是null，则不能调用 eqauls方法进行比较  
  39.             for (Entry e = header.next; e != header; e = e.next) {  
  40.                 if (e.element==null)  
  41.                     return index;  
  42.                 index++;  
  43.             }  
  44.         } else {  
  45.             for (Entry e = header.next; e != header; e = e.next) {  
  46.                 if (o.equals(e.element))  
  47.                     return index;  
  48.                 index++;  
  49.             }  
  50.         }  
  51.         return -1;  
  52.     }  
  53.   
  54. /** 
  55. *默认的添加动作，可以看到这个方法是把新元素添加 到表尾 
  56. */  
  57. public boolean add(E e) {  
  58.     addBefore(e, header); //加到头结点之前 ，即表尾  
  59.         return true;  
  60.     }  
  61.   
  62. /** 
  63. *默认的删除动作是删除链表的第一个元素，所以说在默认情况下，LinkedList其实扮*演的是一个队列的角色 
  64. */  
  65. public E remove() {  
  66.         return removeFirst();  
  67.     }  
  68.   
  69. /** 
  70. *返回第一个元素 
  71. */  
  72. public E peek() {  
  73.         if (size==0)  
  74.             return null;  
  75.         return getFirst();  
  76.     }  
/** 
*将元素e添加到entry结点之前 
*/
private Entry<E> addBefore(E e, Entry<E> entry) {
	Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
	newEntry.previous.next = newEntry; //将新结点与前后结点相连接 
	newEntry.next.previous = newEntry;
	size++;
	modCount++;
	return newEntry;
    }


/**
*删除给定的结点e
*/
    private E remove(Entry<E> e) {
	if (e == header)
	    throw new NoSuchElementException();

        E result = e.element;
	e.previous.next = e.next;
	e.next.previous = e.previous;
        e.next = e.previous = null;
        e.element = null;
	size--;
	modCount++;
        return result;
    }



/** 
*从表头开始遍历，返回此元素在表中的第一个位置
     */
    public int indexOf(Object o) {
        int index = 0;
        if (o==null) { //如果传入的元素是null，则不能调用 eqauls方法进行比较
            for (Entry e = header.next; e != header; e = e.next) {
                if (e.element==null)
                    return index;
                index++;
            }
        } else {
            for (Entry e = header.next; e != header; e = e.next) {
                if (o.equals(e.element))
                    return index;
                index++;
            }
        }
        return -1;
    }

/**
*默认的添加动作，可以看到这个方法是把新元素添加 到表尾
*/
public boolean add(E e) {
	addBefore(e, header); //加到头结点之前 ，即表尾
        return true;
    }

/**
*默认的删除动作是删除链表的第一个元素，所以说在默认情况下，LinkedList其实扮*演的是一个队列的角色
*/
public E remove() {
        return removeFirst();
    }

/**
*返回第一个元素
*/
public E peek() {
        if (size==0)
            return null;
        return getFirst();
    }

可以看出，如果表为空的时候 ，这个方法并不会抛出异常，而是返回null，而传统的（在Collections中声明的）方法则会抛出异常。相似的方法还有：poll,但请注意pop方法在表空的时候 会抛出异常。

 

还有一点请注意，如果先返回list的Iterator，之后 又对链表进行了添加删除修改操作，那么如果再使用返回的那个Iterator就会抛出ConcurrentModificationException。

 

 

最后看一下LinkedList是如何序列化和反序列化的，如果对这两个反序列化中用到的这两个回调方法有疑问的，可以看我的这篇博客 http://blog.csdn.net/moreevan/article/details/6697777

[java] view plain copy print ?
  1. /** 
  2.      * Save the state of this <tt>LinkedList</tt> instance to a stream (that 
  3.      * is, serialize it). 
  4.      * 
  5.      * @serialData The size of the list (the number of elements it 
  6.      *             contains) is emitted (int), followed by all of its 
  7.      *             elements (each an Object) in the proper order. 
  8.      */  
  9.     private void writeObject(java.io.ObjectOutputStream s)  
  10.         throws java.io.IOException {  
  11.     // Write out any hidden serialization magic  
  12.     s.defaultWriteObject();  
  13.   
  14.         // Write out size  
  15.         s.writeInt(size);  
  16.   
  17.     // Write out all elements in the proper order.  
  18.         for (Entry e = header.next; e != header; e = e.next)  
  19.             s.writeObject(e.element);  
  20.     }  
  21.   
  22.     /** 
  23.      * Reconstitute this <tt>LinkedList</tt> instance from a stream (that is 
  24.      * deserialize it). 
  25.      */  
  26.     private void readObject(java.io.ObjectInputStream s)  
  27.         throws java.io.IOException, ClassNotFoundException {  
  28.     // Read in any hidden serialization magic  
  29.     s.defaultReadObject();  
  30.   
  31.         // Read in size  
  32.         int size = s.readInt();  
  33.   
  34.         // Initialize header  
  35.         header = new Entry<E>(null, null, null);  
  36.         header.next = header.previous = header;  
  37.   
  38.     // Read in all elements in the proper order.  
  39.     for (int i=0; i<size; i++)  
  40.             addBefore((E)s.readObject(), header);  
  41.     }  
/**
     * Save the state of this <tt>LinkedList</tt> instance to a stream (that
     * is, serialize it).
     *
     * @serialData The size of the list (the number of elements it
     *             contains) is emitted (int), followed by all of its
     *             elements (each an Object) in the proper order.
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
	// Write out any hidden serialization magic
	s.defaultWriteObject();

        // Write out size
        s.writeInt(size);

	// Write out all elements in the proper order.
        for (Entry e = header.next; e != header; e = e.next)
            s.writeObject(e.element);
    }

    /**
     * Reconstitute this <tt>LinkedList</tt> instance from a stream (that is
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
	// Read in any hidden serialization magic
	s.defaultReadObject();

        // Read in size
        int size = s.readInt();

        // Initialize header
        header = new Entry<E>(null, null, null);
        header.next = header.previous = header;

	// Read in all elements in the proper order.
	for (int i=0; i<size; i++)
            addBefore((E)s.readObject(), header);
    }

综上 ，我们可以看出。LinkedList是一个双向链表，它可以被当成栈，队列或双端队列来使用。它也提供 了随机访问元素的方法，不过这个访问的时间复杂度并不像ArrayList是O（1），而是O（n）。它删除给定位置的元素

的效率其实并不比ArrayList高。但它删除特定元素的效率 要比ArrayList高。

Java我人生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
Java 集合之LinkedList源码分析
01-20
Java API中提供了链表的Java实现—LinkedList下。LinkedList是通过节点的连接实现链表的数据结构，向linkedList中插入或删除元素的速度是特别快，而随机访问的速度相对较慢，这个是由于链表本身的性质造成的，在链表...
java linkedlist源码_java集合中LinkedList源码浅析
weixin_39556853的博客
02-16 85
LinkedList就传说中的双向循环链表了。是List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素(包括 null)。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。链表操作优点：1.因为每个结点记录下个结点的引用，则在进行插入和删除操作...
java集合： LinkedList源码浅析
一生编程，快乐编程
12-06 53
LinkedList 数据结构是双向链表，插入删除比较方便。LinkedList 是线程不安全的，允许元素为null 。 构造函数： 构造函数是空的。 /** * Constructs an empty list. */ public LinkedList() { } 基本属性： //transient表示不会被序列化 //集...
Java集合 LinkedList源码浅析
qq_32468603的博客
10-08 457
Java LinkedList源码浅析
Java集合——LinkedList源码浅析
weixin_42738587的博客
11-09 229
一、继承关系 public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable List接口：可以存储重复性数据，数据可以为null，插入有序 Deque...
第四章 JAVA集合之LinkedList源码浅析
屌丝程序员的奋斗之路
09-14 596
一.概括       在JDK1.7中LinkedList是一种双链表结构，而不是一种循环双链表结构，LinkedList这种结构适合用来存储增删操作比较多的集合，因为在增删的时候不需要移动元素，只需要改变元素的连接指针就可以了，如果是查询操作比较多的时候，用ArrayList存储比较合适。LinkedList不是线程安全的。        二.LinkedList的数据结构
常用集合之LinkedList源码浅析
我弟是个程序员
08-17 4331
上一篇 【ArrayList和Vector源码解刨对比】 先看 LinkedList 部分源码： public class LinkedList&amp;amp;amp;amp;amp;amp;amp;amp;lt;E&amp;amp;amp;amp;amp;amp;amp;amp;gt; extends AbstractSequentialList&amp;amp;amp;amp;amp;amp;amp;amp;lt;E&amp;amp;amp;amp;amp
java集合——LinkedList（1.8）源码浅析
C_AJing的博客
09-11 214
LinkedList是Java集合框架中List接口一种实现。LinkedList 是有序并且可以元素重复的集合，底层是基于双向链表的。它也可以被当作堆栈、队列或双端队列进行操作。 一、继承体系 这里使用IntelliJ IDEA生成的体系图，看一下LinkedList 的继承体系： 由体系图可以看到，LinkedLis实现了以下接口： 实现了Iterable 接口，可以使用迭代器进行遍历； 实现了Collection接口，拥有集合操作的方法； 实现了List 接口，拥有集合增删改查等方法； 实现Deq
java集合 ArrayList , LinkedList 源码浅析
DJH2717的博客
05-05 230
ArrayList 初始容量是多少? /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; ArrayList 是如何扩容的? 每次扩容多大? ArrayList 的扩容是通过 Arrays.copy 来实现的, 底层是通过 native 方法, ...
LinkedList 源码浅析
一枚爪洼同鞋
07-05 110
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。LinkedList同时实现了List接口和Deque接口，也就是说它既可以看作一个顺序容器，又可以看作一个队列(Queue)，同时又可以看作一个栈(Stack)。...
Java中集合LinkedList的原理与使用方法
08-25
LinkedList是Java集合框架中List接口的一个实现，它是一种基于链表结构的数据容器。本文将深入探讨LinkedList的原理和使用方法。 首先，LinkedList是一个双向链表，意味着每个元素（节点）都有指向前后元素的引用。...
简单了解java集合框架LinkedList使用方法
08-18
Java集合框架中的LinkedList是一个双向链表，具有链表底层实现的特点，查询速度慢，增删速度快。LinkedList是Java集合框架中的一个重要组件，广泛应用于各种软件系统中。本文将详细介绍LinkedList的使用方法，通过...
java集合-LinkedList的使用
06-14
基于双向链表实现的列表，支持在任意位置的插入和删除操作。
b050闲置图书分享-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
本次开发的闲置图书分享平台实现了收货地址管理、字典管理、公告管理、留言板管理、图书管理、图书收藏管理、图书评价管理、图书订单管理、用户管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让闲置图书分享平台更能从理念走到现实，确确实实的让人们提升信息处理效率。 管理图书的数据，此页面主要实现图书的增加、修改、删除、查看的功能。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
《大学生职业生涯规划与就业指导》大一阶段课程作业
最新发布
07-24
《大学生职业生涯规划与就业指导》大一阶段课程作业
开题报告潮汕特产直销系统 已通过开题答辩的.doc
07-23
随着互联网的高速发展，人们的生活方式发生了翻天覆地的变化，在过去，人们想要购买很远地方的东西会非常麻烦，因为是通信和交通都不是十分的方便，而现在网络购物成为了人们日常生活中不可或缺的一部分。在这样的背景下，互联网与传统行业的融合已经成为了一种不可阻挡的趋势。对于中国特色的潮汕特产来说，这一趋势也带来了巨大的变革和发展机遇[1]。
Python性能优化：掌握性能分析工具的实战指南
07-23
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
Java集合框架深度解析：LinkedList与Collection接口
"Java集合框架中的LinkedList类是一个重要的数据结构，它实现了List接口，允许在列表的任何位置进行增删改查操作。LinkedList类适用于需要频繁进行插入和删除操作的场景，因为这些操作在LinkedList中相对高效。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值