该方法是Arrays类的静态方法,用于对数组进行排序,时间复杂度O(n*logn),方法返回值为void。排序后,数组中存放的是排序后的结果。由于该方法是在原来数组的空间基础上进行升序排序,因此不需要定义一个数组接收它,即不需要返回值。


Arrays.sort()重载了四类方法:

1.sort(T[] a)

对指定T型数组按数字升序排序,例如:

1
2
3
4
5
6
7
8
9
import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[] a = {2,5,1,8,12};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

运行结果如下:

1
[125812]

2.sort(T[] a,int formIndex,int toIndex)

对指定T型数组的指定范围按数字升序排序,例如:

1
2
3
4
5
6
7
8
9
import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[] a = {8,2,15,4,7,1};
        Arrays.sort(a,1,5);
        System.out.println(Arrays.toString(a));
    }
}

运行结果如下:

1
[8247151]

3.sort(T[] a,Comparator<? supre T> c)

根据指定比较器产生的顺序对T型数组进行排序。

(1)按第一维元素比较二维数组:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[][] nums = new int[][]{{1,3},{5,7},{9,5},{7,3}};
        Arrays.sort(nums,new Comparator<int[]>() {
            public int compare(int[] a,int[] b) {
                if(a[0]==b[0]) {
                    return a[1]-b[1];
                }else{
                    return a[0]-b[0];
                }
            }
        });
        for(int[] num : nums)
            System.out.println(Arrays.toString(num));
        int[] a = {8,2,15,4,7,1};
        Arrays.sort(a,1,5);
        System.out.println(Arrays.toString(a));
    }
}

运行结果如下:

1
2
3
4
5
[13]
[57]
[73]
[95]
[8247151]

(2)按第二维元素比较二维数组:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[][] nums = new int[][]{{1,3},{5,7},{9,5},{7,3}};
        Arrays.sort(nums,new Comparator<int[]>() {
            public int compare(int[] a,int[] b) {
                if(a[1]==b[1]) {
                    return a[0]-b[0];
                }else{
                    return a[1]-b[1];
                }
            }
        });
        for(int[] num : nums)
            System.out.println(Arrays.toString(num));
    }
}

运行结果如下:

1
2
3
4
[13]
[73]
[95]
[57]

4.sort(T[] a,int formIndex,int toIndex,Comparator<? supre T> c)

根据指定比较器产生的顺序对T型数组的指定范围进行排序,例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[][] nums=new int[][]{{9,5},{7,3},{5,7},{1,3}};
        Arrays.sort(nums,1,4,new Comparator<int[]>() {
            public int compare(int[] a,int[] b) {
                if(a[0]==b[0]){
                    return a[1]-b[1];
                else {
                    return a[0]-b[0];
                }
            }
        });
        for(int[] num : nums)
            System.out.println(Arrays.toString(num));
    }
}

运行结果如下:

1
2
3
4
[95]
[13]
[57]
[73]


点赞(202)

C语言网提供由在职研发工程师或ACM蓝桥杯竞赛优秀选手录制的视频教程,并配有习题和答疑,点击了解:

一点编程也不会写的:零基础C语言学练课程

解决困扰你多年的C语言疑难杂症特性的C语言进阶课程

从零到写出一个爬虫的Python编程课程

只会语法写不出代码?手把手带你写100个编程真题的编程百练课程

信息学奥赛或C++选手的 必学C++课程

蓝桥杯ACM、信息学奥赛的必学课程:算法竞赛课入门课程

手把手讲解近五年真题的蓝桥杯辅导课程

Dotcpp在线编译      (登录可减少运行等待时间)
#include<stdio.h>
int main()
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX