Java Arrays.parallelSort()方法

原文：https://www.studytonight.com/java-util/java-arrays-parallelsort-method

在本教程中，我们将学习 Java 中数组类的parallelSort()方法。这种排序技术非常快，因为它可以并行地对给定数组的元素进行排序。这种排序算法是弗拉基米尔·雅罗斯拉夫斯基、乔恩·本特利和乔什·布洛赫的双枢轴快速排序。该算法在所有数据集上提供 O(n log(n))性能，通常比传统的(单轴)快速排序实现更快。

句法

parallelSort(datatype[] array)

此方法接受数组作为参数，并在排序后返回它。

parallelSort()方法重载方法列表

此表包含parallelSort()方法的所有重载变体。

【parallelSort()是如何工作的？

该方法在以下步骤中工作

1. 递归划分数组，直到到达单个元素。
2. 所有单独的元素都在多个线程上排序。
3. 所有的子数组被合并得到一个排序的数组。

示例:使用parallelSort()方法对数组进行排序

在下面的例子中，首先我们有一个未排序的整数数组。应用parallelSort() 方法后，所有元素都被排序，并且可以在从数组中打印每个元素后进行验证。

import java.util.Arrays;
class StudyTonight { 
    public static void main(String args[]) 
    { 
        int arr[] = {1, 46, 165, 6, 78, 6, 65, 955, 4, 5, 323, 256, 5, 99, 22, 33};
        //sorting an array
        Arrays.parallelSort(arr);        
        for(int num:arr)
        {
            System.out.print(num+" ");
        }
    } 
}

1 4 5 6 6 22 33 46 65 78 99 165 256 323 955

示例:使用具有特定范围的parallelSort()方法对数组进行排序

在下面的程序中，我们可以看到给定的未排序数组 arr 只排序到前八个元素，这是因为我们在方法中传递了一个 startIndex 和 endIndex ，这是一个parallelSort()的重载方法。

import java.util.Arrays;
class StudyTonight { 
    public static void main(String args[]) 
    { 
        int arr[] = {5, 7, 1, 9, 8, 11, 2, 36, 1, 22, 34, 18, 17, 22, 13 };
        //sorting first eight array elements only
        Arrays.parallelSort(arr, 0, 7);        
        for(int num:arr)
        {
            System.out.print(num+" ");
        }
    } 
}

1 2 5 7 8 9 11 36 1 22 34 18 17 22 13

示例:使用带变量的parallelSort()对数组进行排序

import java.util.Arrays;
class StudyTonight { 
    public static void main(String args[]) 
    { 
        float arr[] = {5, 7, 1, 9, 8, 11, 2, 36, 1, 22, 34, 18, 17, 22, 13 };
        System.out.println("Array Before Sorting:");
        for(float num:arr)
        {
            System.out.print(num+" ");
        }
        System.out.println("\nArray Sorting from 0 to 6:");
        Arrays.parallelSort(arr, 0, 7);        
        for(float num:arr)
        {
            System.out.print(num+" ");
        }
        System.out.println("\nArray After Sorting as a Whole:");
        Arrays.parallelSort(arr);        
        for(float num:arr)
        {
            System.out.print(num+" ");
        } 
    } 
}

排序前数组: 5.0 7.0 1.0 9.0 8.0 11.0 2.0 36.0 1.0 22.0 34.0 18.0 17.0 22.0 13.0 从 0 到 6 的数组排序: 1.0 2.0 5.0 7.0 8.0 9.0 11.0 36.0 1.0 22.0 34.0 18.0 17.0 22.0 10

parallelSort()的所有重载方法示例

在下面的程序中，我们一起实现了parallelSort() 的所有重载方法。我们在不同的数据类型和不同的范围上实现了这个方法。从这个程序的输出，我们可以很容易地关联排序是如何在不同的数组上执行的。

import java.util.Arrays;
public class StudyTonight 
{
    public static void main(String[] args) 
    {
        byte byteArray[] = {5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60}; 
        Arrays.parallelSort(byteArray,0,5);
        System.out.println("Arrays.parallelSort(byteArray,0,5): "+Arrays.toString(byteArray));
        Arrays.parallelSort(byteArray);
        System.out.println("Arrays.parallelSort(byteArray): "+Arrays.toString(byteArray));        

        char charArray[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'}; 
        Arrays.parallelSort(charArray,0,5);
        System.out.println("Arrays.parallelSort(charArray,0,5): "+Arrays.toString(charArray));
        Arrays.parallelSort(charArray);
        System.out.println("Arrays.parallelSort(charArray): "+Arrays.toString(charArray));

        int intArray[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150};
        Arrays.parallelSort(intArray,0,5);
        System.out.println("Arrays.parallelSort(intArray,0,5): "+Arrays.toString(intArray));
        Arrays.parallelSort(intArray);
        System.out.println("Arrays.parallelSort(intArray): "+Arrays.toString(intArray));

        double doubleArray[] = {5.1, 6.2, 7.2, 8.1, 9.4, 10.2, 11.6, 12.96, 13.2, 14.25, 15.6, 16.4, 17.2}; 
        Arrays.parallelSort(doubleArray,0,5);
        System.out.println("Arrays.parallelSort(doubleArray,0,5): "+Arrays.toString(doubleArray));
        Arrays.parallelSort(intArray);
        System.out.println("Arrays.parallelSort(doubleArray): "+Arrays.toString(doubleArray));

        float floatArray[] = {1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, 10f}; 
        Arrays.parallelSort(floatArray,0,5);
        System.out.println("Arrays.parallelSort(floatArray,0,5): "+Arrays.toString(floatArray));
        Arrays.parallelSort(floatArray);
        System.out.println("Arrays.parallelSort(floatArray): "+Arrays.toString(floatArray));

        short shortArray[] = {2, 4, 6, 8, 10 ,12, 14, 16, 18, 20}; 
        Arrays.parallelSort(shortArray,0,5);
        System.out.println("Arrays.parallelSort(shortArray,0,5): "+Arrays.toString(shortArray));
        Arrays.parallelSort(shortArray);
        System.out.println("Arrays.parallelSort(shortArray): "+Arrays.toString(shortArray));
    }
}

数组。并行排序(字节数组，0，5): [5，10，15，20，25，30，35，40，45，50，55，60] 数组。并行排序(字节数组):[5，10，15，20，25，30，35，40，45，50，55，60] 数组。并行排序(字符数组，0，5): [a，b，c 90，100，110，120，130，140，150] 数组. parallels art(double array，0，5):【5.1，6.2，7.2，8.1，9.4，10.2，11.6，12.96，13.2，14.25，15.6，16.4，17.2】 数组. parallels art(double array):【5.1，6.2

结论

在本教程中，我们学习了如何使用parallelSort() 对给定的未排序数组进行高效排序。该方法使用分叉/连接概念对数组进行排序。这种排序算法是弗拉基米尔·雅罗斯拉夫斯基、乔恩·本特利和乔什·布洛赫的双枢轴快速排序。该算法在所有数据集上提供 O(n log(n))性能，通常比传统的(单轴)快速排序实现更快。