LinkedList类

最新推荐文章于 2024-06-10 17:29:18 发布
最新推荐文章于 2024-06-10 17:29:18 发布
阅读量72 收藏
点赞数
原文链接：https://blog.csdn.net/ws_PersonalSpace/article/details/84326999
版权

LinkedList类

LinkedList特点：
数据重复性：数据可重复
数据有序性：保证插入数据的有序性
null值问题：可以有多个null值
底层数据结构：

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

LinkedList底层提供的是双向链表
继承关系：

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


LinkedList直接继承了AbstractSequentialList类，该类继承了AbstractList类。
LinkedList实现了List接口，Deque接口，可以克隆，可以进行序列化和反序列化操作。
基本属性：

transient int size = 0;//表示当前集合存储数据个数
transient Node<E> first;//第一个节点
transient Node<E> last;//最后一个节点
private static final long serialVersionUID = 876323262645176354L;//用于Java的序列化机制
protected transient int modCount = 0;//表示的是版本控制，添加，删除，修改之类的操作都会进行++操作

构造函数：

//无参构造函数，构造一个空列表
public LinkedList() {
}
//使用集合的构造方法，先构造一个空列表，在将集合中所有元素添加到列表中
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

主要实现方法：

//头插法插入指定结点
private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}
//尾插法插入指定结点
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) {
    final Node<E> pred = succ.prev;
    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) {
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; 
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}
//尾删法删除结点
private E unlinkLast(Node<E> l) {
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null;
    last = prev;
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}
//删除指定结点
E unlink(Node<E> x) {
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
    x.item = null;
    size--;
    modCount++;
    return element;
}

//返回此列表的第一个元素
public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}
//返回此列表的最后一个元素
public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

//头删法删除结点
public E remove() {
    return removeFirst();
}
//移除此列表中指定位置处的元素
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}
//移除并返回此列表的第一个元素
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}
//移除并返回此列表的最后一个元素
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}
//删除指定元素
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 void clear() {
    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 void addFirst(E e) {
    linkFirst(e);
}
//将给定元素追加到此列表的结尾
public void addLast(E e) {
    linkLast(e);
}

//判断此列表是否包含指定元素
public boolean contains(Object o) {
    return indexOf(o)!= -1;
}

//返回此列表的元素数                
public int size() {
    return size;
}

//尾插法插入指定结点                
public boolean add(E e) {
    linkLast(e);
    return true;
}

//返回此列表中指定位置处的元素
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
//将此列表中指定位置的元素替换为指定的元素
public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}
//将指定集合中所有元素添加到指定集合的后面
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}
//在指定位置插入指定集合
public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }
    for (Object o : a) {
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }
    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }
    size += numNew;
    modCount++;
    return true;
}
//将指定元素插入到指定下标位置之前
public void add(int index, E element) {
    checkPositionIndex(index);
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}
//判断下标是否合法
private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}
private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}    
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//返回指定位置的结点
Node<E> node(int 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 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 int lastIndexOf(Object o) {
    int index = size;
    if (o == null) {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (x.item == null)
                return index;
        }
    } else {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (o.equals(x.item))
                return index;
        }
    }
    return -1;
}
public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}
public E element() {
    return getFirst();
}
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}
public boolean offer(E e) {
    return add(e);
}
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}
public boolean offerLast(E e) {
    addLast(e);
    return true;
}
public E peekFirst() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
 }
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}
public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}
public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}
public void push(E e) {
    addFirst(e);
}
public E pop() {
    return removeFirst();
}
//返回ListIterator迭代器
public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
    return new ListItr(index);
}
//返回Iterator迭代器              
public Iterator<E> descendingIterator() {
    return new DescendingIterator();
}
//返回此 LinkedList 的浅表复制              
public Object clone() {
    LinkedList<E> clone = superClone();
    clone.first = clone.last = null;
    clone.size = 0;
    clone.modCount = 0;
    for (Node<E> x = first; x != null; x = x.next)
        clone.add(x.item);
    return clone;
}                
//以正确顺序返回包含此列表中所有元素的数组               
public Object[] toArray() {
    Object[] result = new Object[size];
    int i = 0;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;
    return result;
}
//以正确顺序返回包含此列表中所有元素的数组,返回数组的运行时类型即为指定数组的类型
public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.newInstance( a.getClass().getComponentType(), size);
    int i = 0;
    Object[] result = a;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;
    if (a.length > size)
        a[size] = null;
    return a;
}
//通过JAVA对象流进行序列化和反序列化
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
    s.defaultWriteObject();
    s.writeInt(size);
    for (Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();
    int size = s.readInt();
    for (int i = 0; i < size; i++)
        linkLast((E)s.readObject());
}
————————————————
版权声明：本文为CSDN博主「ws_PersonalSpace」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ws_PersonalSpace/article/details/84326999

正在努力的菜鸟猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
集合类之LinkedList
weixin_43356265的博客
03-01 225
继承关系 底层数据结构 构造函数 基本属性 默认值 增长方式 CRUD（增删改查）方法研究
【Java LinkedList详解】
Java程序员廖志伟
05-31 2555
Java中的LinkedList是一个重要的集合类，它是基于双向链表实现的，具有动态扩容能力、查询性能低、插入和删除性能高、访问和删除任意位置元素性能高以及线程安全等特点。本文将详细讲解LinkedList的实现原理、特性和使用场景。
LinkedList特点
weixin_45208757的博客
11-01 2066
LinkedList特点和底层实现 LinkedList的特点和存储结构 LinkedList底层用双向链表实现存储 特点：增删效率高，查询效率低，线程不安全 双向链表也叫双链表，是链表的一种，它的每个数据节点都有两个指针，分别指向前一个节点和后一个节点。 LinkedList的存储结构图 节点类的内容 class Node{ Node previous;//指向前一个节点 Node next;//指向后一个节点 Object element;//本节点所存放数据 } ...
双端队列(deque)总结(会更新)
xingzi201的博客
08-23 983
文章目录一.deque一.deque简介二.deque特性(1).deque与vector的不同(2)deque和vector相似的特性：三.基本函数实现1.构造函数2.添加函数3.删除函数4.遍历函数5.判断函数6.大小函数7.其他函数8.总结 一.deque 适用于既要频繁随机访问，又要关心两端数据的插入与删除的场景。 一.deque简介 deque是双向开口的连续性存储空间。虽说是连续性存储空间，但这种连续性只是表面上的，实际上它的内存是动态分配的，它在堆上分配了一块一块的动态储存区，每一..
双端队列Deque
keavykk的博客
03-29 312
介绍Deque Deque是double ended queue的缩写，继承自Queue接口，读作“deck”。 此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。 三种用途 Deque有三种用途： 普通队列(一端进另一端出): Queue queue = new LinkedList()或Deque deque = new LinkedList() 双端队列(两端都可进出) Deque deque = new LinkedList() 堆栈 Deque deque = new Lin
java LinkedList类详解及实例代码
08-31
Java中的LinkedList类是Java集合框架的一部分，属于List接口的实现，它提供了线性数据结构的能力，同时保持了链表的特点。LinkedList不同于ArrayList，后者在内存中是连续存储的，而LinkedList则是通过节点对象链接...
javalinkedlist:编写一个程序，演示您了解如何使用Java LinkedList类
04-14
Java LinkedList类是Java集合框架的一部分，它位于`java.util`包中，主要用于创建和操作链表数据结构。链表是一种动态数据结构，其中元素不是在内存中连续存储的，而是通过节点之间的引用链接起来。LinkedList类实现...
LinkedLIst.cpp
03-07
LinkedLIst.cpp
模拟实现 LinkedList 测试类
06-10
模拟实现 LinkedList 测试类
记录工作中遇到的k8s的坑
qq_39904356的博客
07-24 375
记录工作中遇到的k8s的坑和简单用法1、k8s指定node节点启动pod 1、k8s指定node节点启动pod 在工作中遇到集群节点通信问题，需要指定节点启动pod的情况，这个时候就要去修改yaml脚本。 首先我需要知道指定节点上的标签，k8s不能直接指定hostname进行节点指定，需要从节点的label中找到特征的key-value，用 nodeSelector 这个字段，放在containers的同级。不要用TAB键。 执行下面这条命令 kubectl get node --show-la
深入理解Java中的LinkedList：特性、用法及其优势
最新发布
2301_78864183的博客
06-10 1114
LinkedList是一个基于双向链表（Doubly Linked List）实现的集合类。它允许存储重复的元素，并且可以动态地调整大小。每个节点包含一个数据元素以及指向前后节点的引用。E data;// 节点数据// 指向下一节点的引用// 指向前一节点的引用LinkedList是Java集合框架中的一个重要类，基于双向链表实现，提供了灵活且高效的插入和删除操作。尽管其随机访问效率较低，但在需要频繁插入和删除、双向遍历以及实现栈和队列等场景下，LinkedList具有显著的优势。动态大小。
linkedlist类的特点是_最详细集合源码解析之LinkedList集合源码解析
weixin_42515364的博客
11-28 632
LinkedList集合特点就是增删快，查询慢，这种特性的主要原因就是其内部是通过链表来做为存储数据的数据结构，先看下内部整体结构。LinkedList整体结构这里主可以看到，和ArrayList的继承结构大致差不多，这里LinkedList实现了Queue,可以实现一些队列的操作，先带大家看下LinkedList的内部的Node内部类的结构，这个是完成数据存储的核心部分，所有的操作都是围绕No...
链表——LinkedList类的概述和实现
weixin_62458944的博客
08-05 1245
上面我们讲了各种链表，每个链表都包括一个LinkedList对象和许多Node对象，LinkedList对象通常包含头和尾节点的引用，分别指向链表的第一个节点和最后一个节点。而每个节点对象通常包含数据部分data，以及对上一个节点的引用prev和下一个节点的引用next，只有下一个节点的引用称为单向链表，两个都有的称为双向链表。next值为null则说明是链表的结尾，如果想找到某个节点，我们必须从第一个节点开始遍历，不断通过next找到下一个节点，直到找到所需要的。栈和队列都是ADT。
c#中queue_C＃中的Queue.Dequeue（）方法示例
07-09 1万+
c#中queue C＃Queue.Dequeue()方法 (C# Queue.Dequeue() method) Queue.Dequeue() method is used to remove an object/element from the beginning of the Queue and returns that object/element. Queue.Dequeue()方法用...
java基础之LinkedList类
weixin_50691399的博客
10-27 389
本文主要是java集合中LinkedList类的相关知识
deque(双端队列)介绍
热门推荐
行码棋
02-25 1万+
双端队列介绍
详解双端队列&单调队列
Forward♞的博客
08-10 907
typedef struct DequeNode //队列的节点//指向下一个//指向前一个int data;//数据域}DQNode;//队头指针//队尾指针}Deque;
Linkedlist类
03-29
LinkedList类是Java中的一个类，用于实现链表数据结构。它是List接口的一个实现，可以用于存储一系列的元素。LinkedList类的特点是它是一个双向链表，每个节点都有指向前一个节点和后一个节点的引用。这使得在链表中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值