RandomAccess接口

最新推荐文章于 2024-05-19 00:46:48 发布

_thinkCode

最新推荐文章于 2024-05-19 00:46:48 发布

阅读量640

点赞数

分类专栏： java源码

java源码专栏收录该内容

13 篇文章 0 订阅

订阅专栏

RandomAccess在类Collections的shuffle()方法中的使用:(jdk源码如下)

    <span style="font-size: small;">/** 
         * Randomly permute the specified list using the specified source of 
         * randomness.  All permutations occur with equal likelihood 
         * assuming that the source of randomness is fair.<p> 
         * 
         * This implementation traverses the list backwards, from the last element 
         * up to the second, repeatedly swapping a randomly selected element into 
         * the "current position".  Elements are randomly selected from the 
         * portion of the list that runs from the first element to the current 
         * position, inclusive.<p> 
         * 
         * This method runs in linear time.  If the specified list does not 
         * implement the {@link RandomAccess} interface and is large, this 
         * implementation dumps the specified list into an array before shuffling 
         * it, and dumps the shuffled array back into the list.  This avoids the 
         * quadratic behavior that would result from shuffling a "sequential 
         * access" list in place. 
         * 
         * @param  list the list to be shuffled. 
         * @param  rnd the source of randomness to use to shuffle the list. 
         * @throws UnsupportedOperationException if the specified list or its 
         *         list-iterator does not support the <tt>set</tt> operation. 
         */  
      
      
    public static void shuffle(List<?> list, Random rnd) {  
            int size = list.size();  
            if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {//注意这一句中的instanceof  
                for (int i=size; i>1; i--)  
                    swap(list, i-1, rnd.nextInt(i));  
            } else {  
                Object arr[] = list.toArray();  
      
                // Shuffle array  
                for (int i=size; i>1; i--)  
                    swap(arr, i-1, rnd.nextInt(i));  
      
                // Dump array back into list  
                ListIterator it = list.listIterator();  
                for (int i=0; i<arr.length; i++) {  
                    it.next();  
                    it.set(arr[i]);  
                }  
            }  
        }</span>

由以上的jdk源码可见,在对实现list接口的对象进行洗牌,打乱时,区分了该类是否是RandomAccess的实例,这样做有什么意义呢?请继续向下看:

介绍:

在jdk文档中对RandomAccess接口的定义如下:

public interface RandomAccess

List 实现所使用的标记接口，用来表明其支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。

将操作随机访问列表的最佳算法（如 ArrayList）应用到连续访问列表（如 LinkedList）时，可产生二次项的行为。如果将某个算法应用到连续访问列表，那么在应用可能提供较差性能的算法前，鼓励使用一般的列表算法检查给定列表是否为此接口的一个 instanceof，如果需要保证可接受的性能，还可以更改其行为。

现在已经认识到，随机和连续访问之间的区别通常是模糊的。例如，如果列表很大时，某些 List 实现提供渐进的线性访问时间，但实际上是固定的访问时间。这样的 List 实现通常应该实现此接口。

强调:

JDK中推荐的是对List集合尽量要实现RandomAccess接口

如果集合类是RandomAccess的实现，则尽量用for(int i = 0; i < size; i++) 来遍历而不要用Iterator迭代器来遍历，在效率上要差一些。反过来，如果List是Sequence List，则最好用迭代器来进行迭代。

JDK中说的很清楚，在对List特别是Hugesize的List的遍历算法中，要尽量来判断是属于RandomAccess(如ArrayList)还是Sequence List(如LinkedList），因为适合RandomAccess List的遍历算法，用在Sequence List上就差别很大，常用的作法就是：
    要作一个判断：
    if (list instance of RandomAccess) {
        for(int m = 0; m < list.size(); m++){}
    }else{
        Iterator iter = list.iterator();
        while(iter.hasNext()){}
    }

    <span style="font-size: small;">/* 
     * To change this template, choose Tools | Templates 
     * and open the template in the editor. 
     */  
    package testrandomaccess;  
      
    import java.util.ArrayList;  
    import java.util.Iterator;  
    import java.util.LinkedList;  
    import java.util.List;  
    import java.util.RandomAccess;  
      
    /** 
     * 
     * @author bolong 
     */  
    public class TestRandomAccess {  
    // 初始化列表  
      
        public static void initList(List list, int n) {  
            for (int i = 0; i < n; i++) {  
                list.add(i);  
            }  
        }  
    //使用循环进行对列表的迭代  
      
        public static void traverseWithLoop(List list) {  
            long starttime = 0;  
            long endtime = 0;  
            starttime = System.currentTimeMillis();  
            for (int count = 0; count <= 1000; count++) {  
                for (int i = 0; i < list.size(); i++) {  
                    list.get(i);  
                }  
            }  
            endtime = System.currentTimeMillis();  
            System.out.println("使用loop迭代一共花了" + (endtime - starttime) + "ms时间");  
      
        }  
    //使用迭代器对列表进行迭代  
      
        public static void traverseWithIterator(List list) {  
            long starttime = 0;  
            long endtime = 0;  
            starttime = System.currentTimeMillis();  
            for (int count = 0; count <= 1000; count++) {  
                for (Iterator itr = list.iterator(); itr.hasNext();) {  
                    itr.next();  
                }  
            }  
            endtime = System.currentTimeMillis();  
            System.out.println("使用Iterator迭代一共花了" + (endtime - starttime) + "ms时间");  
        }  
      
        public static void traverse(List list) {  
      
            long starttime = 0;  
            long endtime = 0;  
            if (list instanceof RandomAccess) {  
                System.out.println("该list实现了RandomAccess接口");  
                starttime = System.currentTimeMillis();  
                for (int count = 0; count <= 1000; count++) {  
                    for (int i = 0; i < list.size(); i++) {  
                        list.get(i);  
                    }  
                }  
                endtime = System.currentTimeMillis();  
                System.out.println("迭代一共花了" + (endtime - starttime) + "ms时间");  
            } else {  
                System.out.println("该list未实现RandomAccess接口");  
                starttime = System.currentTimeMillis();  
                for (int count = 0; count <= 1000; count++) {  
                    for (Iterator itr = list.iterator(); itr.hasNext();) {  
                        itr.next();  
                    }  
                }  
                endtime = System.currentTimeMillis();  
                System.out.println("迭代一共花了" + (endtime - starttime) + "ms时间");  
            }  
        }  
      
        public static void main(String[] args) {  
            ArrayList arraylist = new ArrayList();  
            LinkedList linkedlist = new LinkedList();  
            initList(arraylist, 1000);  
            initList(linkedlist, 1000);  
            traverse(arraylist);  
            traverse(linkedlist);  
            traverseWithIterator(arraylist);  
            traverseWithLoop(arraylist);  
            traverseWithIterator(linkedlist);  
            traverseWithLoop(linkedlist);  
        }  
    }  
    </span>

运行程序输出的结果为:

该list实现了RandomAccess接口
迭代一共花了47ms时间
该list未实现RandomAccess接口
迭代一共花了15ms时间
使用Iterator迭代一共花了79ms时间
使用loop迭代一共花了46ms时间
使用Iterator迭代一共花了47ms时间
使用loop迭代一共花了797ms时间

结论:

根据程序输出的结果的确证明了,arraylist等实现了RandomAccessj接口的类在进行迭代时使用loop效率更高,而linkedList那些未实现该接口的类在进行迭代时使用Iterator进行迭代效率更高.