译|Arrays.sort VS Arrays.parallelSort

英文原文地址：Arrays.sort vs Arrays.parallelSort

作者：baeldung

翻译：高行行

小结：

当我们要排序的数据集很大时，parallelSort() 可能是更好的选择。但是，在数组较小的情况下，最好使用 sort()，因为它可以提供更好的性能

1. 概述

我们都使用过 Arrays.sort() 对对象或原始数据类型数组（byte，short，int，long，char，float，double和boolean）进行排序。在 JDK 8 中，创造者增强了 API 以提供一种新方法：_Arrays.parallelSort()_。

在本教程中，我们将对 sort() 和 parallelSort() 方法进行比较。

2. Arrays.sort()

Arrays.sort() 方法对对象或原始数据类型的数组进行排序。此方法中使用的排序算法是 Dual-Pivot Quicksort。 换句话说，它是快速排序算法的自定义实现，以实现更好的性能。

此方法是单线程的 ，有两种变体：

• _sort(array)_–将整个数组按升序排序
• _sort(array, fromIndex, toIndex)_–仅将从 fromIndex 到 toIndex 的元素排序

让我们看一下两种变体的例子：

@Test
public void givenArrayOfIntegers_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
    int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
    int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 
    Arrays.sort(array);
 
    assertArrayEquals(expected, array);
 
}
 
@Test
public void givenArrayOfIntegers_whenUsingArraysSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
    int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
    int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
 
    Arrays.sort(array, 2, 8);
 
    assertArrayEquals(expected, array);
}

让我们总结一下这种方法的优缺点：

优点	缺点
快速处理较小的数据集	大型数据集的性能下降
	没有利用系统的多个核心

3. Arrays.parallelSort()

此方法对对象或原始数据类型的数组进行排序。与 sort() 类似，它也有两个变体来对完整数组和部分数组进行排序：

@Test
public void givenArrayOfIntegers_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
    int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
    int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 
    Arrays.parallelSort(array);
 
    assertArrayEquals(expected, array);
}
 
@Test
public void givenArrayOfIntegers_whenUsingArraysParallelSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
    int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
    int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
 
    Arrays.parallelSort(array, 2, 8);
 
    assertArrayEquals(expected, array);
}

parallelSort() 在功能上有所不同。与 sort() 使用单个线程对数据进行顺序排序不同，它使用并行排序-合并排序算法。它将数组分成子数组，这些子数组本身先进行排序然后合并。

为了执行并行任务，它使用 ForkJoin 池。

但是我们需要知道，只有在满足某些条件时，它才会使用并行性。如果数组大小小于或等于 8192，或者处理器只有一个核心，则它将使用顺序的 Dual-Pivot Quicksort 算法。否则，它使用并行排序。

让我们总结一下使用它的优缺点：

优点	缺点
为大型数据集提供更好的性能	对于大小较小的数组，处理速度较慢
利用系统的多个核心

4.比较

现在，让我们看看在不同大小的数据集上两种方法怎样执行。以下数字是使用JMH 基准测试得出的。测试环境使用 AMD A10 PRO 2.1Ghz 四核处理器和 JDK 1.8.0_221：

数组大小	Arrays.sort()	Arrays.parallelSort()
1000	o.048	0.054
10000	0.847	0.425
100000	7.570	4.395
1000000	65.301	37.998

5.结论

在这篇短篇文章中，我们看到了 sort() 和 parallelSort() 的不同之处。

根据性能结果，我们可以得出结论，当我们要排序的数据集很大时，parallelSort() 可能是更好的选择。但是，在数组较小的情况下，最好使用 sort()，因为它可以提供更好的性能。

与往常一样，完整的源代码可以在 GitHub 找到。

打赏