在本指南中，我们将通过实例看到LinkedList类的实现。

Java LinkedList 类使用一个双链表来存储元素。它提供了一个链接列表的数据结构。它继承了AbstractList类并实现了List和Deque接口。
关于Java LinkedList的重要内容是。

• Java LinkedList 类可以包含重复的元素。
• Java LinkedList 类可以保持插入的顺序。
• 在JavaLinkedList类中，操作是快速的，因为不需要发生移位。
• LinkedList 类实现了Queue 和Deque 接口。因此，它也可以作为一个队列、Deque或堆栈使用。
• Java LinkedList 不是线程安全的。在多线程环境下，你必须明确地同步对LinkedList的并发修改。

1. 我们将学到什么？

1. LinkedList类的概述
2. 添加元素 LinkedList 有例子的API

• add(String element)
• add(int index, String element)
• addFirst(String e)
• addLast(String e)
• addAll(Collection<? extends String> c)

1. 删除元素 LinkedList 有例子的API

• removeFirst()
• removeLast()
• remove(Object o)
• removeIf(Predicate<? super String> filter)
• clear()

1. 检索元素 LinkedList 2. 有例子的API

• getFirst()
• getLast()
• get(int index)

1. 搜索元素 LinkedList 有例子的API

• contains(Object o)
• indexOf(Object o)
• lastIndexOf(Object o)

1. 使用Java 8的forEach()方法遍历LinkedList。

• forEach(Consumer<? super String> action)
• Iterator java.util.AbstractSequentialList.iterator()

1. ArrayList和LinkedList之间的区别

2. 添加元素 LinkedList 有例子的API

让我们讨论用不同的方法向LinkedList添加元素。

LinkedList<String> linkedList = new LinkedList<>();

add(String element)

使用*add()*方法将新元素添加到LinkedList的末尾。

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");

add(int index, String element)

使用index方法在LinkedList的指定位置添加一个元素--add(index, element)。

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.add(3, "L");
System.out.println("After add(3, \"D\") : " + linkedList);

addFirst(String e)

使用*addFirst()*方法在LinkedList的开始添加一个元素

LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("R");

addLast(String e)

使用*addLast()*方法在链接列表的末尾添加一个元素

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.add(3, "L");
linkedList.addLast("J");
System.out.println("After addLast(\"F\") : " + linkedList);

addAll(Collection<? extends String> c)

将现有集合中的所有元素添加到LinkedList的末端

List<String> secondList= new ArrayList<>();
secondList.add("Jesse");
secondList.add("Walt");
linkedList.addAll(secondList);
System.out.println("After addAll(secondList) : " + linkedList);

。

3. 删除元素 LinkedList API的实例

让我们首先创建带有少量水果的LinkedList，然后使用移除方法从LinkedList中移除水果。

LinkedList<String> fruitList = new LinkedList<>();

fruitList.add("Apple");
fruitList.add("banana");
fruitList.add("mango");
fruitList.add("Pinaple");

System.out.println("Initial LinkedList = " + fruitList);

removeFirst()

删除LinkedList中的第一个元素。如果LinkedList为空，则抛出NoSuchElementException。

String element = fruitList.removeFirst();   
System.out.println("Removed the first element " + element + " => " + fruitList);

removeLast()

删除LinkedList中的最后一个元素。如果LinkedList为空，则抛出NoSuchElementException。

element = fruitList.removeLast();    
System.out.println("Removed the last element " + element + " => " + fruitList);

remove(Object o)

从LinkedList中移除第一次出现的指定元素

boolean isRemoved = fruitList.remove("banana");
if(isRemoved) {
 System.out.println("Removed banana => " + fruitList);
}

removeIf(Predicate<? super String> filter)

移除这个集合中满足给定谓词的所有元素。在迭代过程中或由谓词抛出的错误或运行时异常将被转达给调用者。

fruitList.removeIf(programmingLanguage -> programmingLanguage.startsWith("C"));
System.out.println("Removed elements starting with C => " + fruitList);

clear()

移除此列表中的所有元素。这个调用返回后，列表将是空的。

fruitList.clear();
System.out.println("Cleared the LinkedList => " + fruitList);

4. 检索元素 LinkedList API的例子

一个包含某公司过去6天的股票价格的关联列表

LinkedList<Double> stockPrices = new LinkedList<>();

        stockPrices.add(45.00);
        stockPrices.add(51.00);
        stockPrices.add(62.50);
        stockPrices.add(42.75);
        stockPrices.add(36.80);
        stockPrices.add(68.40);

``getFirst()

返回该列表中的第一个元素。

Double firstElement = stockPrices.getFirst();
  System.out.println("Initial Stock Price : " + firstElement);

getLast()

返回这个列表中的最后一个元素。

Double lastElement = stockPrices.getLast();
 System.out.println("Current Stock Price : " + lastElement);

get(int index)

获取LinkedList中指定位置的元素

Double stockPriceOn3rdDay = stockPrices.get(2);
 System.out.println("Stock Price on 3rd Day : " + stockPriceOn3rdDay);

5. 搜索元素 LinkedList 例子中的API

让我们创建一个雇员列表并应用LinkedList搜索方法。

LinkedList<String> employees = new LinkedList<>();

employees.add("John");
employees.add("David");
employees.add("Lara");
employees.add("Chris");
employees.add("Steve");
employees.add("David");

contains(Object o)

检查LinkedList是否包含一个元素

System.out.println("Does Employees LinkedList contain \"Lara\"? : " + employees.contains("Lara"));

indexOf(Object o)

查找LinkedList中第一次出现的元素的索引

System.out.println("indexOf \"Steve\" : " + employees.indexOf("Steve"));
System.out.println("indexOf \"Mark\" : " + employees.indexOf("Mark"));

lastIndexOf(Object o)

查找LinkedList中最后出现的元素的索引

System.out.println("lastIndexOf \"David\" : " + employees.lastIndexOf("David"));
System.out.println("lastIndexOf \"Bob\" : " + employees.lastIndexOf("Bob"));

6. 遍历LinkedList。

package com.javaguides.collections.linkedlistexamples;

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

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

        progLangs.add("C");
        progLangs.add("C++");
        progLangs.add("Core Java");
        progLangs.add("Java EE");
        progLangs.add("Spring Framework");
        progLangs.add("Hibernate Framework");

        System.out.println("=== Iterate over a LinkedList using Java 8 forEach and lambda ===");
        progLangs.forEach(name - > {
            System.out.println(name);
        });


        System.out.println("\n=== Iterate over a LinkedList using iterator() ===");
        Iterator < String > iterator = progLangs.iterator();
        while (iterator.hasNext()) {
            String speciesName = iterator.next();
            System.out.println(speciesName);
        }

        System.out.println("\n=== Iterate over a LinkedList using iterator() and Java 8 forEachRemaining() method ===");
        iterator = progLangs.iterator();
        iterator.forEachRemaining(speciesName - > {
            System.out.println(speciesName);
        });

        System.out.println("\n=== Iterate over a LinkedList using descendingIterator() ===");
        Iterator < String > descendingIterator = progLangs.descendingIterator();
        while (descendingIterator.hasNext()) {
            String speciesName = descendingIterator.next();
            System.out.println(speciesName);
        }


        System.out.println("\n=== Iterate over a LinkedList using listIterator() ===");
        // ListIterator can be used to iterate over the LinkedList in both forward and backward directions
        // In this example, we start from the end of the list and traverse backwards
        ListIterator < String > listIterator = progLangs.listIterator(progLangs.size());
        while (listIterator.hasPrevious()) {
            String speciesName = listIterator.previous();
            System.out.println(speciesName);
        }

        System.out.println("\n=== Iterate over a LinkedList using simple for-each loop ===");
        for (String name: progLangs) {
            System.out.println(name);
        }
    }
}

输出

=== Iterate over a LinkedList using Java 8 forEach and lambda ===
C
C++
Core Java
Java EE
Spring Framework
Hibernate Framework

=== Iterate over a LinkedList using iterator() ===
C
C++
Core Java
Java EE
Spring Framework
Hibernate Framework

=== Iterate over a LinkedList using iterator() and Java 8 forEachRemaining() method ===
C
C++
Core Java
Java EE
Spring Framework
Hibernate Framework

=== Iterate over a LinkedList using descendingIterator() ===
Hibernate Framework
Spring Framework
Java EE
Core Java
C++
C

=== Iterate over a LinkedList using listIterator() ===
Hibernate Framework
Spring Framework
Java EE
Core Java
C++
C

=== Iterate over a LinkedList using simple for-each loop ===
C
C++
Core Java
Java EE
Spring Framework
Hibernate Framework

7. ArrayList和LinkedList的区别

1. ArrayList 内部使用动态数组来存储元素。 LinkedList 内部使用双链表来存储元素。

2. 使用ArrayList的操作很慢，因为它内部使用了一个数组。如果从数组中删除任何元素，所有的位都会在内存中移位。用LinkedList进行操作比ArrayList快，因为它使用一个双链表，所以不需要在内存中移位。

3. ArrayList 类只能作为一个列表，因为它只实现了List。LinkedList 类可以作为列表和队列，因为它实现了 List 和 Deque 接口。

4. ArrayList更适合于存储和访问数据。LinkedList更适合于操作数据。