Java篇—Arrays.sort()用法理解

拼搏现实的明天。 2021-11-23 15:50 366阅读 0赞

Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，可以直接调用。

**注：数组类型是Object（），即sort（）的参数类型也为Object。**本文中以int型数组为例。

用法1：

**Arrays.sort(int\[\] a)**

它是对数组的所有元素进行升序排序，即将数组中的元素按照从小到大进行排序。

代码实现：

import java.util.Arrays;
    public class Exercise10 {
        public static void main(String[] args) {
            int[] data = {5,2,0,1,3,1,4};
            Arrays.sort(data);
            for (int temp:data) {
                System.out.print(temp + " ");
            }
            System.out.println();
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70][]

结果说明：output为数组data的升序排序。

用法2：

**Arrays.sort(int\[\] a, int fromIndex, int toIndex)**

它是对数组部分元素进行升序排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序—\[fromIndex,toIndex)

注意：下标为toIndex的元素不参与排序！

代码实现：

import java.util.Arrays;
    public class Exercise10 {
        public static void main(String[] args) {
            int[] data = {5,2,0,1,3,1,4};
            Arrays.sort(data,1,4);
            for (int temp:data) {
                System.out.print(temp + " ");
            }
            System.out.println();
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 1][]

结果说明：output只是把数组data下标为0到3的元素进行了升序排序，由2 0 1变为了0 1 2。

上面的两种用法很容易发现一个问题，那就是数组没有办法进行降序排序，如果想进行降序排序该怎么办呢？

用法3：

**public static void sort(T\[\] a, Comparator c)**

**注：根据指定的比较器引发的顺序对指定的对象数组进行排序**

**public static void sort(T\[\] a,int fromIndex,int toIndex, Comparator c)**

**注：根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序**

代码实现：

import java.util.Arrays;
    import java.util.Comparator;
    public class Exercise10 {
        public static void main(String[] args) {
            //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
            //而要使用它们对应的类
            Integer[] data = {5,2,0,1,3,1,4};
            //new一个MyComparator的对象
            MyComparator myComparator = new MyComparator();
            Arrays.sort(data,myComparator);
            for (int temp:data) {
                System.out.print(temp + " ");
            }
            System.out.println();
        }
    }
    
    class MyComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            //降序
            return o2 - o1;
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 2][]

结果说明：output为数组data的降序排序。

为什么实现了Comparator接口，就能实现降序排序呢？

**实现Comparator接口：升序是前者减去后者（o1 - o2），降序是后者减去前者(o2 - o1)。记住！！！**

实现Comparator接口，升序代码实现如下，作用同用法1

import java.util.Arrays;
    import java.util.Comparator;
    
    /**
     * @author:QJJia
     * @date:2019/7/27 0:40
     * @description:Arrays.sort()用法理解
     */
    public class Exercise10 {
        public static void main(String[] args) {
            //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
            //而要使用它们对应的类
            Integer[] data = {5,2,0,1,3,1,4};
            //new一个MyComparator的对象
            MyComparator myComparator = new MyComparator();
            Arrays.sort(data,myComparator);
            for (int temp:data) {
                System.out.print(temp + " ");
            }
            System.out.println();
        }
    }
    
    class MyComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            //升序
            return o1 - o2;
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 3][]

结果说明：output与用法1相同，都为数组data的升序排序。

用法4：

**lambda表达式实现升序排序（**Arrays.sort(data, (o1, o2) -> o1 - o2);**），**

**lambda表达式实现降序排序（**Arrays.sort(data, (o1, o2) -> o2 - o1);**），**

另一种写法：

需要导入util包下的Comparator类,

**lambda表达式实现升序排序（**Arrays.sort(data1, (o1, o2) -> o1.compareTo(o2);**）**

**lambda表达式实现降序排序（**Arrays.sort(data2, (o1, o2) -> o2.compareTo(o1));**）**

代码实现：

import java.util.Arrays;
    import java.util.Comparator;
    public class Exercise10 {
        public static void main(String[] args) {
            Integer[] data1 = {5,2,0,1,3,1,4};
            Integer[] data2 = {5,2,0,1,3,1,4};
            //升序排序，写法1
            Arrays.sort(data1, (o1, o2) -> o1 - o2);
            //写法2
            //Arrays.sort(data1, (o1, o2) -> o1.compareTo(o2));
            //降序排序，写法1
            //Arrays.sort(data2, (o1, o2) -> o2 - o1);
            //写法2
            Arrays.sort(data2, (o1, o2) -> o2.compareTo(o1));
            System.out.println("lambda表达式实现升序排序：");
            System.out.println(Arrays.toString(data1));
            System.out.println("lambda表达式实现降序排序：");
            System.out.println(Arrays.toString(data2));
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 4][]

结果说明：output升序同用法1，用法3，output降序同用法3

lambda表达式详解：

[https://www.cnblogs.com/knowledgesea/p/3163725.html][https_www.cnblogs.com_knowledgesea_p_3163725.html]

Arrays.sort()的深入理解：

[Arrays.sort() ----- DualPivotQuicksort][Arrays.sort_ ----- DualPivotQuicksort]：[https://www.cnblogs.com/wuweishuo/p/10648039.html][Arrays.sort_ ----- DualPivotQuicksort]

[Arrays.sort() ----- TimSort][Arrays.sort_ ----- TimSort]：[https://www.cnblogs.com/wuweishuo/p/10646045.html][Arrays.sort_ ----- TimSort]

**心灵鸡汤：将来的你一定会感谢现在拼命的自己！**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70]: /images/20211122/a28a53ce643846c49c011130a530fdf7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 1]: /images/20211122/f49d55c4578f4cb38bf4be473d988a66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 2]: /images/20211122/b548570b7fe34518b40cda3edc91474f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 3]: /images/20211122/5ed132f1efb94bf1844e645fb582b9e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2MTY1OQ_size_16_color_FFFFFF_t_70 4]: /images/20211122/2575c96ddf4f430c8aa396b897d76869.png
[https_www.cnblogs.com_knowledgesea_p_3163725.html]: https://www.cnblogs.com/knowledgesea/p/3163725.html
[Arrays.sort_ ----- DualPivotQuicksort]: https://www.cnblogs.com/wuweishuo/p/10648039.html
[Arrays.sort_ ----- TimSort]: https://www.cnblogs.com/wuweishuo/p/10646045.html