Question

以下代码的目标是对300,000个整数进行排序。我发现ArrayList的sort（）的持续时间小于Arrays的sort（）。在内部，它们使用相同的算法进行排序。 ArrayList使用Arrays的sort（）对元素数据进行排序。

public class EasySort {
    public static void main(String args[]) {
        // Read data from file, number split by ","
        FileReader fr = null;
        try {
            fr = new FileReader("testdata2.txt");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        BufferedReader  bufferedReader=new BufferedReader(fr);
        String line=null;
        try {
            line=bufferedReader.readLine();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        // use split method to generate a String array to save numbers
        String[] strArray=line.split(",");

        //Convert string array to ArrayList<Integer>
        ArrayList<Integer> integerList=new ArrayList<>();
        for(String str:strArray){
            integerList.add(Integer.parseInt(str));
        }

        //Sort by ArrayList
        long t0=System.currentTimeMillis();
        integerList.sort(((p1,p2)->(p1.intValue()<p2.intValue()?-1:p1.intValue()>p2.intValue()?1:0)));
        long t1=System.currentTimeMillis();
        System.out.println("ArrayList Sort duration:"+(t1-t0));

        //Convert string array to Integer array
        Integer[] integerArray=new Integer[strArray.length];
        int i=0;
        for(String str:strArray){
            integerArray[i++]=Integer.parseInt(str);
        }

        //Sort by Arrays
        t0=System.currentTimeMillis();
        Arrays.sort(integerArray, ((p1,p2)->(p1.intValue()<p2.intValue()?-1:p1.intValue()>p2.intValue()?1:0)));
        t1=System.currentTimeMillis();
        System.out.println("Arrays duration:"+(t1-t0));
    }
}

结果如下：
ArrayList排序时间：211
数组持续时间：435

我检查了ArrayList的源代码。它在自己的sort方法中使用Arrays.sort（）。

 @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

所以，我认为我的代码应显示相同的持续时间。但是我尝试了很多次，结果是相似的。发生什么事了？

Java版本：8
操作系统：Windows 7

Answer 1

这是一个热身的问题-但这正是我不知道的原因。

使用此代码：

public void test() {
    Integer[] a = randomData(10000000);

    ArrayList<Integer> integerList = new ArrayList<>();
    for (Integer i : a) {
        integerList.add(i);
    }

    long t0, t1;
    //Sort by ArrayList
    t0 = System.currentTimeMillis();
    integerList.sort(((p1, p2) -> (p1.intValue() < p2.intValue() ? -1 : p1.intValue() > p2.intValue() ? 1 : 0)));
    t1 = System.currentTimeMillis();
    System.out.println("ArrayList duration:" + (t1 - t0));


    //Sort by Arrays
    Integer[] integerArray = Arrays.copyOf(a, a.length);
    t0 = System.currentTimeMillis();
    Arrays.sort(integerArray, ((p1, p2) -> (p1.intValue() < p2.intValue() ? -1 : p1.intValue() > p2.intValue() ? 1 : 0)));
    t1 = System.currentTimeMillis();
    System.out.println("Arrays duration:" + (t1 - t0));

}

Random r = new Random(System.currentTimeMillis());

private Integer[] randomData(int n) {
    Integer[] a = new Integer[n];
    for (int i = 0; i < n; i++) {
        a[i] = r.nextInt();
    }
    return a;
}

然后将两种排序移到不同的顺序：

数组持续时间：4209

ArrayList持续时间：4570

ArrayList持续时间：6776

数组持续时间：4684

因此，如果ArrayList排在最前面，则需要更长的时间。

@AndyTurner的评论正确-请参考How do I write a correct micro-benchmark in Java?

Java 8-Windows 10

Answer 2

它们应该是相同的，我不知道你为什么会有不同的结果。下面是我的代码，我几乎有相同的时间。对于T[]和ArrayList<T>都将调用Arrays.sort(T[], ...)，然后将使用合并排序或tim排序。

Random rand = new Random();
Integer[] array = new Integer[300000];
for (int i = 0; i < array.length; i++)
    array[i] = rand.nextInt(array.length);  
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(array));    

long a = System.currentTimeMillis();
Arrays.sort(array, 0 ,array.length);
long b = System.currentTimeMillis();
list.sort(null);
long c = System.currentTimeMillis();

System.out.println(b - a);
System.out.println(c - b);

Answer 3

这是我使用Java 8尝试过的。请注意，有一个数组是myItems.Select(mi => mi.MyProperty).OfType<MyType>()，一个数组是int，而Integer是List s。另外，Integer数组是使用Integer排序的。

Arrays.parallelSort()

结果（在运行于CORE i3处理器上的Windows 7 64位操作系统上）：

import java.util.*;
import java.util.stream.*;
public class TestingSorts {
    public static void main(String[] args) {
        long t0 = 0L;
        long t1 = 0L;
        // Run this procedure 10 times
        for (int i = 1; i < 11; i++) {
            // Create an int array and Integer List filled with random numbers
            int [] intArray = IntStream.generate(() -> new Random().nextInt())
                        .limit(300_000)
                        .toArray();
            Integer [] integerArray = IntStream.generate(() -> new Random().nextInt())
                        .limit(300_000)
                        .boxed()
                        .toArray(n -> new Integer[n]);
            Integer [] integerArrayP = IntStream.generate(() -> new Random().nextInt())
                        .limit(300_000)
                        .boxed()
                        .toArray(n -> new Integer[n]);
            List<Integer> intList = IntStream.generate(() -> new Random().nextInt())
                        .limit(300_000)
                        .boxed()
                        .collect(Collectors.toCollection(ArrayList::new));
            // Sort the List and the arrays
            t0 = System.currentTimeMillis();
            intList.sort(null);
            t1 = System.currentTimeMillis();
            System.out.println(i + ") ArrayList<Integer> sort duration: " + (t1 - t0));
            t0 = System.currentTimeMillis();
            Arrays.sort(integerArray, Comparator.naturalOrder());
            t1 = System.currentTimeMillis();
            System.out.println(i + ") Integer[ ] sort duration: " + (t1 - t0));
            t0 = System.currentTimeMillis();
            Arrays.parallelSort(integerArrayP, Comparator.naturalOrder());
            t1 = System.currentTimeMillis();
            System.out.println(i + ") Integer[ ] PARALLEL sort duration: " + (t1 - t0));
            t0 = System.currentTimeMillis();
            Arrays.sort(intArray);
            t1 = System.currentTimeMillis();
            System.out.println(i + ") int[ ] sort duration: " + (t1 - t0));
        }
    }
}

编辑：添加了对1) ArrayList<Integer> sort duration: 200 1) Integer[ ] sort duration: 424 1) Integer[ ] PARALLEL sort duration: 414 1) int[ ] sort duration: 136 2) ArrayList<Integer> sort duration: 143 2) Integer[ ] sort duration: 101 2) Integer[ ] PARALLEL sort duration: 56 2) int[ ] sort duration: 33 3) ArrayList<Integer> sort duration: 124 3) Integer[ ] sort duration: 118 3) Integer[ ] PARALLEL sort duration: 96 3) int[ ] sort duration: 42 4) ArrayList<Integer> sort duration: 108 4) Integer[ ] sort duration: 102 4) Integer[ ] PARALLEL sort duration: 92 4) int[ ] sort duration: 57 5) ArrayList<Integer> sort duration: 142 5) Integer[ ] sort duration: 113 5) Integer[ ] PARALLEL sort duration: 118 5) int[ ] sort duration: 31 6) ArrayList<Integer> sort duration: 113 6) Integer[ ] sort duration: 103 6) Integer[ ] PARALLEL sort duration: 58 6) int[ ] sort duration: 32 7) ArrayList<Integer> sort duration: 115 7) Integer[ ] sort duration: 116 7) Integer[ ] PARALLEL sort duration: 57 7) int[ ] sort duration: 33 8) ArrayList<Integer> sort duration: 115 8) Integer[ ] sort duration: 115 8) Integer[ ] PARALLEL sort duration: 58 8) int[ ] sort duration: 31 9) ArrayList<Integer> sort duration: 114 9) Integer[ ] sort duration: 101 9) Integer[ ] PARALLEL sort duration: 52 9) int[ ] sort duration: 32 10) ArrayList<Integer> sort duration: 113 10) Integer[ ] sort duration: 114 10) Integer[ ] PARALLEL sort duration: 57 10) int[ ] sort duration: 32数组进行排序的功能。
编辑：添加了使用并行排序对Integer数组进行排序的功能。

为什么ArrayList的sort方法比Java中的Arrays更快？

3 个答案: