LinkedList的原理和方法介绍、使用

最新推荐文章于 2023-08-05 17:20:16 发布
最新推荐文章于 2023-08-05 17:20:16 发布
阅读量614 收藏
点赞数
分类专栏： java并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22701869/article/details/106982496
版权

目录

 

LinkedList底层是双向链表

变量

构造方法

public LinkedList()

public LinkedList(Collection c)

常用方法，不讨论最简单的add和remove

public void addFirst(E e)：在把元素添加在链表头

public void addLast(E e)：添加在链表结尾

public void clear()：将数据全部置空，size=0

public Object clone() ：克隆出一个全新的链表，对克隆的链表修改，不会影响原来的链表

public boolean contains(Object o)：对象包含

public Iterator descendingIterator()：链表反序迭代

public E element()：获取首节点的元素

public E getFirst()：获取首节点的值

public E getLast()：获取尾结点

public int indexOf(Object o)：元素在链表中第一次出现的位置

public int lastIndexOf(Object o)：元素在链表中最后一次出现的位置

public ListIterator listIterator(int index)：迭代的时候，能对链表就行修改

offer、offerLast、offerLast，将制定的元素加载到链表尾，链表尾，链表头

public E peek()，peekFirst(),peekLast()：找链表首节点,首节点，尾节点

public E poll()；找到首节点，并删除

public E pollFirst()；找到首节点，并删除首节点

public E pollLast()找到尾节点，并删除尾节点

public E pop()：获取首节点，并删除首节点

public void push(E e)：加入首节点

public boolean removeLastOccurrence(Object o)：移除最后出现的

Object[] toArray()：返回Object[] toArray()，无法强转

public T[] toArray(T[] a) ：转换数据到指定数组

LinkedList底层是双向链表

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

变量

transient Node<E> first;
链表首节点
transient Node<E> last;
链表尾节点
transient int size = 0;
链表存储数据量

构造方法

public LinkedList()

不做任何处理

public LinkedList(Collection<? extends E> c)

通过list构造

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        List<Integer> linkedList = new LinkedList<>(list);
        System.out.println(linkedList);
    }
}

通过LinkedList构造

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        List<Integer> linkedList = new LinkedList<>(list);
        System.out.println(linkedList);
    }
}

常用方法，不讨论最简单的add和remove

跑一遍之后，发现好多方法是重复的

public void addFirst(E e)：在把元素添加在链表头

一定要使用完成类声明LinkedList<Integer> linkedList = new LinkedList<>(list);，使用LinkedList<Integer> linkedList = new LinkedList<>(list);声明无法使用AddFirst（）

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        list.addFirst(6);
        System.out.println(list);
    }
}

结果：

[6, 1, 3, 4, 2]

public void addLast(E e)：添加在链表结尾

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        list.addLast(6);
        System.out.println(list);
    }
}

结果：

[1, 3, 4, 2, 6]

public void clear()：将数据全部置空，size=0

public Object clone() ：克隆出一个全新的链表，对克隆的链表修改，不会影响原来的链表

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        LinkedList<Integer> clone = (LinkedList<Integer>)list.clone();
        clone.remove(1);
        System.out.println(list);
        System.out.println(clone);
    }
}

结果：

[1, 3, 4, 2]
[1, 4, 2]

public boolean contains(Object o)：对象包含

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.contains(1));
        System.out.println(list.contains(0));
    }
}

结果：

true
false

public Iterator<E> descendingIterator()：链表反序迭代

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        Iterator<Integer> integerIterator = list.descendingIterator();
        while(integerIterator.hasNext()){
            System.out.println(integerIterator.next());
        }
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

结果：

2
4
3
1
1
3
4
2

public E element()：获取首节点的元素

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.element());
    }
}

结果：首节点是1，所以输入1

1

public E getFirst()：获取首节点的值

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.getFirst());
    }
}

结果：首节点是1，输入1

1

public E getLast()：获取尾结点

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.getLast());
    }
}

结果：尾结点是2，输出2

2

public int indexOf(Object o)：元素在链表中第一次出现的位置

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.indexOf(3));
    }
}

结果：下标从0开始，没有返回-1

1

public int lastIndexOf(Object o)：元素在链表中最后一次出现的位置

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.indexOf(5));
        System.out.println(list.lastIndexOf(3));
    }
}

结果：

-1
3

public ListIterator<E> listIterator(int index)：迭代的时候，能对链表就行修改

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        ListIterator<Integer> integerListIterator = list.listIterator();
        while(integerListIterator.hasNext()){
            System.out.println(integerListIterator.next());
            integerListIterator.set(8);
            integerListIterator.add(6);
        }
        System.out.println(list);
    }
}

结果：

1
3
4
3
[8, 6, 8, 6, 8, 6, 8, 6]

offer、offerLast、offerLast，将制定的元素加载到链表尾，链表尾，链表头

public E peek()，peekFirst(),peekLast()：找链表首节点,首节点，尾节点

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.peek());
        System.out.println(list.peekFirst());
        System.out.println(list.peekLast());
        System.out.println(list);
    }
}

结果：

1
1
3
[1, 3, 4, 3]

public E poll()；找到首节点，并删除

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.poll());
        System.out.println(list);
    }
}

结果：

1
[3, 4, 3]

public E pollFirst()；找到首节点，并删除首节点

public E pollLast()找到尾节点，并删除尾节点

public E pop()：获取首节点，并删除首节点

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.pop());
        System.out.println(list.pop());
        System.out.println(list.pop());
        System.out.println(list.pop());
        System.out.println(list);
    }
}

结果：

1
3
4
3
[]

public void push(E e)：加入首节点

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        list.push(6);
        list.push(7);
        list.push(8);
        System.out.println(list);
    }
}

结果

[8, 7, 6, 1, 3, 4, 3]
public boolean removeFirstOccurrence(Object o)：移除第一个出现的元素
public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        list.removeFirstOccurrence(3);
        System.out.println(list);
    }
}

结果

[1, 4, 3]

public boolean removeLastOccurrence(Object o)：移除最后出现的

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        list.removeLastOccurrence(3);
        System.out.println(list);
    }
}

结果：

[1, 3, 4]

Object[] toArray()：返回Object[] toArray()，无法强转

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        Object[] objects = list.toArray();
        System.out.println(objects[0]);
        System.out.println(objects[1]);
        System.out.println(objects[2]);
        System.out.println(objects[3]);
    }
}

结果

1
3
4
3

public <T> T[] toArray(T[] a) ：转换数据到指定数组

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        Integer[] array = new Integer[list.size()];
        list.toArray(array);
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
    }
}

结果

1
3
4
3

 

 

 

 

 

 

 

黑皮爱学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中集合LinkedList的原理与使用方法
08-25
主要给大家介绍了关于Java中集合LinkedList的原理与使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java Linkedlist原理及实例详解
08-25
主要介绍了Java Linkedlist原理及实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
LinkedList详解
热门推荐
weixin_39387961的博客
12-24 6万+
文章目录介绍LinkedLists实现底层数组结构 介绍 LinkedList同时实现了List接口和Deque对口，也就是收它既可以看作一个顺序容器，又可以看作一个队列（Queue），同时又可以看作一个栈（stack），这样看来，linkedList简直就是无敌的，当你需要使用栈或者队列时，可以考虑用LinkedList,一方面是因为Java官方已经声明不建议使用Stack类，更遗憾的是，Java里根本没有一个叫做Queue的类（只是一个接口的名字）。关于栈或队列，现在首选是ArrayDeque，它有着比
LinkedList的各种方法
Mr.White的博客
12-23 1983
LinkedList常用于栈和队列的模拟，经常在算法题中遇见，所以一次性将LinkedList的方法总结一下。 public E getFirst() 返回此列表中的第一个元素。 public E getLast() 返回此列表中的最后一个元素。 public E removeFirst() 移除并返回此列表中的第一个元素。 public E removeLast() 移除并返回此列表中的最后一个元素。 public void addFirst(E e) 在此列表的开始处插入指定的元素。 public vo
数据结构之链表（LinkedList详解）
crazy_xieyi的博客
09-29 6855
LinkedList实现了List接口；LinkedList的底层使用了双向链表；LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问； LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)；ArrayList实质是顺序表，底层是一个数组。LinkedList实质是一个链表。ArrayList顺序表在物理上和逻辑上都是连续的，但是在扩容的时候，可能会造成空间的浪费。而LinkedList在物理上不一定是连续的，在逻辑上是连续的。
【Java】链表LinkedList
qq_61635026的博客
07-06 7196
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
LinkedList用法详解
韩家老大的博客
06-21 1万+
一、LinkedList介绍
对ArrayList和LinkedList底层实现原理详解
08-26
今天小编就为大家分享一篇对ArrayList和LinkedList底层实现原理详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java中LinkedList原理代码解析
08-28
主要介绍了Java中LinkedList原理代码解析，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
Kotlin中Stack与LinkedList的实现方法示例
08-27
主要给大家介绍了关于Kotlin中Stack与LinkedList实现的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧
Java基础之LinkedList
qq_45344586的博客
04-09 1327
Java基础之LinkedList
【Java集合类】之 LinkedList(链表)
小新的博客
07-23 4204
Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在..
linkedlist和arraylist的区别是什么
thunder-1
04-09 1535
主要区别：ArrayList是Array(动态数组)的数据结构，而LinkedList是Link(链表)的数据结构。随机访问（get和set）时，ArrayList优于LinkedList；新增和删除操作，LinedList比较占优势。 LinkedeList和ArrayList的区别 1、数据结构不同 ArrayList是Array(动态数组)的数据结构，LinkedList是Link(链表)的...
java集合（二）——List
shanheye的博客
03-01 99
List接口及其实现类
Java集合之LinkedList
GeraldTetris的博客
05-17 220
LinkedList继承自AbstractSequentialList，是List和Deque接口的双向链表实现，其底层维护一个双向链表存储元素。它实现了所有可选的列表操作，并且只能存储同一种引用类型的数据，但是包括null。动态扩容非线程安全允许插入的元素重复插入的元素是有序的（即按照添加的先后顺序排序）随机访问速度慢，可以使用下标访问（底层使用双向链表实现，访问元素需要遍历链表）插入和删除速度快（只需要改变相关节点引用的指向即可）
LinkedList 的常见用法及对应源码介绍
liuyuanq123的博客
03-30 427
1.介绍 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;LinkedList是对一个双向链表的封装，在链表的基础上实现了增、删、改、查等功能，容量也是动态增加，LinkedList继承于AbstractSequentialList类，实现了List接口（可进行队列操作）、Deque 接口（可作为双端队列）、Cloneable（可以克隆）、Serializable序列化接...
java的linkedlist_Java集合 LinkedList的原理及使用
weixin_34315264的博客
02-12 253
LinkedList和ArrayList一样是集合List的实现类，虽然较之ArrayList，其使用场景并不多，但同样有用到的时候，那么接下来，我们来认识一下它。一. 定义一个LinkedListpublic static void main(String[] args) {List stringList = new LinkedList<>();List tempList = ne...
一篇文章带你彻底理解Java LinkedList数据结构详解
最新发布
Stevedash的博客
08-05 547
*链表是一种常用的数据结构，适合在动态插入和删除元素的场景中使用。**它的主要特点是节点之间通过引用连接起来，每个节点包含数据和指向下一个节点的引用。
ArrayList和LinkedList的区别
心若向阳 无谓悲伤
12-28 2404
ArrayList和LinkedList的异同点以及使用区别
LinkedList原理
06-08
LinkedList是Java中常用的集合类，它...总之，LinkedList的优点是在插入和删除元素时性能较好，支持作为栈或队列使用，缺点是在随机访问元素时性能较差。因此，如果需要频繁地进行随机访问操作，建议使用ArrayList。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值