【LinkedList】常用方法大全

于 2023-12-12 23:53:44 发布
阅读量1.3k 收藏 17
点赞数 18
文章标签： java windows 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_44946030/article/details/134938443
版权

1、添加元素：

push、offerFirst都调用了addFirst函数，只不过push和addFirst一样没有返回值，offer会返回true；add背后通过linkLast(e)源码实现且有返回值

具体方法实现备注
addpublic boolean add(E e) {linkLast(e); return true;}有返回值
offerpublic boolean offer(E e) {return add(e); }有返回值
addFirst public void addFirst(E e) {linkFirst(e);}无返回值
pushpublic void push(E e) {addFirst(e);}等价于addFirst
offerFirst public boolean offerFirst(E e) {addFirst(e);return true;}有返回值
addLastpublic void addLast(E e) {linkLast(e);}无返回值
offerLastpublic boolean offerLast(E e) {addLast(e);return true;}有返回值

2、删除元素：

remove、pop都调用了removeFirst函数，removeFirst函数内部又调用了unlinkFirst；poll内部也调用了unlinkFirst；poll与remove和pop不同的是poll在链表为空调用时返回null，另外两个抛出NoSuchElementException异常

具体方法实现备注
removeFirstpublic E removeFirst() { final Node<E> f = first; if (f == null) throw new NoSuchElementException();return unlinkFirst(f);}会抛出NoSuchElementException异常
removeLastpublic E removeLast() {final Node<E> l = last;if (l == null)throw new NoSuchElementException();return unlinkLast(l);}会抛出NoSuchElementException异常
removepublic E remove() { return removeFirst(); }会抛出NoSuchElementException异常
removepublic E remove(int index) {checkElementIndex(index);return unlink(node(index));}会抛出IndexOutOfBoundsException异常
poppublic E pop() {return removeFirst(); }会抛出异常
poll·public E poll() {final Node<E> f = first;return (f == null) ? null : unlinkFirst(f); }为空是返回null
pollFirstpublic E pollFirst() { final Node<E> f = first; return (f == null) ? null : unlinkFirst(f);}为空是返回null
pollLastpublic E pollLast() {final Node<E> l = last;return (l == null) ? null : unlinkLast(l);}为空是返回null

3、测试代码

public class testLinkedList {
    public static void main(String[] args) {
        LinkedList<Integer> list=new LinkedList<>();
        /*
        增加元素
         */
        //1、add向末尾增加一个元素,添加成功返回为true
        boolean result1=list.add(1);
        boolean result2=list.add(2);
        list.add(2);
        list.add(2);
        list.add(2);
        System.out.println("测试1插入1、2、2、2、2：");
        System.out.println(list.toString());
        System.out.println(result1);
        //2、add向指定位置插入元素,没有返回值
        list.add(1,1000);
        System.out.println("测试2在下标1处插入1000：");
        System.out.println(list.toString());
        //3、addFirst向链表头插入元素,没有返回值
        list.addFirst(3);
        System.out.println("测试3在表头插入3：");
        System.out.println(list.toString());
        //4、offerFirst，如果成功返回true
        boolean result8=list.offerFirst(5);
        System.out.println("测试4在表头插入5：");
        System.out.println(list.toString());
        System.out.println(result8);
        //5、向链表中第一个位置插入元素，无返回值
        list.push(8);
        System.out.println("测试5在表头插入8：");
        System.out.println(list.toString());
        //6、addLast向链表尾插入元素,没有返回值
        list.addLast(4);
        System.out.println("测试6在表头插入4：");
        System.out.println(list.toString());
        //7、offer向链表尾部插入元素，插入成功返回true
        boolean result10=list.offer(7);
        System.out.println("测试7在表尾插入7：");
        System.out.println(result10);
        System.out.println(list.toString());
        //8、offerLast,向链表尾部插入元素，插入成功返回true
        boolean result9=list.offerLast(6);
        list.offerLast(2);
        list.offerLast(2);
        list.offerLast(2);
        System.out.println("测试8在表尾插入6、2、2、2：");
        System.out.println(result9);
        System.out.println(list.toString());

         /*
        获取元素
         */
        //9、contains检查list里是否包含某些元素，如果包含返回true
        boolean result3=list.contains(1000);
        boolean result4=list.contains(10000);
        System.out.println("测试9检查链表中是否包含1000、10000：");
        System.out.println(result3);
        System.out.println(result4);
        //10、根据下标获取元素
        Integer result5=list.get(2);
        System.out.println("测试10获取下标2的元素：");
        System.out.println(result5);
        //11、获取链表中第一个元素
        Integer result6=list.getFirst();
        System.out.println("测试11获取第1个元素：");
        System.out.println(result6);
        //12、获取链表中最后一个元素
        Integer result7=list.getLast();
        System.out.println("测试12获取最后1个元素：");
        System.out.println(result7);
        //13、获取链表的第1个元素
        Integer result11=list.peek();
        System.out.println("测试13获取链表的第1个元素：");
        System.out.println(result11);
        //14、获取链表的第1个元素
        Integer result12=list.peekFirst();
        System.out.println("测试14获取链表的第1个元素：");
        System.out.println(result12);
        //15、获取链表的最后1个元素
        Integer result13=list.peekLast();
        System.out.println("测试15获取链表的最后1个元素：");
        System.out.println(result13);

        /*
        删除元素
         */
        //16、pop 删除链表中第一个元素，链表为空执行删除时抛异常
        list.pop();
        System.out.println(list.toString());
        System.out.println("测试16删除链表中第1个元素：");
        //17、poll 删除链表中第一个元素，链表为空时，返回null
        list.poll();
        System.out.println(list.toString());
        System.out.println("测试17删除链表中第1个元素：");
        //18、pollFirst 删除链表中第一个元素，链表为空时，返回null
        list.pollFirst();
        System.out.println(list.toString());
        System.out.println("测试18删除链表中第1个元素：");
        //19、pollLast 删除链表中最后1个元素，链表为空时，返回null
        list.pollLast();
        System.out.println("测试19删除链表中第1个元素：");
        System.out.println(list.toString());
        //20、remove 删除链表中第1个元素
        list.remove();
        System.out.println("测试20删除链表中第1个元素：");
        System.out.println(list.toString());
        //21、removeFirst 删除链表中第1个元素
        list.removeFirst();
        System.out.println("测试21删除链表中第1个元素：");
        System.out.println(list.toString());
        //22、remove 删除链表中第1个元素
        list.removeLast();
        System.out.println("测试22删除链表中第1个元素：");
        System.out.println(list.toString());
        //23、IndexOutOfBoundsException
        boolean result14=list.remove(Integer.valueOf(2));
        System.out.println("测试23删除链表中下标为2元素：");
        System.out.println(result14);
        System.out.println(list.toString());
        //24、remove(index)会报java.lang.IndexOutOfBoundsException异常
        list.remove(1);
        System.out.println("测试24删除链表中下标为1的元素：");
        System.out.println(list.toString());
        //25、removeFirstOccurrence删除元素在链表中第一次出现的位置
        list.removeFirstOccurrence(Integer.valueOf(2));
        System.out.println("测试25删除链表中2第一次出现位置的元素：");
        System.out.println(list.toString());
        //26、removeLastOccurrenceremoveLastOccurrence
        list.removeLastOccurrence(Integer.valueOf(2));
        System.out.println(list.toString());
        //27、清空链表
        list.clear();
        System.out.println("测试26清空链表：");
        System.out.println(list.toString());
        list.removeLastOccurrence(Integer.valueOf(2));
        list.pop();
//        list.removeFirst();

    }
}

4、输出结果

测试1插入1、2、2、2、2：
[1, 2, 2, 2, 2]
true
测试2在下标1处插入1000：
[1, 1000, 2, 2, 2, 2]
测试3在表头插入3：
[3, 1, 1000, 2, 2, 2, 2]
测试4在表头插入5：
[5, 3, 1, 1000, 2, 2, 2, 2]
true
测试5在表头插入8：
[8, 5, 3, 1, 1000, 2, 2, 2, 2]
测试6在表头插入4：
[8, 5, 3, 1, 1000, 2, 2, 2, 2, 4]
测试7在表尾插入7：
true
[8, 5, 3, 1, 1000, 2, 2, 2, 2, 4, 7]
测试8在表尾插入6、2、2、2：
true
[8, 5, 3, 1, 1000, 2, 2, 2, 2, 4, 7, 6, 2, 2, 2]
测试9检查链表中是否包含1000、10000：
true
false
测试10获取下标2的元素：
3
测试11获取第1个元素：
8
测试12获取最后1个元素：
2
测试13获取链表的第1个元素：
8
测试14获取链表的第1个元素：
8
测试15获取链表的最后1个元素：
2
[5, 3, 1, 1000, 2, 2, 2, 2, 4, 7, 6, 2, 2, 2]
测试16删除链表中第1个元素：
[3, 1, 1000, 2, 2, 2, 2, 4, 7, 6, 2, 2, 2]
测试17删除链表中第1个元素：
[1, 1000, 2, 2, 2, 2, 4, 7, 6, 2, 2, 2]
测试18删除链表中第1个元素：
测试19删除链表中第1个元素：
[1, 1000, 2, 2, 2, 2, 4, 7, 6, 2, 2]
测试20删除链表中第1个元素：
[1000, 2, 2, 2, 2, 4, 7, 6, 2, 2]
测试21删除链表中第1个元素：
[2, 2, 2, 2, 4, 7, 6, 2, 2]
测试22删除链表中第1个元素：
[2, 2, 2, 2, 4, 7, 6, 2]
测试23删除链表中下标为2元素：
true
[2, 2, 2, 4, 7, 6, 2]
测试24删除链表中下标为1的元素：
[2, 2, 4, 7, 6, 2]
测试25删除链表中2第一次出现位置的元素：
[2, 4, 7, 6, 2]
[2, 4, 7, 6]
测试26清空链表：
[]
Exception in thread “main” java.util.NoSuchElementException
at java.util.LinkedList.removeFirst(LinkedList.java:270)
at java.util.LinkedList.pop(LinkedList.java:801)
at lrrtcode.testLinkedList.main(testLinkedList.java:141)

慢慢来的小邵
关注
  • 18
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
容器中基于链路的linkedList方法的底层实现
06-25
容器中基于链路的linkedList方法的底层实现
LinkedList 方法大全（栈、队列）
赶路人儿
01-12 7947
LinkedList类是双向列表（底层使用链表结构），列表中的每个节点都包含了对前一个和后一个元素的引用。LinkedList有很多方法，通过这些方法可以很容易将其用作队列、栈等数据结构。   1、常用方法： 1）获取第一、最后一个元素： LinkedListlist = new LinkedList();   System.out.println("链表的第一个元素是: " + li
Java LinkedList
12-16
Java LinkedList Java 集合框架 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。 Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。 与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。 以下情况使用 ArrayL
Java集合框架之：LinkedList的常见方法使用
sjs52406的博客
11-29 1205
本篇文章主要介绍Java LinkedList的使用方法教程及示例代码
java linklist pop,带有示例的Java LinkedList对象pop()方法
weixin_30474629的博客
03-19 960
LinkedList对象pop()方法软件包java.util.LinkedList.pop()中提供了此方法。此方法用于删除或删除或返回或弹出位于链表所表示的堆栈顶部(初始位置或第一位置)的对象。此方法等效于LinkedListremove()或removeFirst()与LinkedList等效。如果List为空，则此方法将引发异常。语法：Objectpop(){}参数：在链接列表的方法中，...
LinkedList用法详解
热门推荐
韩家老大的博客
06-21 1万+
一、LinkedList介绍
LinkedList常用方法
weixin_58696998的博客
04-20 1731
一、介绍 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。链表可分为单向链表和双向链表。 LinkedList和ArrayList的区别 Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。 与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。 以下情况使用 ArrayList : 频繁访问列表中的某一个元素。
剑指offer（Java实现） 从上往下打印二叉树
一只特立独行的猪
09-15 204
题目描述 从上往下打印出二叉树的每个节点，同层节点从左至右打印。 解题思路 利用队列（链表）辅助实现。 代码实现 import java.util.ArrayList; import java.util.LinkedList; /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode r...
简谈LinkedList特有的方法
Star_RainSea的博客
01-19 3239
一、什么是LinkedList集合 二、LinkedList集合特有的方法
linked list java_Java LinkedList offer()方法
weixin_39890543的博客
02-12 2629
Java LinkedList offer()方法java.util.LinkedList.offer(E e)将指定的元素添加为LinkedList的最后一个元素。1 语法public boolean offer(E e)2 参数e：要添加的元素3 返回值返回true。4 示例package com.yiidian;/*** 一点教程网： http://www.yiidian.com*//**...
LinkedList 部分源码
10-24
LinkedList的部分源码解析 包括部分常用的方法: add() ,remove(),get(),set()
Java LinkedList源码分析
01-20
　LinkedList 是一个常用的集合类，用于顺序存储元素。 LinkedList 经常和 ArrayList 一起被提及。大部分人应该都知道 ArrayList 内部采用数组保存元素，适合用于随机访问比较多的场景，而随机插入、删除等操作因为...
JAVA 范例大全 光盘 资源
03-07
JAVA 范例大全 光盘 资源 书籍目录： 前言. 第1章 开发环境搭建 1 实例1 下载、安装并配置JDK 1 实例2 第一个Java程序 3 实例3 在Eclipse中创建第一个Java程序 4 常见问题 javac不是内部或者外部命令 6 常见...
java范例开发大全
03-08
实例219 LinkedList的添加删除操作 395 实例220 运用Vector 397 实例221 改变Properties文件中的键值 399 第13章 多线程编程（教学视频：121分钟） 405 13.1 多线程的五种基本状态 405 实例222 启动线程 405 实例223...
快速入门JAVA数据结构-LinkedList常用方法
qq_53344479的博客
03-02 732
LinkedList相比于ArrayList增加删除的操作效率更高，但是查找和修改的效率更低 适合LinkedList的情况： 1.需要循环迭代访问列表中的某些元素 2.需要频繁的在列表开头、中间、结尾等添加或者删除元素 基本的添加和删除操作：add、pop LinkedList<String> stack = new LinkedList<>(); stack.add("a1"); //添加元素 stack.add("a2")
LinkedList的常见使用方法
最新发布
weixin_72083767的博客
11-29 457
LinkedList的常见使用方法
LinkedList集合的常用方法及底层解析
weixin_52450674的博客
04-05 395
LinkedList集合的常用方法及底层解析 文章目录LinkedList集合的常用方法及底层解析前言一、常用方法二、构造方法无参构造含参构造三、add方法linkLast(e);四、get方法node(index)方法五、 remove方法索引删除节点按元素删除这个节点总结 前言 LinkedList集合属于线性链表结构（双向链表） 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的 优缺点 优点：删除和插入效率高 缺点：查询效率低 注意：
Java中LinkedList类的常用方法
tanxinji的博客
02-07 6758
 LinkedList类有很多方法，可以模拟栈，队列，链表功能。 一、队列  1.入队 add(E e );将e插入队列末尾。  2.出队删除队首 poll() ; 取出队首元素，并且在队列中删除队首。队首为空返回null。  3.出队删除队首 remove(); 取出队首元素，并且在队列中删除队首。队首为空报错。  4.出队不删除队首 peek(); 只返回队首元素，不删除。为空则返回null。  5.出队不删除队首 element(); 只返回队首元素，不删除。为空则报错。 二、栈  1.入栈 push
LinkedList的源码分析（二）
时代新人的博客
10-10 292
4）peekLast()方法：检索但不删除此列表的最后一个元素，如果此列表为空则返回{@code null}。方法：用指定的元素替换此列表中指定位置的元素。方法：将一个元素压入由此列表表示的堆栈。换句话说，将元素插入到列表的前面。方法：检索但不删除此列表的头(第一个元素，可为null)。方法：检索并删除此列表的尾(最后一个元素，可为null)。方法：检索并删除此列表的头(第一个元素，可为null)。方法：添加指定元素作为列表的尾部(最后一个元素)。方法：将指定的元素插入到列表的开头，此时的时间复杂度是。
linkedlist方法
06-10
LinkedList 是 Java 中的一个双向链表数据结构，它提供了一些常用的方法来操作链表。以下是一些常用的 LinkedList 方法： 1. add(element)：在链表的末尾添加一个元素。 2. add(index, element)：在指定位置插入一个元素。 3. remove()：删除链表的最后一个元素。 4. remove(index)：删除指定位置的元素。 5. get(index)：获取指定位置的元素。 6. set(index, element)：将指定位置的元素替换为新的元素。 7. size()：获取链表中元素的个数。 8. clear()：清空链表中的所有元素。 9. isEmpty()：判断链表是否为空。 10. contains(element)：判断链表中是否包含指定的元素。 除此之外，LinkedList 还提供了其他一些方法，例如： 1. addFirst(element)：在链表的头部添加一个元素。 2. addLast(element)：在链表的尾部添加一个元素。 3. removeFirst()：删除链表的第一个元素。 4. removeLast()：删除链表的最后一个元素。 5. getFirst()：获取链表的第一个元素。 6. getLast()：获取链表的最后一个元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值