LinkedList （概念、使用，遍历，以及与ArrayList的区别）

最新推荐文章于 2023-05-17 20:08:43 发布
最新推荐文章于 2023-05-17 20:08:43 发布
阅读量228 收藏 1
点赞数 3
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52083255/article/details/120961075
版权

**List 的实现类之二--------LinkedList **

当在 ArrayList 任意位置进行插入或者删除元素时，需要将后序元素整体往前或往后搬移，时间复杂度为O(n)，效率比较低，因此：Java 集合中又引入了另一种结构 ：LinkedList，即链表结构;

ArrayList

LinkedList 介绍

LinkedList 是一个普通的类，底层采用链表结构，它继承自 AbstractList, 实现了 List 、Deque、Cloneable和 Serializable 等接口；

LinkedList 使用

LinkedList 的 2 种构造方式

由于底层结构是链表，所以没有容量一说，因此构造方式 比 ArrayList 少一个；

  • 无参构造 LinkedList()
 List<Integer> list1=new LinkedList<>();
  • 利用其他 Collection 中的元素构造： public LinkedList(Collection<? extends E> c)
 List<String> al = new ArrayList<>();
        al.add("111");
        al.add("222");
       //使用其他容器构造
       List<String> list1=new LinkedList<>(al);
       System.out.println(list1); //[111, 222]

LinkedList 的常见方法

（1） public boolean add(E e)： 尾部插入元素 e

 List<String> list=new LinkedList();
       list.add("0000");
       list.add("1111");
     System.out.println(list);  //[0000, 1111]

(2) public void add(int index, E e): 在index 位置插入e

 List<String> list=new LinkedList();
     list.add("0000");
     list.add("1111");
     list.add(0,"5555");
     System.out.println(list); //[5555, 0000, 1111]

(3) public boolean addAll(Collection<? extends E> c)：尾部插入 c 中的元素

//将list中的所有元素插入到list1中
   List<String> list=new LinkedList();
        list.add("0000");
        list.add("1111");
        List<String> list1=new LinkedList<>();
        list1.addAll(list);  
        System.out.println(list1); //[0000,1111]

（4） public int size()：获取有效元素的个数

   System.out.println(list.size());

(5) public E remove(int index) :删除 index 位置元素

 List<String> list=new LinkedList();
        list.add("0000");
        list.add("1111");
        list.remove(1);
        System.out.println(list); //[0000]

(6) public boolean remove(E e) ：删除指定元素 e

 List<String> list=new LinkedList();
        list.add("0000");
        list.add("1111");
        list.remove("0000");
        System.out.println(list);//[1111]

(7) public boolean contains(E e）：是否包含元素 e

 List<String> list=new LinkedList();
     list.add("0000");
     list.add("1111");
     //包含返回true
     System.out.println(list.contains("0000")); 
      //不包含，返回false
    System.out.println(list.contains("9999"));

（8）public E get(int index)：获取 index 位置元素

List<String> list=new LinkedList();
      list.add("0000");
      list.add("1111");
   System.out.println(list.get(1)); //1111

(9) public E set(int index, E e)：将 index 位置元素设置为 e

List<String> list=new LinkedList();
        list.add("0000");
        list.add("1111");
        list.set(1,"2222");
     System.out.println(list);//[0000, 2222]

(10) public int indexOf(E e)：从前往后找，返回第一次 e 出现的下标

List<String> list=new LinkedList();
        list.add("0000");
        list.add("3333");
        list.add(1,"0000");
    System.out.println(list.indexOf("0000"));//0

(11) public int lastIndexOf(E e)：从后往前找，返回第一次 e出现的下标

List<String> list=new LinkedList();
        list.add("0000");
        list.add("3333");
        list.add(1,"0000");
     System.out.println(list.lastIndexOf("0000")); // 1

(12) public List<E> subList(int fromIndex, int toIndex)：截取 [fromIndex,toIndex) 部分

 List<String> list=new LinkedList();
        list.add("0000");
        list.add("1111");
        list.add("2222");
        list.add("3333");
        list.add("4444");
  System.out.println(list.subList(1,4));//[1111, 2222, 3333]

(13) public boolean isEmpty()：判定链表是否为空

 System.out.println(list.isEmpty());

(14) public void clear()：清空

 list.clear();
System.out.println(list.size()); //0

LinkedList 的遍历

两种遍历方式：
foreach
迭代器遍历

package day20211018;
import java.util.List;
import java.util.LinkedList;
import java.util.ListIterator;
public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        // foreach 遍历
        for (int e:list) {
            System.out.print(e + " ");
        }
        System.out.println(); // 1 2 3 4
            // 迭代器遍历
            ListIterator<Integer> it = list.listIterator();
            while(it.hasNext()){
                System.out.print(it.next()+ " ");
            }
            System.out.println(); //1 2 3 4
    }
}

补充----链表

链表的概念

链表在物理上：是一种非连续的存储结构；
在逻辑上：数据元素的逻辑顺序是通过链表中的引用来依次链接的；
生活中的实例：类似于火车的结构

链表中的元素存储在一个一个的结点之中；

结点中包含有两个字段：
value：每个结点中元素的值域
next：用来指向下一个结点

需要注意的是：每个结点都是一个对象，而 next只是个引用，并不是对象；

链表的常见结构
  • 单向链表与双向链表

单向链表：
在这里插入图片描述
双向链表：

在这里插入图片描述

  • 带头链表与不带头链表

不带头结点：
在这里插入图片描述
带头结点链表：
在这里插入图片描述

  • 循环链表与非循环链表

非循环链表：
在这里插入图片描述
循环链表：
在这里插入图片描述

注：组合起来就有 8 种结构

链表实现
  • （1 ） 模拟实现不带头结点的单链表
package day20211018;

   //模拟实现：不带头结点的单链表
public class SingleLinkList<E> {
   public static class Node<E> {
      E value;
      Node<E> next;

      //构造方法
      public Node(E value) {
         this.value = value;
      }
   }
      Node<E> head; //用来指向链表中的第一个有效结点
      //获取单链表的有效长度
      public int size(){
         Node<E> cur=head;
         int count=0;
         while(null != cur){
            count++;
            cur=cur.next;
         }
         return count;
      }


      // 头插 e
      public void addFirst(E e){
         Node<E> newNode=new  Node<>(e);
         if(null==head){
            head=newNode;
         }else{
            newNode.next=head;
            head=newNode;
         }
      }


      // 尾插e
      public void addLast(E e) {
         Node<E> newNode = new Node<>(e);
         if (null == head) {
            head = newNode;
         } else {
            //找最后一个结点
            //cur 指向第一个结点
            Node<E> cur = head;
            //pre 来标记最后一个结点的位置
            Node<E> pre = null;
            while (null != cur) {
               pre = cur;
               cur = cur.next;
            }
            //插入新结点
            pre.next = newNode;
         }
      }
      //任意位置插入e,第一个数据结点为0号位置
      public boolean addIndex(int position,E e){
         //1.检测参数是否合法
         if(position < 0 || position >= 4){
            throw new IllegalArgumentException("参数不合法");
         }
         if(0==position){
            addFirst(e);
            return true;
         }
         //2.找到position位置的结点，并将其前一个保存(插在position位置的前面)
         Node<E> cur=head;
         Node<E> pre=null;
         while(0 != position){
            pre=cur;
            cur=cur.next;
            position--;
         }
         //3 插入新结点

         Node<E> newNode=new Node<E>(e);
         newNode.next=cur;
         pre.next=newNode;

         return true;
      }

      //删除第一次出现关键字为e的结点
      public void remove(E e){
         Node<E> cur=head;
         Node<E> prev=null;
         //prev 用来标记cur
         while(null != cur){
            if(e.equals(cur.value)){
               cur.value=null;
               if(prev==null){
                  //说明删除的是第一个结点
                 head=cur.next;
            }else{
                  //删除其他结点
                  prev.next=cur.next;
               }
            return;
            }
            prev=cur;
            cur=cur.next;
         }
      }

      //删除所有值为e的结点
     public void removeAllKey(E e) {
        //时间复杂度O(N^2)
        /*while(contains(e)){
           remove(e);
        }*/
        Node<E> cur=head;
        Node<E> prev=null;
        while(null!= cur){
           if(e.equals(cur.value)){
              //删除结点
              cur.value=null;
              if(prev==null){
                 head=cur.next;
                 cur=head;
              }else{
                 prev.next=cur.next;
                 cur=prev.next;
              }

           }else{
              prev=cur;
              cur=cur.next;
           }

        }
      }

      //查找是否包含关键字 e
      public boolean contains(E e) {
         Node<E> cur=head;
         while(null!=cur){
            if(e.equals(cur.value)){
               return true;
            }
            cur=cur.next;
         }
         return false;
      }
     
      @Override
      public String toString(){
         Node<E> cur=head;
         String s="[";
         while(null!= cur){
            s+=cur.value;
            if(null !=cur.next){
               s+=",";
            }

            cur=cur.next;
         }
         s+="]";
         return s;
      }

      public static void main(String[] args) {
         SingleLinkList<Integer> s=new SingleLinkList<>();
         System.out.println(s); //[]
         //测试尾插
         s.addLast(1);
         s.addLast(2);
         s.addLast(3);
         s.addLast(4);
         System.out.println(s); //[1,2,3,4]
         System.out.println(s.size()); //4
         //测试是否包含元素e
         System.out.println(s.contains(2)); //true
         System.out.println(s.contains(5)); //false
         //测试头插
         s.addFirst(0);
         System.out.println(s);  //[0,1,2,3,4]
         //测试任意位置插入
         s.addIndex(0,0);
         System.out.println(s); //[0,0,1,2,3,4]
         s.addIndex(3,5);
         System.out.println(s); //[0,0,1,5,2,3,4]
         //删除所有值为0的元素
         s.removeAllKey(0);
         System.out.println(s); //[1,5,2,3,4]
         //测试remove
         s.remove(5);
         System.out.println(s); //[1,2,3,4]
      }
   }

动起小手往下戳~~
在这里插入图片描述

总结—ArrayList 与 LinkedList 的联系与区别

  • 相同点：两者均实现了 List 接口；
  • 不同点体现在以下方面：

（1）由于ArrayList 底层采用数组来存储元素,支持随机访问；
（2）LinkedList 底层采用双向链表结构，不支持随机访问；
（3）ArrayList 支持扩容，LinkedList 没有扩容这个概念；
（4）在存储空间上：ArrayList 在物理上是一定连续的，LinkedList 逻辑上是连续的，但物理上不一定连续；
（5）在任意位置进行元素的插入与删除时，ArrayList 需要通过搬移元素后，将位置腾出后，才可以进行插入，因此，时间复杂度为O(N)，效率慢；
LinkedList 只需要修改引用的指向即可，时间复杂度为O(1)，效率较高；
换句话说：在元素进行高效访问时，优先考虑 ArrayList，在进行任意位置插入与删除元素时，优先考虑 **LinkedList**.

躲不过️动
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinkedList简单介绍
lihoo747的博客
11-18 856
大家好，我是IT修真院北京分院第27期的JAVA学员，一枚正直纯洁善良的java程序员。 今天给大家分享一下，修真院官网Java任务10，深度思考中的知识点———LinkedList简单介绍   1.背景介绍 1.Collection 接口： Collection接口是所有集合类的根节点，Collection表示一种规则，所有实现了Collection接口的类遵循这种规则 2.List ...
ArrayList与LinkedList的使用以及区别
菜鸟也学大数据的博客
07-30 311
一.List的特点 List本身是有序，可重复的，所以ArrayList与LinkedList也同样是这样 二.ArrayList ArrayList的底层原理是数组，当创建集合并传入第一个对象时初始长度是10，当一直传入对象直到达到容量最小值时，便会创建一个比原来长1.5倍的新数组，并将原来的数组内容，都转移至新数组，原有数组将被回收，但ArrayList的最大容量为0x7fffffff 其数组存储方法，可以使ArrayList在遍历与查找的速度上更快一些 增删查改等方法的使用 import ja
ArrayList和LinkedList的基本用法以及区别
gh323093的博客
06-22 2699
Java学习笔记之ArrayList基本用法https://blog.csdn.net/gongchuangsu/article/details/51514389ArrayList简介ArrayList是一个其容量能够动态增长的动态数组。它继承了AbstractList，实现了List、RandomAccess, Cloneable, java.io.Serializable。基本的ArrayLi...
ArrayList和LinkedList的基本用法与区别
Hydra的博客
08-15 307
用法： ArrayList是线性表（数组） get()直接读取第几个下标，复杂度O(1) add(E)添加元素,直接在后面添加，复杂度O(1) add(index,E)添加元素，在第几个元素后面插入，后面的元素需要向后移动，复杂度O(n) remove() 删除元素,后面的元素需要逐个移动，复杂度O(n) LinkedList是链表的操作 get()获取第几个元素，依次遍历，复杂度O...
深入理解LinkedList
weixin_46272350的博客
08-15 1035
什么是LinkedList 概念： LinkedList是基于链表实现的，所以先讲解一下什么是链表。链表是一种线性的存储结构，意思是将要存储的数据存在一个存储单元里面，这个存储单元里面除了存放有待存储的数据以外，还存储有其下一个存储单元的地址（下一个存储单元的地址是必要的，有些存储结构还存放有其前一个存储单元的地址），每次查找数据的时候，通过某个存储单元中的下一个存储单元的地址寻找其后面的那个存储单元。理解：LinkedList是一个双向链表，也就是说list中的每个元素，在存储自身值之外，还 额外存储
Java中ArrayList和LinkedList的遍历与性能分析
09-01
主要给大家介绍了ArrayList和LinkedList这两种list的五种循环遍历方式，各种方式的性能测试对比，根据ArrayList和LinkedList的源码实现分析性能结果，总结结论。相信对大家的理解和学习具有一定的参考价值，有需要的...
Java数据存储类型ArrayList、HashSet、HashMap、LinkedList使用不同遍历方法效率研究By Python
12-22
Java不同数据存储类型使用不同遍历方法效率研究 GitHub代码仓库 数据存储类型 ArrayList HashSet HashMap LinkedList 遍历方法 传统遍历方法 for(int i=0;i<list.size();i++) { String str = list.get(i); ... ...
java 中ArrayList与LinkedList性能比较
08-31
ArrayList与LinkedList性能比较在java中 ArrayList和LinkedList是java中两个常用的实现List接口的类，它们之间的性能比较是一个非常重要的知识点。 首先，让我们来了解ArrayList和LinkedList的实现原理。ArrayList...
ArrayList和LinkedList区别及使用场景代码解析
08-28
ArrayList和LinkedList区别及使用场景代码解析 ArrayList和LinkedList都是Java集合框架中的重要成员，它们都是List接口的实现类，但它们在实现机制、性能和使用场景等方面存在着很大的差异。 ArrayList ...
从源码角度彻底搞懂LinkedList
潇风寒月
05-17 1494
LinkedList源码赏析 一、概述 LinkedList，相对于ArrayList，大家可能平时使用LinkedList要少一些，其实有时候使用LinkedList比ArrayList效率高很多，当然，这得视情况而定。 本文将带大家深入LinkedList源码，分析其背后的实现原理，以便以后在合适的情况下进行使用。 之前我所知道的LinkedList的知识： Lin...
Java重要类之LinkedList
Darlin_F的博客
07-19 201
一、ArrayList与LinkedList 基本概念：List是一个接口，Arraylist和LinkedList是它的两个实现类，只是实现的方式不一样。我在“单链表java实现”一文中已经对单链表的结构和基本方法进行了实现，这里要说的LinkedList是java封装好的双向链表数据结构，而ArrayList是用数组实现的，它不是真正的链表，在初始化的时候它先对数组设置一个初始容量，当数组空...
LinkedList的遍历
qq_43776742的博客
06-12 441
3地方
java中ArrayList集合的三种遍历方式，简单易懂
huangjing8203的博客
03-17 460
前言 在java中存储数据的方式有很多种，最开始接触到的是定义一个变量去接收，然后是数组，集合等等，但是这些数据仅仅是存储在内存当中，不能实现永久保存，而且数组的长度是固定的，而集合刚好解决了这个问题，集合的长度是可变的，除此之外，集合可以存放的数据类型可以是多种而不再是单一的数据类型。 那么，集合存储完数据，我们一般是怎么获取到里面的数值呢？和数组的取值方式有什么不一样呢？这里简单的列出三种不...
LinkedList集合对元素进行增、查、删操作
黑马程序员官方博客
03-28 2232
ArrayList集合在查询元素时速度很快，但在增删元素时效率较低，为了克服这种局限性，可以使用List接口的另一个实现类LinkedList。 LinkedList集合内部包含有两个Node类型的first和last属性维护一个双向循环链表，在链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素，从而可以将所有的元素彼此连接起来。 当插入一个新元素时，只需要修改元素之间的这种引用关系即可，删除一个节点也是如此。 正因为这样的存储结构，所以LinkedList集合对于元素的增删操作表现出很高的
JAVA中ArrayList和LinkedList的区别
m0_50373778的博客
04-28 3795
JAVA中ArrayList和LinkedList的区别 ArrayList和LinkedList的大致区别如下: 1.ArrayList是基于动态数组的数据结构实现，LinkedList是基于双向链表实现。 2.对于随机访问的get和set方法，ArrayList要优于LinkedList，因为ArrayList基于数组，获取任意元素的位置时间复杂度为O(1)，LinkedList基于链表，时间复杂度则为O(n)。 3.对于新增和删除操作add和remove，LinkedList比较占优势，因为如果Arr
java的linkedlist_Java集合 LinkedList的原理及使用
weixin_34315264的博客
02-12 255
LinkedList和ArrayList一样是集合List的实现类，虽然较之ArrayList，其使用场景并不多，但同样有用到的时候，那么接下来，我们来认识一下它。一. 定义一个LinkedListpublic static void main(String[] args) {List stringList = new LinkedList<>();List tempList = ne...
Java集合之LinkedList
最新发布
GeraldTetris的博客
05-17 229
LinkedList继承自AbstractSequentialList，是List和Deque接口的双向链表实现，其底层维护一个双向链表存储元素。它实现了所有可选的列表操作，并且只能存储同一种引用类型的数据，但是包括null。动态扩容非线程安全允许插入的元素重复插入的元素是有序的（即按照添加的先后顺序排序）随机访问速度慢，可以使用下标访问（底层使用双向链表实现，访问元素需要遍历链表）插入和删除速度快（只需要改变相关节点引用的指向即可）
ArrayList和LinkedList区别？看完秒懂~
热门推荐
m0_68103666的博客
04-11 3万+
工作中，大家是不是经常分不清楚，什么时候用ArrayList，什么时候用LinkedList？
ArrayList 与 LinkedList 的方法及其区别
m0_66789766的博客
04-28 380
3.LinkedList 的常用方法 二、聊聊 ArrayList 1. ArrayList 的底层源码 2. ArrayList 的构造方法 3. ArrayList 的常用方法 三、两者与 Vector 的区别 1.ArrayList 和 LinkedList 的区别 2.ArrayList 和 Vector 的区别 [](()一、聊聊 LinkedList [](()1.LinkedList 的底层源码 public class LinkedList ex..
arraylist和linkedlist遍历
04-12
ArrayList和LinkedList都是可用于存储数据的集合类，但它们的遍历方式略有不同。ArrayList是通过索引顺序读取元素，而LinkedList则是通过链表的方式遍历元素。因此，当涉及到需要随机访问、删除、添加元素时，ArrayList比较适用，而当需要频繁的插入、删除时，LinkedList则比较适用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值