java中的Arrays.sort()的几种用法

直奔主题

Arrays.sort()有三种用法

1.第一种

Arrays.sort(int [] a)
查看源码

 public static void sort(int[] a) {
        DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }
1
2
3

即对一个数组的所有元素进行排序
而且排序的时候是从小到大
所以在使用的时候则为

public class text1
{
    public static void main(String []args)
    {
        int[] a=new int[]{10,1,6,8,4,5};

        System.out.println("默认排序是从小到大");
        Arrays.sort(a);
        for (int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+" ,");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出的结果为：

---

2.第二种方法

Arrays.sort(int[] a, int fromIndex, int toIndex)
查看源码

 public static void sort(int[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
    }

1
2
3
4
5

使用规则则为从fromIndex<=a数组<toIndex

public class text1
{
    public static void main(String []args)
    {
        int[] a=new int[]{10,1,6,8,4,5};

        System.out.println("从1到4的排序，也就是1到3的排序");
        Arrays.sort(a,1,4);
        for (int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+" ,");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出结果为

---

3.第三种方法

public static <T> void sort(T[] a,int fromIndex, int toIndex,  Comparator<? super T> c)
1

可以实现降序排序
错误用法：
要实现减序排序，得通过包装类型数组，基本类型数组是不行滴

public class text1
{
    public static void main(String []args)
    {
        int [] a=new int[]{1,6,8,4};
        Arrays.sort(a, Collections.reverseOrder());
        for (int b:a)
        {
            System.out.print(b+" ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

正确用法：
用java自带的函数Collections.reverseOrder（）

public class text1
{
    public static void main(String []args)
    {
        Integer[] integers=new Integer[]{2,324,4,4,6,1};
        Arrays.sort(integers, Collections.reverseOrder());
        for (Integer integer:integers)
        {
            System.out.print(integer+" ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

或者是使用自定义的排序方法，自定义排序方法需要实现java.util.Comparetor接口中的compare方法

int compare(Object obj1, Object obj2);
1

public class text1
{
    public static void main(String []args)
    {
        Integer[] integers=new Integer[]{2,324,4,4,6,1};
        Arrays.sort(integers, new Comparator<Integer>() {

            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        for (Integer integer:integers)
        {
            System.out.print(integer+" ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果为：

关于自定义排序的补充：
Arrays.sort(int[],Comparator)这个api，需要返回一个int类型的值，一般会直接使用两数相减来直接得出这两个数的相对顺序，如果大数据的时候会溢出

Arrays.sort(points,new Comparator<int []>(){
            public int compare(int[] points1,int []points2){
                return points1[1]-points2[1];
            }
        });
1
2
3
4
5

具体可参考这道题：
leetcode：452. 用最少数量的箭引爆气球

具体使用下标0还是下标1排序，主要看用的左边界排序还是右边界排序

正确的格式防止溢出可看以下：
为此可使用三目运算符

Arrays.sort(points,new Comparator<int []>(){
            public int compare(int[] points1,int []points2){
                if(points1[1]>points2[1])return 1;
                else if(points1[1]<points2[1])return -1;
                else return 0;
            }
        });

//或者lambda表达式
Arrays.sort(points, (p1, p2) -> p1[1] < p2[1] ? -1 : 1);
1
2
3
4
5
6
7
8
9
10

或者使用如下：Integer.compare(int,int)

Arrays.sort(points,(o1,o2)->Integer.compare(o1[1],o2[1]));
1

---

4.额外补充 for each的语法结构

for(元素类型t 元素变量x : 遍历对象obj){
引用了x的java语句;
}
1
2
3