【集合（容器）】LinkedList基础

最新推荐文章于 2025-07-09 01:04:37 发布
原创 最新推荐文章于 2025-07-09 01:04:37 发布 · 200 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

博客介绍了一种查询效率低、增删效率高且线程不安全、一般不常用的数据结构。围绕建立LinkedList包展开，包含创建链表、自定义链表使用get方法、增加remove操作、插入节点以及增加小封装和泛型等内容。

LinkedList

查询效率低，增删效率高，线程不安全，一般不常用

建立包LinkedList

Node（创建链表）

public class Node {

    Node previous; //上一个节点
    Node next;     //下一个节点
    Object element;//元素数据

    public Node(Node previous, Node next, Object element) {
        this.previous = previous;
        this.next = next;
        this.element = element;
    }

    public Node(Object element){
        super();
        this.element=element;
    }

}

TestLinkedList（自定义一个链表，使用get）

public class TestLinkedList {

    private Node first;
    private Node last;

    private int size;

    //[]
    //["a","b","c","d","e","f"]        2
    public Object get(int index){

        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }

        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp.element;
    }


    public void add(Object obj){
        Node node=new Node(obj);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList list=new TestLinkedList();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);
        System.out.println(list.get(1)); 
    }
}

TestLinkedList02（增加remove）

public class TestLinkedList02 {

    private Node first;
    private Node last;
    private int size;

    public void remove(int index){
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;
            Node down=temp.next;

            if(up!=null){
                up.next=down;
            }

            if(down!=null) {
                down.previous = up;
            }

            //被删除的元素是第一个元素时
            if(index==0){
                first=down;
            }

            //被删除的元素最后一个元素时
            if(index==size-1){
                last=up;
            }
            size--;
        }
    }

    public Node getNode(int index){
        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c","d","e","f"]        2
    public Object get(int index){

        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }

        Node temp=getNode(index);

        return temp!=null?temp.element:null;
    }


    public void add(Object obj){
        Node node=new Node(obj);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList02 list=new TestLinkedList02();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);
        System.out.println(list.get(1));
        list.remove(3);
        System.out.println(list);
        list.remove(0);
        System.out.println(list);
        System.out.println(list.get(1));
        list.remove(5);
        System.out.println(list);
        System.out.println(list.get(1));

    }
}

TestLinkedList03（插入节点）

public class TestLinkedList03 {

    private Node first;
    private Node last;
    private int size;

    public void add(int index,Object obj){

        Node newNode=new Node(obj);
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;

            up.next=newNode;
            newNode.previous=up;

            newNode.next=temp;
            temp.previous=newNode;
        }
    }

    public void remove(int index){
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;
            Node down=temp.next;

            if(up!=null){
                up.next=down;
            }

            if(down!=null) {
                down.previous = up;
            }

            //被删除的元素是第一个元素时
            if(index==0){
                first=down;
            }

            //被删除的元素最后一个元素时
            if(index==size-1){
                last=up;
            }
            size--;
        }
    }

    public Node getNode(int index){
        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c","d","e","f"]        2
    public Object get(int index){

        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }

        Node temp=getNode(index);

        return temp!=null?temp.element:null;
    }


    public void add(Object obj){
        Node node=new Node(obj);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList03 list=new TestLinkedList03();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);
        list.add(3,"若颂");
        System.out.println(list);
    }
}

TestLinkedList04（增加小的封装、增加泛型）

public class TestLinkedList04<E> {

    private Node first;
    private Node last;
    private int size;

    public void add(int index,E element){

        checkRange(index);

        Node newNode=new Node(element);
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;

            up.next=newNode;
            newNode.previous=up;

            newNode.next=temp;
            temp.previous=newNode;
        }
    }

    public void remove(int index){

        checkRange(index);

        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;
            Node down=temp.next;

            if(up!=null){
                up.next=down;
            }

            if(down!=null) {
                down.previous = up;
            }

            //被删除的元素是第一个元素时
            if(index==0){
                first=down;
            }

            //被删除的元素最后一个元素时
            if(index==size-1){
                last=up;
            }
            size--;
        }
    }

    private Node getNode(int index){

        checkRange(index);

        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c","d","e","f"]        2
    public E get(int index){

        checkRange(index);

        Node temp=getNode(index);

        return temp!=null?(E)temp.element:null;
    }

    private void checkRange(int index){
        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }
    }

    public void add(E element){
        Node node=new Node(element);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList04<String> list=new TestLinkedList04<>();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);

        System.out.println(list.get(1));
    }
}
27、Java高级特性——集合、ArrayList集合、LinkedList集合、List接口、ArrayList和LinkedList的区别
优快云_Loveletter的博客
11-10 715
集合基础 1、数组的缺陷 2、集合的概述 3、集合类的特点 二、ArrayList集合类 1、ArrayList集合类的用法 2、ArrayList类中常用方法 三、ArrayList集合代码演示 1、封装属性类 2、创建集合操作类 3、添加数据：add() 4、获取集合元素个数：size() 5、获取集合中指定下标的元素：get() 6、 判断集合中是否包含某个元素：contains() 7、删除集合中的元素：remove(元素)/remove(元素下标) 8、判断集合是
java 集合之LinkedList 构造器 方法 遍历方法 listIterator
SKPrimin的博客
08-17 924
java 集合之LinkedList List 和 Deque 接口的双向链表实现。 实现所有可选的列表操作，并允许所有元素（包括空值）。 除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。 实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。 所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头
搭建自己的SSR
5coder的大前端进阶之路-个人博客网站：blog.5coder.cn
11-24 6229
大多数自定义指令直接操作 DOM，因此会在服务器端渲染 (SSR) 过程中导致错误。推荐使用组件作为抽象机制，并运行在「虚拟 DOM 层级(Virtual-DOM level)」（例如，使用渲染函数(render function)）。如果你有一个自定义指令，但是不是很容易替换为组件，则可以在创建服务器 renderer 时，使用directives选项所提供"服务器端版本(server-side version)"。
ff
weixin_30819163的博客
09-29 3120
ssr://MTcyLjEwNC4xMDIuMjk6NTQ0NDA6b3JpZ2luOmFlcy0yNTYtY2ZiOnBsYWluOlkwUkRVekZsTWpGNE1VbGsvP29iZnNwYXJhbT0mcHJvdG9wYXJhbT0mcmVtYXJrcz01Ny03NWFLWjVZV2FNVFF4TGpreTVwZWw1cHlzJmdyb3VwPTVwZWw1cHlz ssr:...
SSG vs SSR vs ISG 页面渲染策略对比
Bruce__taotao的博客
05-24 1399
本文对比了SSG、SSR和ISG三种页面渲染策略的核心差异。SSG（静态生成）在构建时预渲染所有页面，性能最优但动态内容支持弱；SSR（服务端渲染）每次请求实时生成页面，支持动态数据但性能开销较大；ISG（增量静态生成）结合两者优势，通过混合生成策略实现性能与动态性的平衡。关键维度包括：SSG适合CDN缓存和固定内容场景，SSR适用于实时个性化需求，ISG则通过按需更新机制兼顾速度与内容新鲜度。实际应用中，Next.js、Nuxt等框架针对不同场景提供了灵活的实现方案。选择策略需权衡性能、动态性、SEO和部
Next.js 数据获取完全指南：SSR、SSG、CSR 和 ISR 详解
最新发布
vvilkin的学习备忘
07-09 1258
在现代 Web 开发中，数据获取是构建动态应用的核心部分。Next.js 作为 React 的元框架，提供了多种数据获取方式，包括 服务端渲染（SSR）、静态生成（SSG）、客户端数据获取（CSR） 以及 增量静态再生（ISR）。不同的方法适用于不同的场景，选择合适的方式可以优化性能、SEO 和用户体验。 本文将详细介绍 Next.js 的各种数据获取方法，分析它们的优缺点，并提供代码示例，帮助你选择最适合你的应用场景的方案。
React 路由快速启动指南（二）
龙哥盟
07-22 925
在本章中，我们看了一下如何使用方法在服务器端（使用 Node.js 和 Express.js）呈现 React 应用程序。React-Router 中的组件可用于包装应用程序的根组件，从而使您能够在服务器端添加与请求的 URL 路径匹配的<Route>组件。组件接受context和location属性。在渲染的组件中，属性（仅在服务器端可用）包含context属性中由提供的数据。它还可以用于在使用<Redirect>组件时添加属性以重定向用户。matchPath函数用于确定请求的 URL 是否与提供的对象。
Java容器集合（equals 和 hashCode+基础数据结构+ArrayList+Vector和LinkedList）
06-21
Java容器集合（equals和hashCode+基础数据结构+ArrayList+Vector和LinkedList） Java容器集合是Java中的一种基础数据结构，用于存储和管理数据。其中，equals和hashCode方法是Java容器集合中两个非常重要的方法，...
Java中集合LinkedList的原理与使用方法
08-25
LinkedList是Java集合框架中List接口的一个实现，它是一种基于链表结构的数据容器。本文将深入探讨LinkedList的原理和使用方法。 首先，LinkedList是一个双向链表，意味着每个元素（节点）都有指向前后元素的引用。...
第8天（集合【LinkedList、HashSet、Collection集合体系】）v201703103
08-08
【Java集合框架】\n\n在Java编程语言中，集合框架是用于存储和操作对象的容器，它提供了灵活且高效的方式来处理数据。本篇将深入探讨List接口和Set集合，特别是LinkedList、HashSet以及Collection集合体系。\n\n1. *...
SSR算法源代码
04-16
关于图像增强方面的最基础的经典算法之一，ssr单尺度Retinex算法的matlab版代码，亲测有效
honeyLambda：honeyλ-一个简单的无服务器应用程序，旨在在AWS Lambda和Amazon API Gateway之上自动创建和监视假HTTP终端节点（即URL honeytoken）。
02-01
无服务器陷阱 honeyλ-一个简单的无服务器应用程序，旨在在AWS Lambda和Amazon API Gateway之上创建和监视URL 松弛通知 电子邮件和短信提醒 从本地文件或Amazon S3加载配置 自定义每个令牌的HTTP响应 威胁情报报告（源IP查找） 使用Cymon API v2 基于无服务器框架 付你用什么 提供者不可知 描述 honeyλ允许您自动创建和监视伪造的HTTP端点。 然后，您可以将这些URL蜜令牌放在收件箱，文档，浏览器历史记录中，或将其作为{隐藏}链接嵌入到网页中（注意：可用于在系统中散布面包屑，以吸引攻击者进入陷阱） 。 根据实施honeytoken的方式和位置，您可能会检测到人类攻击者，恶意内部人员，内容抓取工具或不良机器人。 此应用程序基于，可以部署在不同的云提供商中，例如Amazon Web Services（AWS），Microsoft Azure，IBM OpenWhisk或Google Cloud（仅在AWS上经过测试；主要功能可能需要稍作更改才能支持其他提供商） 。 如果您的云提供商是AWS，它将使用Amazon API Gat
橘子，steam等下载加速
03-04
下载加速 橘子 steam等等 可以更换到其他节点进行网络加速
永久免费虚拟主机推荐
qq_37773858的博客
03-03 518
与市面上那些号称免费虚拟主机的服务不同，它们往往一点开就显示“售罄”，转而诱导用户购买其他产品和服务。而天道论坛云服务，秉持着真诚和负责的态度，真免费，不套路。在当今数字化的时代浪潮中，拥有一个属于自己的网站，无论是展示个人风采、分享生活感悟，还是推广业务，都变得越来越重要。如果你一直怀揣着建站的梦想，却被成本所困扰，那么现在正是绝佳的机会。快来天道论坛云服务开始你的建站之旅吧，开启属于自己的网络天地，尽情展现无限可能！只要用户的使用需求合法合规，都可以免费使用天道论坛云服务的虚拟主机。
浅谈 ssr，ssg，csr，rsc
2403_82864777的博客
11-19 1442
本文主要是简单聊聊 ssr，csr，ssg，rsc 的一些区别和联系，讲解一下这些问题的出现分别解决了哪些问题，以及我们应该如何选择这些开发模式
SSR与CSR
FantasyBreaker的博客
02-05 638
CSR（客户端渲染） 其过程为（以react为例）： 用户在浏览器地址栏输入 url，浏览器首先会去服务器请求对应的 html 资源，服务器成功返回 html 页面，其中包含 js、css、图片等资源路径，浏览器根据资源路径再去请求对应的 js、css 图片等资源，资源加载成功后，浏览器开始执行 js，然后会调用 ReactDOM 提供的 render 方法，将虚拟 Dom 渲染到页面上，完成页面的渲染过程。 SSR（服务端渲染） 其过程为（以react为例）： 在浏览器地址栏输入 url，请求发送到服务端
一文搞懂：什么是SSR、SSG、CSR？前端渲染技术全解析
wujiayu31415的博客
05-15 6846
在这种模式下，服务器主要负责提供静态的HTML文件（可能包含一些基本的HTML结构和JavaScript脚本），而真正的页面渲染工作则完全由客户端的浏览器来完成。在这种模式下，服务器接收到客户端的请求后，会先根据请求数据和模板文件生成完整的HTML页面，然后将这个页面直接发送给客户端。：由于服务器已经生成了完整的HTML页面，因此客户端可以直接显示这个页面，无需等待JavaScript加载和执行。：由于页面是静态的，因此无需等待服务器渲染，直接由浏览器加载显示，具有出色的性能。
8.4.1 搭建自己的SSR
w1fl1w的博客
11-21 7413
本文为拉勾网大前端高薪训练营第一期笔记 心得体会 SSR是未来前端页面必不可少的一个组成成分，掌握了Vue SSR基本上其他框架都非常类似。 3-4-1 搭建自己的SSR Vue SSR 介绍 是什么 官方文档:https://ssr.vuejs.org/ Vue SSR(Vue.js Server-Side Rendering) 是 Vue.js 官方提供的一个服务端渲染(同构应用)解决方案 使用它可以构建同构应用 还是基于原有的 Vue.js 技术栈 官方文档的解释:Vue.js 是构建客户端应
机器学习之pipline
小诚信驿站
03-09 1175
文章目录1.1 从管道符到pipeline1.2 sklearn中pipeline为例 1.1 从管道符到pipeline 先从在linux的管道符讲起， find ./ | grep wqbin | sort Linux体系下的各种命令工具的处理,可以使用管道符作为传递，这是一种良好的接口规范，工具的功能有公共的接口规范，就像流水线一样，一步接着一步。 而我们只需改动每个参数就可以获取我们想要的结果。该过程就被称之管道机制。 一个基础的 机器学习的Pipeline 主要包含了下述 5 个步骤： 源数
Java集合类LinkedList
03-11
### Java 中 LinkedList 集合类 #### 什么是 LinkedList 集合 `LinkedList` 是一种双向链表的数据结构，在 Java 编程中属于 `List` 接口的一种实现形式[^1]。这种数据结构允许元素之间通过指针相互链接，从而形成一个线性的序列。 #### LinkedList 的特性 - **内部实现**：基于双向链表来存储元素，这意味着每个节点不仅保存着自身的数据项还维护着前后相邻结点之间的连接关系。 - **访问速度**：由于不是连续内存分配的方式，因此随机存取效率较低；但在频繁插入删除操作时表现优异因为不需要移动大量现有元素的位置即可完成相应动作[^2]。 #### 如何创建并初始化 LinkedList 对象 为了定义一个具体的实例化对象，可以通过如下方式引入必要的包并且声明带有特定参数化的变量名： ```java import java.util.LinkedList; // 创建 LinkedList 对象，并指定泛型为 String 类型 LinkedList<String> list = new LinkedList<>(); ``` 上述代码片段展示了如何导入所需的库文件以及怎样构建一个新的空列表用于后续的操作处理过程之中[^4]。 #### 常见方法概述 以下是几个常用的 API 方法供开发者调用来管理该类型的容器内的成员： - 添加元素至队列末端或者头部位置； - 移除首尾两端处的目标实体； - 获取第一个或最后一个条目而不将其移出队列之外； - 判断某个给定的对象是否存在于此集合之内等等[^5]。 #### 示例代码展示基本功能的应用场景 下面给出一段简单的例子演示了部分核心函数的具体应用情形： ```java public class Main { public static void main(String[] args) { // 初始化 LinkedList 并加入一些初始值 LinkedList<Integer> numbers = new LinkedList<>(); // 向末尾追加数值 numbers.add(1); numbers.addLast(3); // 插入到开头位置 numbers.addFirst(0); System.out.println("当前内容：" + numbers); // 删除最前面的一个数 Integer removedElement = numbers.remove(); System.out.println("被删掉的是：" + removedElement); // 查看但不取出最后面的数字 int lastNumber = numbers.peekLast(); System.out.println("最后一项是：" + lastNumber); } } ``` 这段程序先建立了一个整数类型的动态数组，接着执行了一系列增减查的动作最终打印出了预期的结果集。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值