【Java集合】LinkedList

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量636 收藏
点赞数
分类专栏： Java集合 文章标签： java 链表 android 移动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Guxiaodong_single/article/details/121827971
版权

继承结构

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

写在前面的一些方法

  • private void linkFirst(E 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) // 如果之前的头节点为null，说明之前整条链都是null的
            last = newNode;// 现在的链表元素就一个，所以last=first
        else
            f.prev = newNode;// 不为null，则把第二节点链接到第一节点
        size++;
        modCount++;
    }
  • void linkLast(E e)与linkFirst(···)同理
    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++;
    }
  • void linkBefore(E e, Node<E> succ)在目标节点之前插入元素到链表
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;// 获取目标节点的前一个节点
        // 创建一个新的节点，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++;
    }
  • private E unlinkFirst(Node<E> 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) // 为null说明链表只有一个元素
            last = null;
        else
            next.prev = null; // 断链
        size--;
        modCount++;
        return element;
    }
  • private E unlinkLast(Node<E> l)删除链表最后一个节点，同理unlinkFirst(···)，返回值为移除的节点的元素值
    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;
    }
  • E unlink(Node<E> 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) { // 为null，说明目标节点为头节点
            first = next; // 重新赋值头节点 = 目标节点的下一个节点
        } else {
            prev.next = next; // 链接目标的前后节点
            x.prev = null;// 断链
        }

        if (next == null) {// 为null，说明目标节点为尾节点
            last = prev; // // 重新赋值尾节点 = 目标节点的上一个节点
        } else {
            next.prev = prev; // 链接目标的前后节点 ，形成双链
            x.next = null;//断链
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }
  • Node<E> node(int index)
    Node<E> node(int index) {
        // assert isElementIndex(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 void addFirst(E e)
    public void addFirst(E e) {
        // 添加元素并链到头节点
        linkFirst(e);
    }
  • public void addLast(E e)
    public void addLast(E e) {
        // 添加元素并链到尾节点
        linkLast(e);
    }
  • public void add(E e) <=>public void addLast(E e)
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
  • public void add(int index, E element)
    public void add(int index, E element) {
        checkPositionIndex(index);
      
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
  • public boolean offer(E e)
    public boolean offer(E e) {
        return add(e);
    }
  • public boolean offerFirst(E e)
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }
  • public void push(E e)
    public void push(E e) {
        addFirst(e);
    }
  • public boolean addAll(int index, Collection<? extends E> c)在index节点之前添加
    /**
     * @param index  index的取值为[0,size]
     *               其中[0-size) 会将集合添加到index之前的位置 eg：[1,2,3].addAll(1,[4,5,6])=[1,4,5,6,2,3]
     *               为size  将集合添加到原集合队尾  eg：[1,2,3].addAll(size,[4,5,6])=[1,2,3,4,5,6]
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length; // 记录入参数组的大小
        if (numNew == 0) // 长度为0，结束
            return false;

        // pred相当于索引
        Node<E> pred, succ;
        // 如果index为目标队列的长度
        if (index == size) {
            // succ:为null节点
            // pred：为队尾节点
            succ = null;
            pred = last;
        } else {
            // 可以理解为在index位置将原链“拆分”为2条链
            // succ:index位置的节点
            // pred：index位置节点的上一个节点
            succ = node(index);
            pred = succ.prev;
        }

        // 遍历入参数组
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            // 新建一个节点
            // index in [0,size),上链为index位置节点的上一个节点，即pred
            // index = size,上链为队尾last节点，即pred
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null) // index位置为头节点的情况
                first = newNode; // 重新赋值头节点
            else
                pred.next = newNode; // 新建节点和pred节点形成双链
            pred = newNode; // 把pred指向新建的这个节点，执行下一次循环
        }
        // 到此，pred节点为入参集合的最后一个元素的节点

        if (succ == null) { // 说明index为size的情况
            last = pred; // 重新赋值队尾节点
        } else {
            // 重新双链之前在index位置"拆分"出来的2条链，形成一整条链
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;// 更新当前链表长度
        modCount++;
        return true;
    }
  • public boolean addAll(Collection<? extends E> c)
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c); // 从队尾添加
    }

二、删

  • public E removeFirst() 返回值为移除的节点的元素值
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
  • public E remove()返回值为移除的节点的元素值
    public E remove() {
        return removeFirst();
    }
  • public E removeLast()，返回值为移除的节点的元素值
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
  • public boolean remove(Object o)移除元素位置上的节点,返回值为是否查到当前元素的节点,一次只会移除一个节点
    public boolean remove(Object o) {
        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;
    }
  • public E remove(int index)，返回值为移除的节点的元素值
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
  • public E pollFirst()返回值为移除的节点的元素值
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
  • public E pollLast()返回值为移除的节点的元素值
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }
  • public E pop()返回值为移除的节点的元素值
    public E pop() {
        return removeFirst();
    }

三、改

  • public E set(int index, E element)，返回值为index节点修改之前的元素
    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
  • public void 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++;
    }

四、查

  • public E get(int index)
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
  • public E getFirst()
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }
  • public E getLast()
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }
  • public E peekFirst()
    public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }
  • public E peekLast()
   public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }
  • public int indexOf(Object o)
    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;
    }
  • public boolean contains(Object o)
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }
  • public E element()
    public E element() {
        return getFirst();
    }
Guxxxd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java LinkedList集合功能实例解析
08-19
Java LinkedList集合是Java集合框架中的一种重要实现，基于链表数据结构，提供了许多有用的方法来操作集合元素。下面对Java LinkedList集合的功能进行详细介绍。 LinkedList集合的基本操作 LinkedList集合继承自...
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
Java集合 LinkedList
Code-5的博客
02-12 988
LinkedList是Java中的一个重要的数据结构，它实现了List接口，提供了链表数据结构的实现。LinkedList类中包含了各种常用的链表操作，如添加、删除、查找等。LinkedList的特点是元素可以动态地添加到链表的任意位置，并且链表中的元素可以按照它们被添加的顺序来遍历。我们想要创建一个可以添加、删除和查找学生的链表。类中，没有直接提供删除指定索引的学生的方法。使用indexOf方法找到要删除学生的索引。使用remove方法删除该索引处的元素。
Java集合之LinkedList
骑着猪猪去旅行的博客
10-30 2379
LinkedList是实现了List和Deque接口的双向链表，实现了所有可选列表的操作，允许存放所有元素（包括null）
JAVA集合之LinkedList
ABC1234567890ABM的博客
05-13 285
LinkedList底层是一个双向链表，他维护了两个属性fist和last分别指向首节点和尾节点，每个节点（Node对象）中又维护的prev、next、item三个属性，通过prev指向前一个节点，next指向后一个节点，item就是具体的值 当使用无参构造器去构造LinkedList集合时，其实只是做了一个初始化，并没有其他作用。而当使用有参构造器去构造LinkedList，它只有一个参数，参数类型是集合类。有参构造方法调用了无参构造方法，并调用了addAll方法。addAll方法的主要作用是：将指定集.
java的linkedlist_Java集合LinkedList用法总结
weixin_42514921的博客
02-12 337
Java的LinkedList是一种常用的数据容器，与ArrayList相比，LinkedList的增删操作效率更高，而查改操作效率较低。LinkedList 实现了List 接口，能对它进行列表操作。LinkedList 实现了Deque 接口，即能将LinkedList当作双端队列使用。LinkedList 实现了Cloneable接口，能克隆。LinkedList 实现了java.io.Se...
Java集合LinkedList
天高任鸟飞
08-10 326
LinkedList List接口的一个实现类 内部维护了一个双向循环链表 链表中的每一个元素，都使用引用来记录它的前一个元素和后一个元素 从而，将所有的元素连接起来 插入、删除元素，只需要修改元素之间的引用关系 优点 对于增删操作，具有很高的效率 此外，还提供了对元素增删操作的一些特定方法 package bhz.aio; import java.util.Linke...
【Java 集合】LinkedList
LCN29的博客
11-26 1124
** 当前节点的内容 */E item;/** 下一个节点 *//** 上一个节点 */// 当前节点的数据 = element// 当前节点的后置节点 = next// 当前节点的前置节点 = prevNode 节点中除了指向下一个节点的 next, 还包含指向上一个节点的 prev, 所以 LinkedList 是一个双向的链表。
java 集合LinkedList、ArrayList、Set
weixin_33427346的博客
11-08 2105
集合类体系结构 Collection集合常用方法 Collection集合的遍历 —— Iterator：迭代器，集合的专用遍历方式 List集合——有序且允许重复 List集合特有方法： Iterator是从前往后迭代； ListIterator是list特有的迭代器，可以从任意方向迭代 增强for循环 目的：简化数组和Collection集合的遍历 内部原理：Iterator迭代器 int[] arr = {1,2,3,4,5}; for(int i:arr){
Java集合 LinkedList 底层详解
mocas_wang的博客
11-28 639
1基本介绍 LinkedList类是List接口的实现类，它是一个集合，可以根据索引来随机的访问集合中的元素，还实现了Deque接口，它还是一个队列，可以当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是通过一个动态的Object[]数组实现的，而LinkedList的底层是通过链表来实现的，因此它的随机访问速度是比较差的，但是它的删除，插入操作很快。 LinkedList是基于双向循环链表实现的，除了可以当作链表
java集合LinkedList类常见使用(超详细)(初学者必看!)
sweetser的博客
11-27 5140
LinkedList = Linked + List = 链表 + 列表 =链表列表LinkedList的底层是 双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
Java集合 LinkedList的原理及使用
梁初夏的专栏
06-29 3064
本文基于java8从定义一个LinkList入手，逐步展开，从源码角度分析LinkedList双向链表的结构是如何构建的，同时针对其常用方法进行分析，包括get，add，remove以及常用的遍历方法，并简单的说明了它的插入、删除操作为何相对高效，而取值操作性能相对较低
简单了解java集合框架LinkedList使用方法
08-18
"Java集合框架LinkedList使用方法" Java集合框架中的LinkedList是一个双向链表，具有链表底层实现的特点，查询速度慢，增删速度快。LinkedList是Java集合框架中的一个重要组件，广泛应用于各种软件系统中。本文将...
java集合-LinkedList的使用
06-14
基于双向链表实现的列表，支持在任意位置的插入和删除操作。
Java中集合LinkedList的原理与使用方法
08-25
LinkedList是Java集合框架中List接口的一个实现，它是一种基于链表结构的数据容器。本文将深入探讨LinkedList的原理和使用方法。 首先，LinkedList是一个双向链表，意味着每个元素（节点）都有指向前后元素的引用。...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1173
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 470
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 228
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1931
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值