前言：在Java编程语言中，Java集合框架提供了一组丰富的数据结构，以满足各种应用需求。其中，LinkedList作为一种常用的数据结构，具有独特的优势和广泛的应用场景。

先让我们看一下本文大致的讲解内容：

1.LinkedList的初识

        在开始学习LinkedList之前，让我们先了解一下什么是LinkedList：

        LinkedList（双向链表）是一种基于链表实现的线性数据结构，与ArrayList（顺序表）等基于数组实现的结构不同，它通过节点的引用来管理元素的存储和连接。

        其中每个节点包含三个主要部分：数据部分、指向下一个节点的指针（next）和指向前一个节点的指针（prev）。

下图很好的展示了什么是通过节点的引用来管理元素的存储和连接以及双向链表的构成：

       —— 通过上边的解释，我相信读者你已经对LinkedList（双向链表）有了自己的初步认知，那么接下来我们从LinkedList在整个集合框架中与其他类与接口的关系来继续介绍LinkedList（双向链表）

LinkedList与其他类与接口的关系：

从上图中我们可以了解到：

1.  LinkedList实现了List接口；
2.  LinkedList的底层使用了双向链表；
3.  LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问；

        通过上边的简单介绍，相信读者已经大致的了解了Java中的LinkedList，那么接下来让我们开始正式的来学习Java中的LinkedList（双向链表）吧。

 

2.LinkedList的创建

        在Java中创建LinkedList有两种方式：

方法	解释
LinkedList()	无参构造
public LinkedList(Collection<? extends E> c)	使用其他集合容器中元素构造List

（1）让我们使用一个案例来看一下使用空参创建LinkedList的方式：

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // 创建一个空的LinkedList
        LinkedList<String> linkedList = new LinkedList<>();

        // 添加一些元素到LinkedList中
        linkedList.add("Element 1");
        linkedList.add("Element 2");
        linkedList.add("Element 3");

        // 输出LinkedList
        System.out.println("LinkedList: " + linkedList);
    }
}

 

（2）让我们使用一个案例来看一下使用使用其他集合容器中元素构造创建LinkedList的方式：

import java.util.LinkedList;
import java.util.ArrayList;

public class LinkedListFromCollection {
    public static void main(String[] args) {
        // 创建一个ArrayList并添加一些元素
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Element 1");
        arrayList.add("Element 2");
        arrayList.add("Element 3");

        // 使用ArrayList创建一个LinkedList
        LinkedList<String> linkedList = new LinkedList<>(arrayList);

        // 输出LinkedList
        System.out.println("LinkedList: " + linkedList);
    }
}

        ——这样我们就大致的了解了如何创建LinkedList了。

 

3.LinkedList中的常见API

        了解完如何创建一个LinkedList之后，让我们开始学习如何去操作所创建好的LinkedList。以下我们将会从增删查改四个方面来解释有关LinkedList的常用API。

（1）添加元素

• add(E e): 在链表末尾添加元素。

• add(int index, E element): 在指定位置插入元素。

• addFirst(E e): 在链表头部添加元素。

• addLast(E e): 在链表尾部添加元素。

接下来让我们使用案例来帮助你进一步理解：

import java.util.LinkedList;

public class LinkedListAddExample {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        
        // 在末尾添加元素
        linkedList.add("Element 1");
        linkedList.add("Element 2");
        
        // 在指定位置插入元素
        linkedList.add(1, "Inserted Element");
        
        // 在头部添加元素
        linkedList.addFirst("First Element");
        
        // 在尾部添加元素
        linkedList.addLast("Last Element");
        
        //打印结果
        System.out.println("final: " + linkedList);
    }
}

 

（2）删除元素

• remove(): 移除并返回链表的第一个元素。

• remove(int index): 移除并返回指定位置的元素。

• removeFirst(): 移除并返回链表的第一个元素。

• removeLast(): 移除并返回链表的最后一个元素。

让我们使用案例来帮助你进一步理解：

import java.util.LinkedList;

public class LinkedListRemoveExample {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        
        linkedList.add("Element 1");
        linkedList.add("Element 2");
        linkedList.add("Element 3");
        
        System.out.println("Initial LinkedList: " + linkedList);
        
        // 移除并返回第一个元素
        String removedElement = linkedList.remove();
        System.out.println("Removed Element: " + removedElement);
        
        // 移除指定位置的元素
        String removedIndexElement = linkedList.remove(1);
        System.out.println("Removed Element at Index 1: " + removedIndexElement);
        
        // 移除第一个元素
        linkedList.addFirst("New First Element");
        String removedFirstElement = linkedList.removeFirst();
        System.out.println("Removed First Element: " + removedFirstElement);
        
        // 移除最后一个元素
        String removedLastElement = linkedList.removeLast();
        System.out.println("Removed Last Element: " + removedLastElement);
        
        //打印结果
        System.out.println("final: " + linkedList);
    }
}

 

（3）修改元素

• set(int index , E element): 修改指定索引位置的元素。

让我们使用案例来帮助你进一步理解：

import java.util.LinkedList;

public class LinkedListSetExample {
    public static void main(String[] args) {
        // 创建一个LinkedList并添加一些元素
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Element 1");
        linkedList.add("Element 2");
        linkedList.add("Element 3");
        linkedList.add("Element 4");

        // 输出初始的LinkedList
        System.out.println("Initial LinkedList: " + linkedList);

        // 使用set方法替换索引为2的元素
        String oldElement = linkedList.set(2, "New Element");

        // 输出被替换的旧元素
        System.out.println("Replaced Element: " + oldElement);

        // 输出修改后的LinkedList
        System.out.println("final: " + linkedList);
    }
}

 

（4）获取元素

• get(int index): 获取指定位置的元素。

• getFirst(): 获取第一个元素。

• getLast(): 获取最后一个元素。

• indexof(): 获取指定对象的索引（从左到右第一个）

• lastindexof(): 获取指定对象的索引（从右到左第一个）

• contains(): 是否包含指定元素

让我们使用案例来帮助你进一步理解：

import java.util.LinkedList;

public class LinkedListGetExample {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();

        linkedList.add("Element 1");
        linkedList.add("Element 2");
        linkedList.add("Element 3");

        // 获取指定位置的元素
        String elementAtIndex = linkedList.get(1);
        System.out.println("Element at Index 1: " + elementAtIndex);

        // 获取第一个元素
        String firstElement = linkedList.getFirst();
        System.out.println("First Element: " + firstElement);

        // 获取最后一个元素
        String lastElement = linkedList.getLast();
        System.out.println("Last Element: " + lastElement);

        // 获取指定对象的索引（从左到右第一个）
        int index = linkedList.indexOf("Element 1");
        System.out.println(index);

        // 获取指定对象的索引（从右到左第一个）
        int lastindex = linkedList.lastIndexOf("Element 3");
        System.out.println(lastindex);

        // 是否包含指定元素
        boolean contains = linkedList.contains("Element 2");
        System.out.println(contains);
    }
}

通过上边的案例加上解释，相信读者已经了解了Java中LinkedList中的常用API该如何使用了。

 

4.LinkedList的遍历

        在Java中遍历LinkedList的方式有五种：分别是使用 for 循环、使用增强型 for 循环、使用 Iterator、使用 ListIterator、以及直接打印。

        ——接下来让我们一个一个来进行讲解：

（1）使用 for 循环

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        // 使用 for 循环遍历 LinkedList
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

 

（2）使用增强型 for 循环

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        // 使用增强型 for 循环遍历 LinkedList
        for (Integer element : list) {
            System.out.println(element);
        }
    }
}

 

（3）使用 Iterator

import java.util.LinkedList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        // 使用 Iterator 遍历 LinkedList
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

 

（4）使用 ListIterator

import java.util.LinkedList;
import java.util.ListIterator;

public class Main {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        // 使用 ListIterator 从前向后遍历 LinkedList
        ListIterator<Integer> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }

        // 使用 ListIterator 从后向前遍历 LinkedList
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }
    }
}

 

（5）直接打印

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        // 直接使用 System.out.println 打印 LinkedList
        System.out.println(list);
    }
}

——以上就是Java中遍历LinkedList的五种方式。

 

5.LinkedList与ArrayList的区别

        在学习完了LinkedList之后，有读者就会发问，LinkedList和之前的ArrayList有什么区别呢？以下为LinkedList与ArrayList的区别：

不同点	ArrayList	LinkedList
存储空间上	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持O(1)	不支持：O(N)
头插	需要搬移元素，效率低O(N)	只需修改引用的指向，时间复杂度为O(1)
插入	空间不够时需要扩容	没有容量的概念
应用场景	元素高效存储+频繁访问	任意位置插入和删除频繁

        以上就是LinkedList和之前的ArrayList的区别，读者要在合适的情况下选择合适的数据结构来进行操作。