Java ArrayList 为什么要实现 RandomAccess 接口？

最新推荐文章于 2024-07-09 11:00:14 发布

My_Way666

最新推荐文章于 2024-07-09 11:00:14 发布

阅读量235

点赞数 1

分类专栏： java 文章标签： java 数据结构

原文链接：https://blog.csdn.net/qq_36879870/article/details/97370068

版权

java 专栏收录该内容

74 篇文章 1 订阅

订阅专栏

本文深入探讨了ArrayList和LinkedList在不同遍历方式下的性能表现，揭示了实现RandomAccess接口对List遍历效率的影响。通过实验对比，展示了ArrayList适用于for循环遍历，而LinkedList则更适合使用iterator遍历。

摘要由CSDN通过智能技术生成

总结：
ArrayList通过for遍历比通过iterator遍历要稍快，LinkedList通过iterator遍历比通过for遍历要快。

所以说在我们的应用中，要考虑使用List接口的哪种实现类，可以更好更高效的满足实际场景需求。所以在这里通过实现RandomAccess接口来区分List的哪种实现类。

在我们的开发中，List接口是最常见不过，而且我们几乎每天都在用ArrayList或者LinkedList，但是细心的同学有没有发现，ArrayList中实现了RandomAccess接口，而LinkedList却没有实现RandomAccess接口，这是为什么呢？

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

RandomAccess接口中是空的，RandomAccess接口又是什么呢？

public interface RandomAccess {
}

RandomAccess接口

RandomAccess是一个标记接口，官方解释是只要List实现这个接口，就能支持快速随机访问。而什么是随机访问呢？接下来我们来举例说明。
Collections是集合的一个工具类，我们看一下Collections源码中的二分搜索方法。

public static <T>
    int binarySearch(List<? extends Comparable<? super T>> list, T key) {
        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            return Collections.indexedBinarySearch(list, key);
        else
            return Collections.iteratorBinarySearch(list, key);
    }

在源码中可以看出，判断list是否是RandomAccess的实例，如果是，则执行indexedBinarySearch方法，如果不是，则执行iteratorBinarySearch方法。接下来看一下这两个方法。

private static <T>
int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key) {
    int low = 0;
    int high = list.size()-1;
while (low &lt;= high) {
    int mid = (low + high) &gt;&gt;&gt; 1;
    Comparable&lt;? super T&gt; midVal = list.get(mid);
    int cmp = midVal.compareTo(key);

    if (cmp &lt; 0)
        low = mid + 1;
    else if (cmp &gt; 0)
        high = mid - 1;
    else
        return mid; // key found
}
return -(low + 1);  // key not found

}
private static <T>
int iteratorBinarySearch(List<? extends Comparable<? super T>> list, T key)
{
int low = 0;
int high = list.size()-1;
ListIterator<? extends Comparable<? super T>> i = list.listIterator();

while (low &lt;= high) {
    int mid = (low + high) &gt;&gt;&gt; 1;
    Comparable&lt;? super T&gt; midVal = get(i, mid);
    int cmp = midVal.compareTo(key);

    if (cmp &lt; 0)
        low = mid + 1;
    else if (cmp &gt; 0)
        high = mid - 1;
    else
        return mid; // key found
}
return -(low + 1);  // key not found

}

上述两个方法的源码表示，实现了RandomAccess接口的List使用索引遍历，而未实现RandomAccess接口的List使用迭代器遍历。那么为什么要这么设计呢？
既然涉及到二分搜索的遍历操作，那么现在我们来分析一下ArrayList和LinkedList遍历元素的性能如何？

public class CollectionTest {
    public static void main(String[] args){
        long arrayListIndexedTime = arrayListIndexed();
        long arrayListIteratorTime = arrayListIterator();
        long linkedListIndexedTime = linkedListIndexed();
        long linkedListIteratorTime = linkedListIterator();
        System.out.println("测试ArrayList通过for遍历所消耗时间：" + arrayListIndexedTime);
        System.out.println("测试ArrayList通过iterator遍历所消耗时间：" + arrayListIteratorTime);
        System.out.println("测试LinkedList通过for遍历所消耗时间：" + linkedListIndexedTime);
        System.out.println("测试LinkedList通过iterator遍历所消耗时间：" + linkedListIteratorTime);
    }
//测试ArrayList通过for遍历所消耗时间
public static long arrayListIndexed() {
    List&lt;Integer&gt; arrayList = new ArrayList&lt;&gt;();
    for (int i = 0; i &lt; 10000; i++) {
        arrayList.add(i);
    }
    //记录开始时间
    long startTime = System.currentTimeMillis();
    for (int i = 0; i &lt; arrayList.size(); i++) {
        arrayList.get(i);
    }
    //记录结束时间
    long endTime = System.currentTimeMillis();
    //遍历消耗时间
    long resultTime = endTime - startTime;
    return resultTime;
}

//测试ArrayList通过iterator遍历所消耗时间
public static long arrayListIterator() {
    List&lt;Integer&gt; arrayList = new ArrayList&lt;&gt;();
    for (int i = 0; i &lt; 10000; i++) {
        arrayList.add(i);
    }
    //记录开始时间
    long startTime = System.currentTimeMillis();
    Iterator&lt;Integer&gt; iterator = arrayList.iterator();
    while (iterator.hasNext()) {
        iterator.next();
    }
    //记录结束时间
    long endTime = System.currentTimeMillis();
    //遍历消耗时间
    long resultTime = endTime - startTime;
    return resultTime;
}

//测试LinkedList通过for遍历所消耗时间
public static long linkedListIndexed() {
    List&lt;Integer&gt; linkedList = new LinkedList&lt;&gt;();
    for (int i = 0; i &lt; 10000; i++) {
        linkedList.add(i);
    }
    //记录开始时间
    long startTime = System.currentTimeMillis();
    for (int i = 0; i &lt; linkedList.size(); i++) {
        linkedList.get(i);
    }
    //记录结束时间
    long endTime = System.currentTimeMillis();
    //遍历消耗时间
    long resultTime = endTime - startTime;
    return resultTime;
}

//测试LinkedList通过iterator遍历所消耗时间
public static long linkedListIterator() {
    List&lt;Integer&gt; linkedList = new LinkedList&lt;&gt;();
    for (int i = 0; i &lt; 10000; i++) {
        linkedList.add(i);
    }
    //记录开始时间
    long startTime = System.currentTimeMillis();
    Iterator&lt;Integer&gt; iterator = linkedList.iterator();
    while (iterator.hasNext()) {
        iterator.next();
    }
    //记录结束时间
    long endTime = System.currentTimeMillis();
    //遍历消耗时间
    long resultTime = endTime - startTime;
    return resultTime;
}

}

测试结果如下

测试ArrayList通过for遍历所消耗时间：1
测试ArrayList通过iterator遍历所消耗时间：2
测试LinkedList通过for遍历所消耗时间：47
测试LinkedList通过iterator遍历所消耗时间：1

我们来分析一下测试结果：ArrayList通过for遍历比通过iterator遍历要稍快，LinkedList通过iterator遍历比通过for遍历要快。

总结

**
最后总结一句话：实现RandomAccess接口的List可以通过for循环来遍历数据比使用iterator遍历数据更高效，未实现RandomAccess接口的List可以通过iterator遍历数据比使用for循环来遍历数据更高效。
**

                                </div><div><div></div></div>
            <link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-ff98e99283.css" rel="stylesheet">
                            </div>