Java LinkedList学习笔记

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

前言

最近在学习Java基础知识，LinkedList是Java的一种常见的数据类型，所以我准备针对它做一个笔记，以供自己查阅。笔记将不仅仅局限于LinkedList（基于1.8.0_45），还会对一些Java的知识做一些总结。文章会参照前辈的文章，希望能有所帮助~

概述

在关于Java集合的小抄里是这样描述的：

以双向链表实现。链表无容量限制，但双向链表本身使用了更多空间，每插入一个元素都要构造一个额外的Node对象，也需要额外的链表指针操作。
按下标访问元素－get（i）、set（i,e） 要悲剧的部分遍历链表将指针移动到位 （如果i>数组大小的一半，会从末尾移起）。
插入、删除元素时修改前后节点的指针即可，不再需要复制移动。但还是要部分遍历链表的指针才能移动到下标所指的位置。
只有在链表两头的操作－add（）、addFirst（）、removeLast（）或用iterator（）上的remove（）倒能省掉指针的移动。

它的定义是

LinkedList is an implementation of {@link List}, backed by a doubly-linked list.
All optional operations including adding, removing, and replacing elements are supported.
All elements are permitted, including null.

中文翻译是：

LinkedList 是List的一个实现，它由双向链表支持。
它支持add，remove和replace操作，并且可以包含null值。

Transient关键字

在LinkedList类一开始，我看到了如下代码：

transient int size = 0;//顺便加一句，这是linkedList的容量，初始化为0

在这里就顺便对transient关键字做一个学习。
transient的解释是：Java 语言规范中提到，transient 关键字用来说明指定属性不进行序列化。（当持久化对象时, 可能有一个特殊的对象数据成员, 我们不想用 serialization 机制来保存它。为了在一个特定对象的一个域上关闭serialization, 可以在这个域前加上关键字transient。）

序列化

序列化其实我们在Android上使用过的，它是用来持久化对象的状态。
关于序列化的知识：transient 关键字的作用?

Android中的序列化

Android中的序列化分两种：

  • Serializable，要传递的类实现Serializable接口传递对象，
  • Parcelable，要传递的类实现Parcelable接口传递对象。

Serializable是Java自带的，而Parcelable是Android加入的。
它们的区别是：Parcelable是将一个完整的对象进行分解，
而分解后的每一部分都是Intent所支持的数据类型。Serializable使用了反射，序列化的过程较慢。Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。Parcelable比Serializable性能高，所以在Android上推荐使用Parcelable（虽然书写稍微麻烦一些）。

上面由一行代码引出了Transient关键字和Android序列化，下面继续对LinkedList进行分析。

Link类

private static final class Link<ET> {
        ET data;

        Link<ET> previous, next;

        Link(ET o, Link<ET> p, Link<ET> n) {
            data = o;
            previous = p;
            next = n;
        }
    }

这里的data指的是用户的数据，previous和next分别指指向前后节点的指针。

构造函数

    /**
     * Constructs a new empty instance of {@code LinkedList}.
     */
    public LinkedList() {
        voidLink = new Link<E>(null, null, null);
        voidLink.previous = voidLink;
        voidLink.next = voidLink;
    }

    /**
     * Constructs a new instance of {@code LinkedList} that holds all of the
     * elements contained in the specified {@code collection}. The order of the
     * elements in this new {@code LinkedList} will be determined by the
     * iteration order of {@code collection}.
     *
     * @param collection
     *            the collection of elements to add.
     */
    public LinkedList(Collection<? extends E> collection) {
        this();
        addAll(collection);
    }

第一个函数就是构建一个header(为voidLink)，并且它的previous和next都指向自己本身；第二个函数就是把一个Collection类中的所有元素添加到list中去。addAll函数将在后面进行学习。

add函数

@Override
    public void add(int location, E object) {
        if (location >= 0 && location <= size) {
            Link<E> link = voidLink;//voidLink就是常说的header
            if (location < (size / 2)) {//如果插入位置位于前半段
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {//如果插入位置位于后半段
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            //通过上面的操作，找出了插入位置的原元素
            Link<E> previous = link.previous;
            Link<E> newLink = new Link<E>(object, previous, link);
            previous.next = newLink;
            link.previous = newLink;//这四行代码，把原来的元素后移一位，前面插入新的数据，并且要把前后的next和previous做相应的修改(不明白的话，依旧可以如底下画图来理解)
            size++;
            modCount++;
        } else {
            throw new IndexOutOfBoundsException();
        }
    }

    /**
     * Adds the specified object at the end of this {@code LinkedList}.
     *
     * @param object
     *            the object to add.
     * @return always true
     */
    @Override
    public boolean add(E object) {
        return addLastImpl(object);
    }

    private boolean addLastImpl(E object) {
        Link<E> oldLast = voidLink.previous;//voidLink也就是header
        Link<E> newLink = new Link<E>(object, oldLast, voidLink);
        voidLink.previous = newLink;
        oldLast.next = newLink;
        size++;//容量加一
        modCount++;
        return true;
    }

在这里还要强调一下LinkedList是一个双向循环的链表。
上面的函数分别是add(E object)；add(int location, E object)；addLastImpl(E object) 。
add(E object)直接调用了addLastImpl(E object)。在addLastImpl(E object)函数里，把header的previous赋值给oldLast；然后新建一个新的Link对象，其中存放的是用户需要加入的数据，并且它的previous赋值为oldLast，next赋值为voidLink的地址；这个时候，把header的previous赋值为新端点的地址，把oldlast的next端点也赋值成为新端点的地址，那么可以说是插入成功了。因为文字略显晦涩，这里我将用图来解释一下：

因为是笔记，所以我直接使用了自己在草稿纸上画的图：

  • size为0的时候（初始化）：
    previous和next都指向自己

  • 当size=0的时候，执行如下代码后的结果：

Link<E> oldLast = voidLink.previous;
Link<E> newLink = new Link<E>(object, oldLast, voidLink);

这里写图片描述

  • 继续执行后面两行的代码后：
voidLink.previous = newLink;
oldLast.next = newLink;


上面两张图指的是size=0到size=1的变化。

  • 当size=1到size=2的过程中：
    执行如下代码后：
Link<E> oldLast = voidLink.previous;
Link<E> newLink = new Link<E>(object, oldLast, voidLink);

这里写图片描述

  • 接上一个步骤，继续执行如下两行代码后：
voidLink.previous = newLink;
oldLast.next = newLink;

就变成了下图：
这里写图片描述

如果继续add的话，应该还是在上图的基础上进行。

add(int location, E object)

然后我们再来看add(int location, E object)函数：
它可以使需要添加的数据插入到链表相应的位置去（在上面的代码中做了相应的注释）。

addAll函数

@Override
    public boolean addAll(int location, Collection<? extends E> collection) {
        if (location < 0 || location > size) {
            throw new IndexOutOfBoundsException();
        }
        int adding = collection.size();
        if (adding == 0) {
            return false;
        }
        Collection<? extends E> elements = (collection == this) ?
                new ArrayList<E>(collection) : collection;

        Link<E> previous = voidLink;
        if (location < (size / 2)) {//同样分情况讨论，看是从前遍历还是从后遍历
            for (int i = 0; i < location; i++) {
                previous = previous.next;
            }
        } else {
            for (int i = size; i >= location; i--) {
                previous = previous.previous;
            }
        }
        Link<E> next = previous.next;
        for (E e : elements) {
            Link<E> newLink = new Link<E>(e, previous, null);
            previous.next = newLink;
            previous = newLink;
        }
        previous.next = next;
        next.previous = previous;
        size += adding;
        modCount++;
        return true;
    }

    @Override
    public boolean addAll(Collection<? extends E> collection) {
        int adding = collection.size();
        if (adding == 0) {
            return false;
        }
        Collection<? extends E> elements = (collection == this) ?
                new ArrayList<E>(collection) : collection;//如果collection是当前linkedList对象，那么就新建一个Arraylist，否则elements就赋值为collection。
        Link<E> previous = voidLink.previous;//赋值为header的previous，previous的值为linkedList的最后一个元素
        for (E e : elements) {
            Link<E> newLink = new Link<E>(e, previous, null);
            previous.next = newLink;
            previous = newLink;//在这个循环里，依次把元素添加在linkedList的末尾。
        }
        previous.next = voidLink;//把最后一个元素的next指向头部的header。
        voidLink.previous = previous;//把header的previous指向最后一个元素。这两行构成了新的循环（如之前的图示）。
        size += adding;
        modCount++;
        return true;
    }

在当前类中重载了两个addAll函数。其中第二个函数同样在构造函数中被调用（如上）。
在上面的代码中做了相应的注释。

set函数

    public E set(int location, E object) {
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            E result = link.data;
            link.data = object;
            return result;
        }
        throw new IndexOutOfBoundsException();
    }

从代码可以看出，set的时候，同样是分情况讨论的，分为从前遍历和从后遍历两种情况。在set的值，需要对linkedList进行遍历。

get函数

public E get(int location) {
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            return link.data;
        }
        throw new IndexOutOfBoundsException();
    }

get的基本逻辑其实和set很相似。也是进行遍历，然后取值。

remove

public E remove() {
        return removeFirstImpl();
    }

public E remove(int location) {
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            if (location < (size / 2)) {//这个if else代码块在当前类经常被使用到,找出相应location的元素
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            Link<E> previous = link.previous;
            Link<E> next = link.next;
            previous.next = next;
            next.previous = previous;//改变当前location元素的指针指向关系，从而把该元素移出LinkedList
            size--;
            modCount++;
            return link.data;
        }
        throw new IndexOutOfBoundsException();
    }

    @Override
    public boolean remove(Object object) {
        return removeFirstOccurrenceImpl(object);
    }

从代码可以看出，remove 函数有三个。
第一个remove是不带参数的，它直接调用了removeFirstImpl()函数。

private E removeFirstImpl() {
        Link<E> first = voidLink.next;//header的next，当size=0时，next指向header自己；当size>0的时候，next指向LinkedList的第一个元素。
        if (first != voidLink) {//size>0时
            Link<E> next = first.next;//next赋值为第一个元素的next值，也就是第二个元素（ps：当size=1时，又指向它本身）
            voidLink.next = next;//header的next赋值为上面的值
            next.previous = voidLink;//第二个元素（或当size=1时，就是header本身）的previous由指向first变为指向header。
            //经过上面的操作，把LinkedList的第一个元素移除了。
            size--;
            modCount++;
            return first.data;
        }
        throw new NoSuchElementException();
    }

所以remove函数在当前类的作用应该是移除LinkedList的第一个元素。

第二个函数见注释。

第三个函数的参数是object元素，而不是索引。通过代码，它直接调用了removeFirstOccurrenceImpl(object)函数：

    private boolean removeFirstOccurrenceImpl(Object o) {
        Iterator<E> iter = new LinkIterator<E>(this, 0);//LinkIterator迭代器
        return removeOneOccurrence(o, iter);
    }

    private boolean removeOneOccurrence(Object o, Iterator<E> iter) {
        while (iter.hasNext()) {//是否存在下一个元素
            E element = iter.next();
            if (o == null ? element == null : o.equals(element)) {//如果删除的元素是null，如果有元素的值也为null，那么进行remove操作；如果o不是null，就调用equals比较。
                iter.remove();
                return true;
            }
        }
        return false;
    }

它借助了迭代器去完成remove操作。迭代器就不再在这里赘述了，它的定义也在LinkedList.java类中。

clear函数

public void clear() {
        if (size > 0) {
            size = 0;//将size容量置为0
            voidLink.next = voidLink;//next指向自己内存地址
            voidLink.previous = voidLink;//previous指向自己内存地址
            //这里是不是做一个=null操作更好呢？
            modCount++;
        }
    }

contains函数

@Override
    public boolean contains(Object object) {
        Link<E> link = voidLink.next;//voidLink就是header，指向第一个有效元素（size=0的时候，指向自己）
        if (object != null) {
            while (link != voidLink) {//从头到尾循环一次，到末节点指向自己为止
                if (object.equals(link.data)) {
                    return true;
                }
                link = link.next;
            }
        } else {
            while (link != voidLink) {
                if (link.data == null) {//遍历到第一个元素为null即可
                    return true;
                }
                link = link.next;
            }
        }
        return false;
    }

后面的一些函数应该不是很常用，后面有时间的话会继续更新。

与ArrayList的比较

LinkedList 和 ArrayList 都实现了 List 接口。LinkedList 是基于链表实现的，所以它的插入和删除操作比 ArrayList 更加高效。但其随机访问的效率要比 ArrayList 差。

总结

其实根据每个Java版本实现代码都会有略微不同，如果可以的话，大家应该可以自己实现一个linkedList。所以对LinkedList的学习应该是知道LinkedList的数据结构是双向链表，其余的具体实现都是围绕这个循环的双向链表进行的。

参考

关于Java集合的小抄

Java LinkedList工作原理及实现

transient 关键字的作用?

Transient 关键字

序列化Serializable和Parcelable的理解和区别

【数据结构】LinkedList原理及实现学习总结

java集合框架04——LinkedList和源码分析

图解集合2：LinkedList

YuNansen
关注
专栏目录
Java学习笔记 --- LinkedList
乌云的博客
11-01 276
1、LinkedList 实现了双向链表和双端队列特点2、可以添加任意元素（元素可以重复），包括null3、线程不安全，没有实现同步。
java学习笔记
12-22
Java学习笔记涵盖了大量的Java基础知识，包括面向对象编程和高级特性。以下是对这些知识点的详细解释： **基础语法** 1. **数据类型**：Java有基本数据类型和引用数据类型。基本数据类型包括整型（byte, short, int...
Java LinkedList
12-16
Java LinkedList Java 集合框架 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。 Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。 与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。 以下情况使用 ArrayL
Java集合类--LinkedList
weixin_33881140的博客
10-14 2129
2019独角兽企业重金招聘Python工程师标准>>> ...
【Java & 数据结构】LinkedList介绍
最新发布
qq_42150700的博客
08-14 1259
回答这个问题前, 首先我们需要了解一下这个头节点是干什么的. 这个头节点实际上和寻常的节点没有什么两样, 但是它的数据域, 是不存储真正的数据的, 你可以在这个数据域中存储任意的数据, 例如存储链表的长度, 或者根本不使用这个数据域都是可以的. 它的作用就是用于作为链表的头, 便于链表的操作和管理而设计的.首先我们要想这个节点和链表是什么关系?很明显如果要插入一定要前一个位置的引用, 因为要令其 next 指向当前节点, 因此我们需要找到前一个节点. 那么我们如何找到前一个节点呢?
【Java】链表LinkedList
热门推荐
qq_61635026的博客
07-06 1万+
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
Java LinkedList实现
baidu_28610773的博客
03-24 794
链表是由一个个节点连接在一起，这里就先创建一个节点类： package cn.mesie.dataStructure.list; public class Node<T> { /**新元素与链表结合节点**/ Node<T> next; /**新元素数据**/ T data; public Node() { } ...
java集合系列之LinkList
weixin_30362233的博客
03-28 144
概要 第1部分 LinkedList介绍第2部分 LinkedList数据结构第3部分 LinkedList源码解析(基于JDK1.6.0_45)第5部分 LinkedList示例 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3308807.html 第1部分 LinkedList介绍 LinkedList简介 LinkedLis...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性...通过深入学习和实践，你可以不断提升自己的Java编程能力。
Java中LinkedList详解
qq_45858803的博客
11-27 1870
Java中LinkedList详解 LinkedList底层是双向链表 单向链表 双向链表 LinkedList新增的方法 主要增加了针对头结点与尾结点进行操作的方法, 即针对第一个元素和最后一个元素进行操作的方法。 void：addFirst(E e) 添加到首部 void：addLast(E e) 添加到尾部 E：element()返回第一个元素 E：getFirst() 返回第一个元素 E：getLast()返回最后一个元素 boolean：offer(E e) 把元素添加到尾部 boolean：
Java中的LinkedList
weixin_52758364的博客
01-16 2429
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
java LinkedList
weixin_45129218的博客
03-25 311
LinkedList实现了双向链表和双端队列特点 可以添加任意元素(元素可以重复),包括null 线程不安全,没有实现同步 LinkedList底层维护了一个双向链表 LinkedList中维护了两个属性first和last分别指向首节点和尾节点 每个节点(Node对象),里面又维护了prev,next,item三个属性,其中通过prev指向前一个,通过next指向后一个节点,最终实现双向链表 所以LinkedList的元素的添加和删除,不是通过数组完成的,相对效率较高 public class Lin.
Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例
大大肉包博客
06-25 142
 概要 前面，我们已经学习了ArrayList，并了解了fail-fast机制。这一章我们接着学习List的实现类——LinkedList。和学习ArrayList一样，接下来呢，我们先对LinkedList有个整体认识，然后再学习它的源码；最后再通过实例来学会使用LinkedList。内容包括：第1部分 LinkedList介绍第2部分 LinkedList数据结构第3部分 LinkedList...
Java集合之LinkedList
骑着猪猪去旅行的博客
10-30 2496
LinkedList是实现了List和Deque接口的双向链表，实现了所有可选列表的操作，允许存放所有元素（包括null）
Java基础之LinkedList
qq_45344586的博客
04-09 1733
Java基础之LinkedList
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值