LinkedList实现原理

最新推荐文章于 2024-08-13 22:32:17 发布
最新推荐文章于 2024-08-13 22:32:17 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： java 文章标签： java 源码学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a87821879/article/details/79686144
版权

LinkedList简介

双向链表实现 List 和 Deque接口。实现所有可选的列表操作,并允许插入null值。

所有操作的执行方式与双向链表都是一样的。检索操作依据离两端的距离，从开头或结尾开始遍历列表。

此未实现同步，可用List list = Collections.synchronizedList(new LinkedList(...))包装。


LinkedList继承

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

LinkedList源码

一、数据成员

transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     * 
     *  指向第一个节点的指针。不变量：(first == null && last == null)|| (first.prev == null && first.item！= null)
     * 
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     * 
     *  指向最后一个节点的指针。不变量：(first == null && last == null)|| (last.next == null && last.item！= null)
     * 
     */
    transient Node<E> last;


二、构造函数

    /**
     * 
     *构造一个空列表。
     * 
     */
    public LinkedList() {
    }

    /**
     *
     *  按照集合的迭代器返回的顺序构造包含指定集合的​​元素的列表。
     * @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);
    }


三、其他方法


1、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++;
    }

2、linkLast

链接e作为最后一个元素。

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


3、unlinkFirst

取消第一个节点f的链接。

private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)//后面没有节点
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }


4、unlinkLast

取消最终节点l的链接。

private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)//前面没有节点
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }


5、unlink

取消链接非空节点x。

E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;//x是头节点，因此头结点变为next
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
//x是尾节点，因此尾结点变为prev
} else { next.prev = prev; x.next = null; } x.item = null; size--; modCount++; return element; }


6、remove

移除头结点

    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

移除尾节点

public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }


7、add

将指定的元素追加到此列表的头。

public void addFirst(E e) {
        linkFirst(e);
    }


将指定的元素追加到此列表的末尾。

public void addLast(E e) {
        linkLast(e);
    }
public boolean add(E e) {
        linkLast(e);
        return true;
    }


8、set

用指定的元素替换此列表中指定位置处的元素。

    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }


9、clear

从此列表中删除所有元素。此调用返回后,列表将为空。

public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }


10、indexOf

返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。

public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

11、node

返回指定元素索引处的(非空)节点。

    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {//若index<size/2 ,则从头开始
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {若index >= size/2 ,则从尾开始
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

12、peek

检索,但不删除此列表的头(第一个元素)。

public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }
public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }
检索,但不删除此列表的尾 
public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

13、element

检索,但不删除此列表的头(第一个元素）。

public E element() {
        return getFirst();
    }

14、poll

检索并删除此列表的头

    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
检索并删除此列表的尾 
public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

15、offer

public boolean offer(E e) {
        return add(e);//添加到末尾
    }

16、offerFirst

在此列表的前面插入指定的元素。

public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }


17、removeLastOccurrence

删除此列表中指定元素的最后一次出现(从头到尾遍历列表时)。如果列表不包含元素,则不会更改。

        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }


18、toArray

以正确的顺序返回包含此列表中所有元素的数组(从第一个元素到最后一个元素)。
返回的数组将是"安全的",因为没有对它的引用由此列表维护。 (换句话说,这个方法分配了一个新的数组)。因此调用者可以自由地修改返回的数组。
此方法充当基于阵列和基于集合的API之间的桥梁。

public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
    }



返回一个包含正确顺序(从第一个元素到最后一个元素)的列表中所有元素的数组。返回的数组的运行时类型是指定数组的运行时类型。如果列表适合指定的数组,则返回其中。
否则,将使用指定数组的运行时类型和此列表的大小分配新数组。
如果列表适合于具有空余空间的指定数组(即,数组具有比列表更多的元素),紧接列表结尾的数组中的元素将设置为{@code null}。
(如果调用者知道列表不包含任何空元素,则这在确定列表</i>的长度时非常有用。)。

与 toArray() 方法类似,此方法充当基于数组和基于集合的API之间的桥梁。此外,该方法允许对输出阵列的运行时类型的精确控制,并且在某些情况下可以用于节省分配成本。

public <T> T[] toArray(T[] a) {
        if (a.length < size)
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;

        if (a.length > size)
            a[size] = null;

        return a;
    }

四、内部类

private class DescendingIterator implements Iterator<E> 
  
private class ListItr extends Itr implements ListIterator<E>  
  
private static class Node<E>
  
static final class LLSpliterator<E> implements Spliterator<E>

DescendingIterator 是实现了Iterator接口，同时重写了里面的hasNext()，next()，remove()等方法；

ListItr继承Itr，实现了ListIterator接口，同时重写了hasPrevious()，nextIndex()，previousIndex()，previous()等方法。

Node<E> 是链表的节点，拥有成员： E item;  Node<E> next;  Node<E> prev;

LLSpliterator是一个可分割迭代器，是为了并行遍历元素而设计的一个迭代器，jdk1.8中的集合框架中的数据结构都默认实现了spliterator，具体没怎么了解。



a87821879
关注
专栏目录
【数据结构】LinkedList原理及实现学习总结
简约人生的博客
04-20 2万+
LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的（通过名字也能区分开来），所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链表的，所以随机访问的效率要比 ArrayList 差。二、ListedList类定义public class Lin
LinkedList 实现原理
weixin_43639735的博客
07-01 331
概述 LinkedList 是通过一个双向链表来实现的，它允许插入所有元素，包括 null，同时，它是线程不同步的。 1、 LinkedList 的底层结构是一个带头/尾指针的双向链表，可以快速的对头/尾节点进行操作。 2、相比数组，链表的特点就是在指定位置插入和删除元素的效率较高，但是查找的效率就不如数组那么高了 常用的方法 双向链表，头节点均指first，尾节点均指last 添加元素： add(E e)：将元素添加到表尾，返回布尔类型值 addFirst(E e)：添加新的头节点 addLast(E
LinkedList的实现原理分析
CoderLife9192的专栏
10-02 491
http://wiki.jikexueyuan.com/project/java-collection/linkedlist.html LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的（通过名字也能区分开来），所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链
【JAVA】LinkedList 详解
最新发布
weixin_37559642的博客
08-13 852
LinkedList 详解
LinkedList的原理介绍
黑马程序员官方博客
03-11 611
一、LinkedList的概述 LinkedList是双向链表实现的List LinkedList是非线程安全的 LinkedList元素允许为null，允许重复元素 LinkedList是基于链表实现的，因此插入删除效率高，查找效率低（虽然有一个加速动作） LinkedList是基于链表实现的，因此不存在容量不足的问题，所以没有扩容的方法 LinkedList还实现了栈和队列的操作方...
LinkedList的实现原理浅析
weixin_33862041的博客
09-17 263
2019独角兽企业重金招聘Python工程师标准>>> ...
Java LinkedList 实现原理
hushaoxi的专栏
08-31 1318
LinkedList 大家都不陌生，来看看他的实现原理，首先声明，他是一个双链条，即previous，next  /** * Constructs a new empty instance of {@code LinkedList}. */ public LinkedList() { voidLink = new Link(null, null,
Java LinkedList的实现原理图文详解
08-26
Java LinkedList 的实现原理图文详解 Java LinkedList 是一个通过双向链表实现的 List 和 Deque 接口，它允许插入所有元素，包括 null，并且它是线程不同步的。如果对双向链表这个数据结构很熟悉的话，学习 ...
对ArrayList和LinkedList底层实现原理详解
08-26
ArrayList和LinkedList底层实现原理详解 ArrayList 底层实现方式的知识点： 1. ArrayList 底层实现方式：ArrayList 通过数组实现，一旦我们实例化 ArrayList 无参数构造函数默认为数组初始化长度为 10。 2. add ...
源码解析jdk7.0集合：LinkedList的底层实现原理.pdf
03-11
首先，LinkedList实现了List接口，因此它是一个有序列表。它还实现了Deque接口，这意味着LinkedList支持双端队列的操作。除了这些接口之外，LinkedList还是Cloneable和java.io.Serializable的，表示它可以被克隆以及...
LinkedList 底层实现原理
weixin_30773135的博客
06-19 153
LinkedList的底层实现原理 LinkedList 底层数据结构为双向链表，链表结构，基于一个个链表节点Node 1,Inner Class 内部类 private static class Node<E>{ E item;//当前节点下的当前元素 Node<E> next;//下一个节点 Node<E> prev;//上一个节点 ...
LinkedList的实现原理
WenJieya的博客
04-07 396
文章目录LinkedList的实现原理1.1 概述1.2 LinkedList类的一些属性1.3 方法1.3.1 节点结构1.3.2 添加元素1.3.3 删除元素1.3.4 获取元素总结 LinkedList的实现原理 1.1 概述 通过这段注释我们可以得出： LinkedList 是通过一个双向链表来实现的，它允许插 入所有元素，包括 null。 它是线程不同步的。 1.2 LinkedList类的一些属性 //链表的节点个数 transient int size = 0; //
Java_LinkedList工作原理
南瓜灯cc
05-03 1541
Doubly-linked list implementation of the List and Deque interfaces. Implements all optional list operations, and permits all elements (including null).LinkedList实现了list接口，其底层实际上一个双向链表，其基本操作就是对双向链表的操作
LinkedList原理讲解
李平安
09-19 1443
1. LinkedList概述本节基于JDK1.8.0_60 LinkedList是双向链表实现的List LinkedList是非线程安全的 LinkedList适用于快速插入和删除，不适用快速获取和修改 源码解析：LinkedList源码 参考：图解集合2：LinkedList 2. LinkedList总结2.1 LinkedList存储结构// 元素个数 transient int siz
LinkedList的原理以及使用方式
weixin_45935149的博客
11-15 74
平时的业务中基本上用的都是ArrayList，很少涉及LinkedList，而且LinkedList中有很多api，如果不知道底层原理，有可能会出现报错问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值