【源码】LinkedList源码

最新推荐文章于 2024-05-03 14:09:07 发布
最新推荐文章于 2024-05-03 14:09:07 发布
阅读量453 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42189048/article/details/107140370
版权

【源码】LinkedList

前言

LinkedList，常用的集合之一，基于链表实现，因此元素的插入、删除十分方便。但是元素的查找性能较差。在阅读LinkedList源码之前先简单地实现链表数据结构，有助于理解源码。

链表实现

接口定义

package com.xsn.container;

public interface Linked<T> {

    T addFirst(T t);

    T addLast(T t);

    T add(T t, int index);

    T removeFirst();

    T removeLast();

    T remove(T t);

    boolean contain(T t);

    boolean isEmpty();

    int getSize();
}

定义链表接口，常用方法：头插入、尾插入、指定位置插入、头移除元素、尾移除元素、移除指定值元素、判断是否存在指定值元素、判断是否为空、获取链表长度

实现类

@Data
public class SingleLinked<T> implements Linked<T> {

    private int size;
    private Node<T> head;

    public SingleLinked() {
        size = 0;
        head = null;
    }

    private class Node<T> {
        Node<T> next;
        T data;

        Node(Node next, T data) {
            this.next = next;
            this.data = data;
        }

        Node(T data) {
            this(null, data);
        }

        @Override
        public String toString() {
            return data + "----->" + next;
        }
    }
	
	@Override
    public String toString() {

        return head.toString();
    }
}

链表有两个属性;
size：长度
head：头结点
维护节点内部类Node，同样两个属性
Node next：下一个节点
T data：储存元素

头插入

	public T addFirst(T t) {
        head = new Node(head, t);
        ++ size;
        return t;
    }

new一个新节点作为头结点（将next指向之前的头结点），链表长度递增

指定位置插入

	public T add(T t, int index) {

        if (index < 0 || index > size) {
            throw new RuntimeException("error index");
        }

        if (index == 0) {
            return addFirst(t);
        }

        Node node = new Node(t);
        Node pre = head;

        for (int i = 0; i < index - 1; i++) {
            pre = pre.next;
        }

        node.next = pre.next;
        pre.next = node;
        ++ size;

        return t;
    }

校验位置是否合法
当位置为0，即插入头元素
当位置不为0时，我们从头元素开始，找到要插入的位置index，将新节点的next指向原index节点的next，再将index - 1节点的next指向新节点，长度递增

尾插入

	public T addLast(T t) {
        add(t, size);
        return t;
    }

即在index = size处插入

移除头元素

	public T removeFirst() {

        if (head == null) {
            throw new RuntimeException("already empty");
        }

        T t = head.data;
        head = head.next;
        -- size;
        return t;
    }

将头元素指向头元素的next，长度 - 1

移除尾元素

	public T removeLast() {
        if (head == null) {
            throw new RuntimeException("already empty");
        }

        Node node = head;
        Node<T> next = head;
        while (next.next != null) {
            node = next;
            next = next.next;
        }

        T t = next.data;
        node.next = null;
        -- size;

        return t;
    }

从头节点向后找，当node的next的next为空时，则说明next是尾结点，将node的next置为null，长度 - 1

移除指定值元素

	public T remove(T t) {
        if (head == null) {
            throw new RuntimeException("already empty");
        }

        if (t.equals(head.data)) {
            return removeFirst();
        }

        Node pre = head;
        Node node = head;
        while (node != null && !t.equals(node.data)) {
            pre = node;
            node = pre.next;
        }

        if (node != null) {
            pre.next = node.next;
            -- size;
            return t;
        }

        throw new RuntimeException("no such element " + t);
    }

当值与头元素值相等时，即移除头元素
从头元素向后找，找到对应值元素则将前一元素的next指向该元素的next，长度 - 1，否则认为没找到

是否包含指定元素

	public boolean contain(T t) {
        Node node = head;

        while (node != null && !t.equals(node.data)) {
            node = node.next;
        }

        return node != null;
    }

从头元素开始找，找到最后节点（next == null）即不包含，否则为true

是否为空

	public boolean isEmpty() {
        return size == 0;
    }

测试

	public static void main(String[] args) {
        SingleLinked<String> singleLinked = new SingleLinked<>();

        System.out.println(singleLinked.add("1", 0));
        System.out.println(singleLinked.add("2", 1));
        System.out.println(singleLinked.addFirst("3"));
        System.out.println(singleLinked.addFirst("4"));
        System.out.println(singleLinked.addLast("5"));
        System.out.println(singleLinked.addLast("6"));
        System.out.println(singleLinked);

        System.out.println("==========================");

        System.out.println(singleLinked.removeFirst());
        System.out.println(singleLinked.removeLast());
        System.out.println(singleLinked.remove("1"));
        System.out.println(singleLinked);
        System.out.println(singleLinked.contain("5"));
        System.out.println("==========================");

        /*System.out.println(singleLinked.size);
        System.out.println(singleLinked.contain("1"));
        System.out.println(singleLinked.isEmpty());
        System.out.println(singleLinked.getHead());

        System.out.println("=========================");

        System.out.println(singleLinked.remove("1"));
        System.out.println(singleLinked.size);
        System.out.println(singleLinked.contain("1"));
        System.out.println(singleLinked.isEmpty());
        System.out.println(singleLinked.getHead());
        System.out.println(singleLinked);*/

    }

LinkedList

实现一遍链表后再看LinkedList的源码

	transient int size = 0;

    transient Node<E> first;

	// 多一个属性last记录尾元素
    transient Node<E> last;

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

LinkedList的Node节点多一个prev属性，用来指向前置节点

add()

	public boolean add(E e) {
		// 插入到最后
        linkLast(e);
        return true;
    }

	void linkLast(E e) {
        final Node<E> l = last;
        
        // 新节点prev指向last，next指向null
        final Node<E> newNode = new Node<>(l, e, null);
        
		// 尾节点指向新节点
		last = newNode;
        if (l == null)
        	// 原尾节点为null，即第一次插入，则头结点也为新节点
            first = newNode;
        else
        	// 否则原尾节点的next指向新节点
            l.next = newNode;
		
		// 长度增加
        size++;
        modCount++;
    }

add(int index, E element)

	public void add(int index, E element) {
		// index校验
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

	// 返回index处的Node节点，距离哪边近就从哪边遍历取出
	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;
        }
    }
    
	void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;

		// 新节点的prev指向index处节点的prev，next指向index处节点，即插在了index节点之前，index节点的prev指向index，如果index节点的prev为null，即index为头结点，则此时新节点为头结点，否则index节点的prev节点的next指向新节点。长度累加
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

addAll(int index, Collection<? extends E> c)

	public boolean addAll(int index, Collection<? extends E> c) {
		// index校验
        checkPositionIndex(index);

		// 插入集合转为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

		// 确定插入的前后节点，当index == size时，插入尾部，则前节点指向last，后节点指向null。否则，后节点指向index处节点，前节点指向index处节点的prev
        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;
            // 新节点的prev指向前节点
            Node<E> newNode = new Node<>(pred, e, null);
            
            // 如果前节点 == null，则该新节点为头结点。否则前节点的next指向新节点
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
			
			// 前节点指向新节点，插入下一个节点
            pred = newNode;
        }

		// 后节点 == null，则尾结点指向最后插入的节点。否则，最后插入节点的next指向尾结点，尾结点的prev指向最后插入的元素
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

		// 计算长度
        size += numNew;
        modCount++;
        return true;
    }

addAll(Collection<? extends E> c)

	// 即向对位插入集合
	public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

addFirst(E e)

	public void addFirst(E e) {
        linkFirst(e);
    }
    
	private void linkFirst(E e) {
        final Node<E> f = first;

		// 新节点的prev指向null，next指向头节点
        final Node<E> newNode = new Node<>(null, e, f);

		// 头结点指向新节点
        first = newNode;

		// 原头节点为null，即第一次插入，则尾节点也指向新节点。否则，原头节点的prev指向新节点
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
		
		// 计算长度
        size++;
        modCount++;
    }

addLast(E e)

同add(E e)，只是没有返回元素

clear()

	// 从头节点开始，依次将节点的各属性置空，最后将链表属性置空，长度清0
	public void clear() {
        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++;
    }

contains(Object o)

	public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

	// 相比于我们的实现，该方法支持查询是否包含null
	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;
    }

LinkedList同样实现了Deque接口，对于其中的方法我们不再解读。链表的实现大致思路一样，实现细节可能有所不同，同样也可以对属性进行相应的拓展（如源码中维护的尾节点，prev指针等）

资料

源码地址
https://github.com/dangzhicairang/my-demos.git
demo

小水牛...
关注
专栏目录
Java源码解析LinkedList
08-26
Java源码解析LinkedList Java源码解析LinkedList是Java集合框架中的一种重要数据结构。它是一种双向链表，具有高效的插入和删除操作。今天，我们将深入探讨LinkedList的源码，了解它的内部实现机制。 首先，让我们...
LinkedList源码
12-29
LinkedList源码
Java集合系列之LinkedList源码分析
07-08 1308
一、LinkedList简介 　　LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。 　　ps:这里有一个问题，就是关于实现LinkedList的数据结构是否为循环的双向链表，上网搜了有很多文章都说是循环的，并且有的文章中但是我看了源代码觉得应该不是循环的？ 　　例如在删除列表尾部节点的代码： private E unli
数据结构之线性表
qq_38331606的博客
10-31 139
数据结构之线性表 线性表 线性表是零个或者多个元素组成的有限序列，每个元素最多只有一个前驱/后驱，且元素的数据类型相同。主要分为两种结构，顺序存储结构，链表结构 顺序存储结构 特点 使用连续的存储结构进行存储，通过数组的拷贝来不断扩容。 优缺点 优点：对于小线性表或长度固定的线性表，具有简单、运算方便等优点；同时随机访问速度快，O(1)。 缺点：插入删除时间复杂度为O(n)，同时...
LinkedList源码阅读
apple_51673523的博客
09-06 882
基于JDK8。
ArrayList和LinkedList源码探究
zhaojunwei666的博客
11-21 426
首先，ArrayList和LinkedList都是Java集合框架中List的子类，在面试过程中我们经常被问到这两个有什么不同？ 最常见的回答无非是ArrayList查询比较快，增删改比较慢。而LinkedList查询比较慢，增删改比较快。大多数人都能答道这点，但是为什么两个都是list，但是一个查询快另一个查询慢呢？ ArrayList 这就要从它的底层数据结构入手了，从源码可以看出，lis...
看源码之LinkedList
leilifengxingmw的博客
06-11 2019
首先扯点别的，桌子上的栀子花已经放了好几天了，有点枯萎了，但是依然芳香浓郁。感觉比玫瑰花强多了，玫瑰花也不见得比栀子花好看，不仅没香味而且还有刺。但是还是好多人喜欢玫瑰花。让我想起一篇古文《爱莲说》。 看一下LinkedList的继承结构 LinkedList 继承AbstractSequentialList，实现了List接口和Deque接口，元素可以为null。 非线程安全。 L...
C#源码分析—LinkedList
weixin_43834106的博客
11-23 925
LinkedList为双向循环链表，链表的定义请自行百度；先贴一下节点类： // Note following class is not serializable since we customized the serialization of LinkedList. [System.Runtime.InteropServices.ComVisible(false)] ...
LinkedList源码解析
qq_32073629的博客
08-07 776
深入理解LinkedList源码
LinkedList源码分析
mkii_hong的博客
08-02 84
LinkedList源码分析1.概述2.源码常用属性：常用构造方法：核心内部类：核心方法：参考 1.概述 高效插入和删除的有序序列 线程不安全，非同步 数据结构：链表（双向链表） 继承了AbstractSequentialList,可以作为栈和队列使用 实现了Deque，可以做双向链表 遍历时推荐使用iterater 关系图： public class LinkedList<E> ...
深入理解 LinkedList 及底层源码分析
最新发布
好好学java
05-03 1228
1、继承树结构：2、LinkedList 定义LinkedList继承了 AbstractSequentialList 类，实现了 List 接口、Deque 接口、Cloneable 接口、java.io.Serializable 接口。LinkedList实现了 List 接口，即能对它进行队列操作，提供了相关的添加、删除、修改、遍历等功能。LinkedList实现了 Deque 接口，即能将 LinkedList 当作双端队列使用。LinkedList。
Java基于JDK 1.8的LinkedList源码详析
08-26
"Java基于JDK 1.8的LinkedList源码详析" LinkedList是Java中一个非常重要的数据结构，基于双向链表实现，适用于增删频繁且查询不频繁的场景。今天我们将深入分析LinkedList的源码，了解其内部实现机制和特点。 1. ...
LinkedList 部分源码
10-24
### LinkedList部分源码解析 #### 一、简介 `LinkedList`是Java集合框架的一个重要组成部分，它基于双向链表实现，既支持`List`接口也实现了`Deque`接口，因此可以作为列表、栈或者队列使用。双向链表的每个节点...
java LinkedList源码详解及实例
08-31
3. **源码分析**： - `getFirst()`和`getLast()`通过直接访问`first`和`last`属性来获取元素，这两个属性分别保存链表的第一个和最后一个节点。 - `removeFirst()`和`removeLast()`通过`unlinkFirst(Node<E> f)`和...
java linkedlist源码_java中LinkedList源码分析
weixin_35333277的博客
02-16 293
ArrayList是动态数组，其实本质就是对数组的操作。那么LinkedList实现原理和ArrayList是完全不一样的。现在就来分析一下ArrayList和LinkeList的优劣吧LinkedList是一个双向链表，每个元素都是一个Node对象,这个node对象里面有三个成员：E item;指向实际的元素Node next;指向下一个节点Node prev;指向前一个结点利用idea编辑器查...
mybatis-plus 2 —— CRUD 封装的使用
小水牛的博客
09-08 2448
mybatis-plus 2 —— CRUD 封装的使用前言CRUD 封装WrapperQueryWrapperUpdateWrapperIServicesavegetlistupdatesaveOrUpdateremovepage 前言 上一章节介绍了 MP 和 Springboot 的整合，以及 代码生成 的特性。本章节介绍 MP 对 CRUD 的封装，并结合大量 使用示例 帮助理解 CRUD 封装 MP 帮我们封装了 IService 和 BaseMapper，封装了全面完善的 CRUD 方法，因为我
java实现平衡二叉树（详细注释附代码）
小水牛的博客
07-11 1527
java实现平衡二叉树前言原理思路 前言 之前有用java实现排序二叉树，但实际上但插入数据较极端时，整个二叉树的左右子树会很不平衡（深度），甚至成为一个链表。平衡二叉树是一种特殊的排序二叉树，使得左右子树的深度相差不超过1，则查询节点的时间复杂度也趋于平衡。 原理 我们为平衡二叉树的每一个节点计一个平衡因子BF，则当BF的绝对值大于1，则以该节点为根的子树出现了不平衡，我们根据具体的情况对其进行相应的调整，使它回归平衡。具体情况画几张图分析： 如图，当BF=2，即左子树深度 - 右子树深度 = 2，则需
线程池浅析 ThreadPoolExecutor FutureTask
小水牛的博客
10-10 1469
ThreadPoolExecutor 线程池的使用总结前言版本 前言 版本 JDK11
Java LinkedList源码解析
"LinkedList.pdf 是一份关于Java中的LinkedList数据结构的学习资料，主要涵盖了LinkedList的源码分析，包括其内部节点结构、构造函数以及添加元素的方法等。这份资料可能是作者自学过程中整理的，可能存在一些错误，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值