Java基础--LinkedList类实现链表_java linkedlist 如何实现链

LinkedList是Java中实现链表的一个类，它实现了List接口，表示一个双向链表的集合。

LinkedList是Java集合框架中实现了List接口的双向链表数据结构。它是由一系列节点组成的，每个节点都包含一个元素和指向前一个节点和后一个节点的引用，即链表中的每个节点都有一个指向前一个节点和后一个节点的指针。

以下是几种常见方法API：

1. LinkedList(): 创建一个新的空链表。
2. add(E element): 将指定的元素添加到链表的末尾。
3. add(int index, E element): 将指定的元素插入到链表的指定位置。
4. get(int index): 返回链表中指定位置的元素。
5. remove(int index): 删除链表中指定位置的元素，并返回被删除的元素。
6. size(): 返回链表中元素的数量。
7. clear(): 清空链表中的所有元素。
8. contains(Object element): 检查链表中是否包含指定的元素，返回true或false。
9. isEmpty(): 检查链表是否为空，返回true或false。
10. indexOf(Object element): 返回链表中第一次出现指定元素的索引位置，如果不存在则返回-1。
11. lastIndexOf(Object element): 返回链表中最后一次出现指定元素的索引位置，如果不存在则返回-1。
12. toArray(): 将链表转换为数组。

以上每个API对应的代码实例如下：

import java.util.LinkedList;
 
public class LinkedListExample {
    public static void main(String[] args) {
 
        // 创建一个新的空链表
        LinkedList<String> linkedList = new LinkedList<>();
 
        // 将元素添加到链表末尾
        linkedList.add("苹果");
        linkedList.add("香蕉");
        linkedList.add("橙子");
 
        // 在指定位置插入元素
        linkedList.add(1, "葡萄");
 
        // 获取指定位置的元素
        String fruit = linkedList.get(2);
        System.out.println("索引为2的元素: " + fruit);
 
        // 移除指定位置的元素
        String removedFruit = linkedList.remove(0);
        System.out.println("移除的元素: " + removedFruit);
 
        // 获取链表的大小
        int size = linkedList.size();
        System.out.println("大小: " + size);
 
        // 检查链表是否为空
        boolean empty = linkedList.isEmpty();
        System.out.println("是否为空: " + empty);
 
        // 检查链表是否包含指定元素
        boolean contains = linkedList.contains("苹果");
        System.out.println("是否包含苹果: " + contains);
 
        // 获取某个元素的首次出现位置的索引
        int index = linkedList.indexOf("香蕉");
        System.out.println("香蕉的索引: " + index);
 
        // 获取某个元素最后一次出现位置的索引
        int lastIndex = linkedList.lastIndexOf("橙子");
        System.out.println("橙子最后一次出现的索引: " + lastIndex);
 
        // 将链表转换为数组
        Object[] array = linkedList.toArray();
 
        // 清空链表
        linkedList.clear();
    }
}

LinkedList类：LinkedList是Java中实现链表的一个类。它实现了List接口，表示一个双向链表的集合，如下是几种常用API：

• addFirst(E element)：将元素添加到链表的开头。
• addLast(E element)：将元素添加到链表的末尾。
• getFirst()：获取链表的第一个元素。
• getLast()：获取链表的最后一个元素。
• removeFirst()：删除并返回链表的第一个元素。
• removeLast()：删除并返回链表的最后一个元素。

以下是每个API实例的代码；

import java.util.LinkedList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个LinkedList对象
        LinkedList<String> linkedList = new LinkedList<>();
 
        // 添加元素到链表的开头
        linkedList.addFirst("A");
        System.out.println(linkedList); // 输出：[A]
 
        // 添加元素到链表的末尾
        linkedList.addLast("B");
        System.out.println(linkedList); // 输出：[A, B]
 
        // 获取链表的第一个元素
        String firstElement = linkedList.getFirst();
        System.out.println("First element: " + firstElement); // 输出：First element: A
 
        // 获取链表的最后一个元素
        String lastElement = linkedList.getLast();
        System.out.println("Last element: " + lastElement); // 输出：Last element: B
 
        // 删除并返回链表的第一个元素
        String removedFirstElement = linkedList.removeFirst();
        System.out.println("Removed first element: " + removedFirstElement); // 输出：Removed first element: A
        System.out.println(linkedList); // 输出：[B]
 
        // 删除并返回链表的最后一个元素
        String removedLastElement = linkedList.removeLast();
        System.out.println("Removed last element: " + removedLastElement); // 输出：Removed last element: B
        System.out.println(linkedList); // 输出：[]
    }
}

List接口：List是一个接口，它可以由不同的类来实现，包括ArrayList和LinkedList等，所以List接口可以定义链表的基本操作，包括增删改查等，如下是几种常用API：

• add(E element)：将元素添加到链表的末尾。
• add(int index, E element)：将元素插入到指定位置。
• remove(int index)：删除指定位置的元素。
• get(int index)：获取指定位置的元素。
• set(int index, E element)：将指定位置的元素替换为新的元素。
• size()：返回链表的大小。

以下是每个API实例的代码；

import java.util.List;
import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        
        // 创建一个List对象
        List<String> list = new ArrayList<>();
 
        // 将元素添加到链表的末尾
        list.add("A");
        list.add("B");
        list.add("C");
        System.out.println(list); // 输出：[A, B, C]
 
        // 将元素插入到指定位置
        list.add(1, "D");
        System.out.println(list); // 输出：[A, D, B, C]
 
        // 删除指定位置的元素
        list.remove(2);
        System.out.println(list); // 输出：[A, D, C]
 
        // 获取指定位置的元素
        String element = list.get(1);
        System.out.println("Element: " + element); // 输出：Element: D
 
        // 将指定位置的元素替换为新的元素
        list.set(0, "E");
        System.out.println(list); // 输出：[E, D, C]
 
        // 返回链表的大小
        int size = list.size();
        System.out.println("Size: " + size); // 输出：Size: 3
    }
}

Iterator接口：Iterator接口用于遍历链表，常用两个API如下：

• hasNext()：判断是否还有下一个元素
•  next()：返回下一个元素

以下是两个API实例的代码；

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
 
public class Main {
    public static void main(String[] args) {
       
        // 创建一个List对象
        List<String> list = new ArrayList<>();
 
        // 添加元素到链表
        list.add("A");
        list.add("B");
        list.add("C");
 
        // 获取Iterator对象
        Iterator<String> iterator = list.iterator();
 
        // 判断是否还有下一个元素
        while (iterator.hasNext()) {
            // 返回下一个元素
            String element = iterator.next();
            System.out.println("Element: " + element);
        }
    }
}

附：以上内容均为自己撰写，若有错误，将在第一时间修改。