Java集合随机访问接口：RandomAccess

引出RandomAccess类：

最近在学习Collections工具类时，发现了一个RandomAccess接口：

public static void reverse(List<?> list) {
        int size = list.size();
        if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
                swap(list, i, j);
                ......
    	}
}

然后打开发现是一个空的接口：

 * @since 1.4
 */
public interface RandomAccess {
}

同时查看时，发现，ArrayList实现了此接口，但是LinkedList却没有：

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
{

标志接口

通过官网的API，我才知道，原来这是一个标志接口，下面引入一段官网的原文：

public interface RandomAccess

Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.

这段话大概的意思就是说 RandomAccess 是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。也就是说，实现了这个接口的集合是支持 快速随机访问 策略的。

同时，官网还特意说明了，如果是实现了这个接口的 List，那么使用for循环的方式获取数据会优于用迭代器获取数据。

As a rule of thumb, aList implementation should implement this interface if, for typical instances of the class, this loop:

​ for (int i=0, n=list.size(); i < n; i++)
list.get(i);

​ for (Iterator i=list.iterator(); i.hasNext(); )
i.next();

接口的作用：

可以通过判断list是否实现这个接口，实现表示能支持快速访问，支持快速访问，就可以用for循环。
可以看Collections的binarySearch()方法：

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

可以看到实现与不实现走不同的方法。
查看这个方法的区别可以看到实现了此接口的方法使用for循环，没有实现的使用迭代器：

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

        while (low <= high) {
            int mid = (low + high) >>> 1;
            Comparable<? super T> midVal = list.get(mid);
            int cmp = midVal.compareTo(key);

            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 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 <= high) {
            int mid = (low + high) >>> 1;
            Comparable<? super T> midVal = get(i, mid);
            int cmp = midVal.compareTo(key);

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

测试：

public static void main (String args[]) {
        List list = new ArrayList();
        for (int i = 1; i < 1000000; i ++) {
            list.add(i);
        }
        long startA = System.currentTimeMillis();
        System.out.println(startA);
        for (int i = 0; i < list.size();i ++) {
            Object k = list.get(i);
        }
        System.out.println(System.currentTimeMillis() - startA);
        Iterator iterator = list.iterator();
        startA = System.currentTimeMillis();
        System.out.println(startA);
        while (iterator.hasNext()) {
            Object k = iterator.next();
        }
        System.out.println(System.currentTimeMillis() - startA);
    }

1585581953018
8
1585581953027
11

可以看出，for循环遍历元素时间上是少于迭代器的，证明RandomAccess 接口确实是有这个效果。

总结：

RandomAccess接口这个空架子的存在，是为了能够更好地判断集合是否ArrayList或者LinkedList，从而能够更好选择更优的遍历方式，提高性能！

摘自：https://blog.csdn.net/weixin_39148512/article/details/79234817?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
https://www.cnblogs.com/yeya/p/9950723.html