LinkedList源码阅读

最新推荐文章于 2023-04-25 23:20:51 发布
最新推荐文章于 2023-04-25 23:20:51 发布
阅读量202 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52383454/article/details/125783848
版权

LinkedList源码阅读

简介：

LinkedList内部是一个双向链表结构，它还实现了List 和 Deque 接口。

LinkedList是线程不安全的，可以通过List list = Collections.synchronizedList(new LinkedList(...)); 将LinkedList转化为线程安全的。

LinkedList继承结构图

在继承关系上与ArrayList的异同

相同点：

都实现了List,Serializable,Cloneable 接口。

不同点：

LinkedList没有实现RandomAccess接口。 说明LinkedList不支持快速随机访问。

LinkedList实现了Deque接口 而ArrayList没有。

Deque是一个队列类，支持对头尾双端进行添加和删除的数据结构。

字段

//LinkedList实际存储元素的个数
transient int size = 0;
//记录LinkedList的头元素
transient Node<E> first;
//记录LinkedList的尾元素
transient Node<E> last;

元素节点的结构

private static class Node<E> {   
        E item;			//元素值 
        Node<E> next;	//指向下一个元素
        Node<E> prev;	//指向上一个元素
    
		//只提供了全参构造方法，没有set、get方法    
        Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

构造方法

无参构造

//构造一个空list
public LinkedList() {
}

有参构造

//根据一个已有的单列集合创建LinkedList
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

常用方法

添加元素的方法

//在链表头部添加元素
private void linkFirst(E e) {
    
    final Node<E> f = first;
    //创建一个结点newNode，它的next指针指向原来的头结点first
    final Node<E> newNode = new Node<>(null, e, f);
    //更新头结点
    first = newNode;
    //如果f所指向的结点为null，说明该集合中只有一个元素节点，此时first和last都指向newNode，否则就更改f的prev指针的指向。
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    //添加元素后size++
    size++;
    //每次操作后 modCount++
    modCount++;
}

//在链表尾部添加元素
void linkLast(E e) {
    final Node<E> l = last;
    //创建一个新结点，添加到链表末尾
    final Node<E> newNode = new Node<>(l, e, null);
    //更新last指向
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

//在链表指定结点前添加元素
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    // 默认succ结点不为null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

//头部添加元素
public void addFirst(E e) {
    linkFirst(e);
}

//尾部添加元素
public void addLast(E e) {
    linkLast(e);
}


//将集合c中的元素全部添加到本集合中。
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

//在指定位置处，将集合c中的元素全部添加到本集合中。
public boolean addAll(int index, Collection<? extends E> c) {
    //检查下表是否越界。
    checkPositionIndex(index);
	//将集合转化成数组，方便不同集合统一处理。
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;

    //查找插入位置的前后结点。
    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }

    //逐个添加元素。
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }

    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

删除元素的方法

//从头部删除元素
private E unlinkFirst(Node<E> f) {
    // 默认f为头结点 并且f不为null
    final E element = f.item;
    final Node<E> next = f.next;
    //将f的item，和next都置为null，目的是方便GC回收
    f.item = null;
    f.next = null; // help GC
    first = next;
    //当next为null时，集合中只有一个元素，此时first和last指向同一个元素，这时删除头元素后，last也要被置为null。
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    // 还会返回这个被删除元素的值。
    return element;
}

//从链表末尾删除元素
private E unlinkLast(Node<E> l) {
    // 默认l为尾结点，且不为null。
    final E element = l.item;
    final Node<E> prev = l.prev;
    //将l的item，和next都置为null，目的是方便GC回收    
    l.item = null;
    l.prev = null; // help GC
    last = prev;
    //同上
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

//删除指定结点。
E unlink(Node<E> x) {
    // 默认x不为null;
    final E element = x.item;
    //保存x的前后结点
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
	//修改前后结点的指向
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}


// 移除集合中第一个元素值为o的元素
public boolean remove(Object o) {
    //因为LinkedList的元素值可以为null， 所以这里要判断o==null.防止空指针异常。
    if (o == null) {
        //循环遍历
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

查找元素的方法

//查找指定位置的结点
Node<E> node(int index) {
    // 这里没有检查下标是否越界，默认下标不会越界，一般在调用此方法前，会有检查下标是否越界的步骤。
    // 采用从两端向中间查找的方式，优化了查找效率。
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

//查找指定位置元素
public E get(int index) {
    //检查下标是否越界
    checkElementIndex(index);
    //查找并返回元素值
    return node(index).item;
}

//获取头结点的元素值
public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

//获取尾结点的
public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

修改元素方法

//修改指定位置的元素
public E set(int index, E element) {
    //检查下标是否越界
    checkElementIndex(index);
    //找到该结点
    Node<E> x = node(index);
    //修改元素值
    E oldVal = x.item;
    x.item = element;
    //返回旧的元素值
    return oldVal;
}

Deque的方法实现

这部分方法其实就是对LinkedList的辅助方法的简单调用。

//得到头结点的元素值
public E peek() {
    final Node<E> f = first;
    //如果列表为空，返回null
    return (f == null) ? null : f.item;
}

//得到头结点的元素值
public E element() {
    //如果列表为空，则抛出异常。
    return getFirst();
}

//移除头结点并得到头结点的元素值
public E poll() {
    final Node<E> f = first;
	//如果列表为空，返回null
    return (f == null) ? null : unlinkFirst(f);
}

// 移除头结点并返回元素值
public E remove() {
    return removeFirst();
}

// 尾部添加元素
public boolean offer(E e) {
    return add(e);
}


//头部添加元素
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

//尾部添加元素
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

//得到头结点的元素值
public E peekFirst() {
    final Node<E> f = first;
    //列表为空则返回null
    return (f == null) ? null : f.item;
 }

//得到尾结点元素值
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

//移除头结点并返回元素值
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);
}

//头部添加元素，可用做 栈 的入栈操作
public void push(E e) {
    addFirst(e);
}

//移除头部结点，可用做 栈 的出站操作
public E pop() {
    return removeFirst();
}
idgoodbye
关注
19：Collection集合接口：List 集合子接口下的LinkedList的基本使用、模拟双向链表存储元素、LinkedList 源码阅读理解总结：
随手记记，加深印象。
06-18 430
目录 链表相关概念： LinkedList的常用API的基本使用： LinkedList 的遍历方式： 模拟双向链表存储元素： LinkendList 集合 部分源码解读: boolean add(E e)方法: void add(int index, E element)方法: E get(int index) 方法: E set(int index, E element) 方法: E pollFirst() 方法: E pollLast() 方法: E remove(int in
LinkedList 部分源码
10-24
### LinkedList部分源码解析 #### 一、简介 `LinkedList`是Java集合框架的一个重要组成部分，它基于双向链表实现，既支持`List`接口也实现了`Deque`接口，因此可以作为列表、栈或者队列使用。双向链表的每个节点...
LinkedList的源码
码农
07-29 311
package java.util; public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, java.io.Serializable { // 链表的表头，表头不包含任何数据。Entry是个链表类数据结构。 private transien
LinkedList源代码阅读
最新发布
weixin_62312011的博客
04-25 157
对LinkedList主要的组成部分进行源码剖析
LinkedList源码
12-29
LinkedList源码
Java基于JDK 1.8的LinkedList源码详析
08-26
"Java基于JDK 1.8的LinkedList源码详析" LinkedList是Java中一个非常重要的数据结构，基于双向链表实现，适用于增删频繁且查询不频繁的场景。今天我们将深入分析LinkedList的源码，了解其内部实现机制和特点。 1. ...
LinkedList源码阅读笔记
三分恶的博客
08-19 928
LinkedList是基于双向链表数据结构实现的Java集合
LinkedList源码阅读分析
SharenFish的博客
12-01 500
LinkedList源码阅读分析 1.1 LinkedList介绍 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。 LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。 LinkedList 实现java.io.Serializ
java8 LinkedList源码阅读【2】- 总结
wbin233的博客
04-17 806
上一篇文章 java8 LinkedList源码阅读已经分析了LinkedList源码，现对LinkedList做个小结。 LinkedList特点 双向链表实现，因此没有固定容量，不需要扩容 元素时有序的，输出顺序与输入顺序一致 允许元素为 null 所有指定位置的操作都是从头开始遍历进行的 和 ArrayList 一样，不是同步容器 需要更多的内存，LinkedList 每个节点中需要多存储前
LinkedList源码解析
tangyuan_sibal的博客
05-03 2422
文章目录1、LinkedList类的说明1.1 解释说明1.2 数据结构2、方法字段3、关键方法栈和队列的操作4、总结 1、LinkedList类的说明 在上篇我们分析了ArrayList的底层实现，知道了ArrayList底层是基于数组实现的，因此具有查找修改快而插入删除慢的特点。本篇介绍的LinkedList是List接口的另一种实现，它的底层是基于双向链表实现的，因此它具有插入删除快而查找修...
jdk源码阅读二：LinkedList
taotoxht的专栏
01-15 435
LinkedList介绍LinkedList是基于链表来实现的List。主要特征如下： 不仅实现了List接口，还实现了Deque，所以是一个双端队列。 允许存储null对象。 非线程安全，如果多线程操作它，需要外部枷锁，或者Collections.synchronizedList。 返回的iterator是fail-fast，如果iterator创建后，修改了list结构则会抛出异常Concurr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值