Java LinkedList 为什么不能实现 RandomAccess 接口？_linkedlist 为什么不能实现 randomaccess 接口?-CSDN博客

本文链接：https://blog.csdn.net/qq_33326733/article/details/139033982

在 Java 集合框架中，RandomAccess 是一个标记接口，用来表明实现该接口的类支持高速的随机访问（即可以通过索引快速访问元素）。然而，LinkedList 并没有实现这个接口。下面我们将详细解释原因，并通过源码解读和示例代码来深入了解这个问题。

`RandomAccess` 接口介绍

RandomAccess 是一个空接口（标记接口），定义在 java.util 包中。其主要目的是标记某个类支持高效的随机访问。实现了这个接口的类，例如 ArrayList，可以通过索引快速访问元素。

java

public interface RandomAccess {
    // no methods
}

`LinkedList` 数据结构

LinkedList 是基于链表的数据结构。链表是一种线性数据结构，元素存储在节点中，每个节点包含一个数据部分和一个指向下一个节点的引用。由于链表的节点在内存中不一定是连续的，因此无法通过索引直接访问特定位置的元素。

`LinkedList` 节点结构

在 LinkedList 中，每个节点由一个内部类 Node 表示，如下所示：

java

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

`ArrayList` vs `LinkedList` 的访问时间

为了更好地理解 LinkedList 为什么不能实现 RandomAccess 接口，我们可以通过对比 ArrayList 和 LinkedList 的访问时间来说明。

`ArrayList` 的访问时间

ArrayList 底层是一个动态数组，内存地址连续，可以通过索引快速访问元素。访问时间是 O(1)。

java

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    transient Object[] elementData; // non-private to simplify nested class access

    public E get(int index) {
        rangeCheck(index);
        return elementData[index];
    }
}

`LinkedList` 的访问时间

LinkedList 需要通过遍历节点来访问特定位置的元素。访问时间是 O(n)。

java

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
    transient Node<E> first;
    transient Node<E> last;

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    Node<E> node(int index) {
        // assert isElementIndex(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;
        }
    }
}

为什么 `LinkedList` 不能实现 `RandomAccess` 接口？

LinkedList 不能实现 RandomAccess 接口的主要原因在于其底层数据结构的特性。由于链表节点在内存中不连续，无法通过简单的数学计算（例如数组中的索引计算）快速定位到特定位置的元素。因此，LinkedList 的访问时间是线性的 O(n)，而非常数时间 O(1)。

实际应用场景

在实际应用中，当我们需要频繁地通过索引访问元素时，应该选择实现了 RandomAccess 接口的集合类，例如 ArrayList。而在需要频繁插入和删除操作的场景下，LinkedList 会更为高效。

示例代码

下面是一个比较 ArrayList 和 LinkedList 在访问元素时性能的示例代码：

java

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

public class ListAccessPerformance {

    public static void main(String[] args) {
        // Initialize lists
        List<Integer> arrayList = new ArrayList<>();
        List<Integer> linkedList = new LinkedList<>();

        // Populate lists with 1 million elements
        for (int i = 0; i < 1_000_000; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }

        // Measure access time for ArrayList
        long startTime = System.nanoTime();
        for (int i = 0; i < 1_000_000; i++) {
            arrayList.get(i);
        }
        long endTime = System.nanoTime();
        long arrayListAccessTime = endTime - startTime;

        // Measure access time for LinkedList
        startTime = System.nanoTime();
        for (int i = 0; i < 1_000_000; i++) {
            linkedList.get(i);
        }
        endTime = System.nanoTime();
        long linkedListAccessTime = endTime - startTime;

        // Print results
        System.out.println("ArrayList access time: " + arrayListAccessTime + " ns");
        System.out.println("LinkedList access time: " + linkedListAccessTime + " ns");
    }
}

运行结果会显示 ArrayList 的访问时间明显快于 LinkedList。