更高效地刷OJ——Java中常用的排序方法，Array.sort()，Arrays.parallelSort()， Collections.sort()

Posted 2021-10-01 有裂痕的石头

对于几大传统的排序算法我在前面博客中已经介绍过了，如果有想要了解的同学可以去看这篇博客八大排序：冒泡排序，选择排序，插入排序，堆排序，希尔排序，归并排序，计数排序但是我们在刷题过程中如果题目中没有对排序算法做特别要求，排序只是当前题目的一个小过程的话我们大可不必自己实现以便排序算法，因为Java中已经提供了几个对数据做排序的方法。

文章目录

• 用Array.sort()进行排序
• Arrays.parallelSort() 是什么 和 Array.sort()有什么区别
• 用 Collections.sort()进行排序

用Array.sort()进行排序

Java中对数组类型的数据有Array.sort(),具体如下：

使用上图第一个重载：

//用Java中有的数据类型做数组
 public static void main(String[] args) {
        int[] array = { 5, 3, 2, 1, 4, 6, 9, 8};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }

运行结果：

如果用自己的实现类做数组的话因为在排序过程中需要比较两个元素的大小，这个实现类必须实现Comparable接口（这篇博客会用到Comparable和Comparator两个接口，不会的同学请补这篇博客：Java中的Comparable和Comparator到底该怎么用看完就全明白了）：

//这是一个自己的实现类Ha，并且这个类实现了Comparable接口，
//意味着同类型对象之间可以进行比较
public class Ha implements Comparable<Ha>{
    int haVal;
    public Ha(int h ){
        haVal = h;
    }

    @Override
    public String toString() {
        return
                "haVal=" + haVal
               ;
    }

    @Override
    public int compareTo(Ha o) {
        //因为方法是拿当前对象compareTo传入对象o
        //所以：
        //返回负数表示当前对象比传入对象o小
        //返回正数反之
        return this.haVal - o.haVal;
    }
}

下面构建一个Ha[]数组并对它排序：

public class Demo7 {
    public static void main(String[] args) {
        //创建几个Ha类型对象
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        //将上面的对象放到Ha[]数组中
        Ha[] array = {f, d, c, e, b, a};

        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

运行结果：

使用第二个重载：

public static void main(String[] args) {
        int[] array = { 5, 3, 2, 1, 4, 6, 9, 8};
        //只会对指定区间内的数据排序，而且是左闭右开
        Arrays.sort(array, 0, 3);
        System.out.println(Arrays.toString(array));
    }

运行结果：

很明显他只对[fromIndex, toIndex)区间做了排序。

使用第三个重载：

这个方法是在排序的时候传入数组的同时传入一个比较器，传入比较器有什么用呢？

1. 对于已经实现了Comparable的类（Integer等基础类型的包装类都实现了Comparable接口）来说sort方法会将它们按规则升序排序，如果你想降序排序那么你可以在这里传入一个比较器来实现目的：

public static void main(String[] args) {
        Integer[] array = { 5, 3, 2, 1, 4, 6, 9, 8};
        Arrays.sort(array, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(array));
    }

运行结果：

这里需要注意使用这个重载数组类型不能是int，short等基础数据类型，需要的是他们的包装类。

2. 对于没有实现Comparable的自己的类，可以在使用该重载的时候传入一个Comparator，而不用在回去给自己的类实现Comparable（相信对这两个比较接口不熟悉的同学这会已经晕了，去补博客吧哈哈）

//这是一个没有实现Comparable接口的Ha类
public class Ha {
    int haVal;
    public Ha(int h ){
        haVal = h;
    }

    @Override
    public String toString() {
        return
                "haVal=" + haVal
               ;
    }
}

如果使用这个类去做sort的时候会报错：

public static void main(String[] args) {
        //创建几个Ha类型对象
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        //将上面的对象放到Ha[]数组中
        Ha[] array = {f, d, c, e, b, a};
		//直接排序
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }

传入了一个Comparator就可以了：

 public static void main(String[] args) {
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
       Ha[] array = {f, b, c, d, a};
       Arrays.sort(array, new Comparator<Ha>() {
           @Override
           public int compare(Ha o1, Ha o2) {
               return o1.haVal - o2.haVal;
           }
       });
        System.out.println(Arrays.toString(array));
    }

运行结果：

对于第四个重载：

可以结合第二个和第三个去理解。

Arrays.parallelSort() 是什么 和 Array.sort()有什么区别

与Array.sort()不同的是Arrays.parallelSort() 是并行排序，就是java会将待排序数组分成好几个部分，然后创建好几个线程去对不同的部分同时进行排序最后将各个线程的排序结果归并到一起，听起来好像Arrays.parallelSort() 要比Array.sort()快一些，其实则不然，因为创建线程这个操作会有性能的损耗，如果数据量小的时候再去创建多线程那么速度并没有Array.sort()快，只有当数据量很大的时候用 Arrays.parallelSort()会比 Array.sort()快，那么这个界限是多少呢？Java在实现Arrays.parallelSort()时候做了规定当数据量小于8192的时候即使调用Arrays.parallelSort()，系统还是会选择Array.sort()去做排序。
至于Arrays.parallelSort()方法的重载其实和 Array.sort()都差不多，只是前者背后有了并行排序这个操作。

所以对于Arrays.parallelSort()的这几个重载大家对照这Array.sort()的去理解就好了

用 Collections.sort()进行排序

这个方法是对List进行排序：

要求还是和Arrays.sort()一样，需要List内的元素的实现类实现Comparable接口或者，如第二个重载所示在排序时传入一个Comparator就可了，这里就不做过多赘述了，直接演示：

 //当传入的类实现了Comparable接口时可以直接对list排序
    public static void main(String[] args) {
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        List<Ha> list = new ArrayList<>();
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(a);
        list.add(f);
        list.add(e);
        //默认升序
        Collections.sort(list);
        System.out.println(list);
    }

运行结果：

 public static void main(String[] args) {
        //没有实现Comparable接口的类需要传入Comparator
        Ha a = new Ha(1);
        Ha b = new Ha(2);
        Ha c = new Ha(3);
        Ha d = new Ha(4);
        Ha e = new Ha(5);
        Ha f = new Ha(6);
        List<Ha> list = new ArrayList<>();
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(a);
        list.add(f);
        list.add(e);
        //默认升序
        Collections.sort(list, new Comparator<Ha>() {
            @Override
            public int compare(Ha o1, Ha o2) {
                //返回值是负数说明前者比后者小
                return o1.haVal - o2.haVal;
            }
        });
        System.out.println(list);
    }

运行结果：