sort方法用于对数组的元素进行排序。排序顺序可以是字母或数字，并按升序或降序。默认排序顺序为按字母升序，当数字是按字母顺序排列时"40"将排在"5"前面。使用数字排序，你必须通过一个函数作为参数来调用。这些说起来可能很难理解，你可以通过本篇文章进一步了解它

−

目录

引言

在学习Java过程中，排序sort是我们常用的功能；在Java里，数组有Arrays.sort()可以排序，集合则是Collections.sort()方法排序；默认情况下是升序排列，但是降序又该怎么排？又可以通过哪几种方法呢？自定义类型又该怎么做？

下面就来介绍一下sort方法的使用；

升序

升序是默认情况下的，所以这里就简单展示一下使用的方法；

数组

数组的sort方法位于Arrays工具类下
代码如下：

1

2

3

4

5

6

7

8

9

10

11

import java.util.Arrays;

public class SortTest01 {

    public static void main(String[] args) {

        int[] array = {2, 4, 8, 9, 78, 1, 3, 66}; // 整型数组

        Arrays.sort(array); // 升序排序

        for (int i : array) {

            System.out.print(i + " ");

        }

    }

}

结果如下：

1 2 3 4 8 9 66 78

集合

集合的sort方法位于Collections类下
代码如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

public class SortTest02 {

    public static void main(String[] args) {

        List<Integer> list = new LinkedList<>(); // 定义一个链表

        // 降序放入list

        for (int i = 10; i >= 0; --i) {

            list.add(i);

        }

        Collections.sort(list); // 升序排序

        for (var i : list) {

            System.out.print(i + " ");

        }

    }

}

结果如下：

0 1 2 3 4 5 6 7 8 9 10

降序

降序就需要一点额外的步骤；这里就需要用到一个接口：Comparator<T>

其实实际上我们用到的只是Comparator<T> 接口中的一个方法，也是这个接口唯一的方法：int compare(T o1, T o2)；
sort方法默认情况下是升序，但是它的一个重载版本可以额外放一个Comparator<T>的参数，作为一个比较器
可以看看Collections的sort方法：

在这里插入图片描述

还有Arrays里的sort方法

在这里插入图片描述

可以看到它们都Comparator<T>参数，所以我们只需要在这里制定指定的规则，就可以按照我们的方式进行排序；

所以接下来的问题就是如何实现Comparator<T> 接口并重写int compare(T o1, T o2)方法了，这里我提供三种方法：

下面就只用集合来作为例子；

声明一个类实现接口

代码如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedList;

import java.util.List;

public class SortTest03 {

    public static void main(String[] args) {

        List<Integer> list = new LinkedList<>(); // 定义一个链表

        // 升序放入list

        for (int i = 0; i <= 10; ++i) {

            list.add(i);

        }

        Collections.sort(list, new MyCompare()); // 降序排序

        for (var i : list) {

            System.out.print(i + " ");

        }

    }

}

class MyCompare implements Comparator<Integer> {

    // 制定排序规则：降序

    @Override

    public int compare(Integer o1, Integer o2) {

        return o2 - o1;

    }

}

结果如下：

10 9 8 7 6 5 4 3 2 1 0

匿名内部类实现接口

代码如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedList;

import java.util.List;

public class SortTest04 {

    public static void main(String[] args) {

        List<Integer> list = new LinkedList<>(); // 定义一个链表

        // 升序放入list

        for (int i = 0; i <= 10; ++i) {

            list.add(i);

        }

        // 匿名内部类降序排序

        Collections.sort(list, new Comparator<Integer>() {

            @Override

            public int compare(Integer o1, Integer o2) {

                return o2 - o1;

            }

        });

        for (var i : list) {

            System.out.print(i + " ");

        }

    }

}

结果如下：

10 9 8 7 6 5 4 3 2 1 0

Lambda表达式实现接口

代码如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

public class SortTest04 {

    public static void main(String[] args) {

        List<Integer> list = new LinkedList<>(); // 定义一个链表

        // 升序放入list

        for (int i = 0; i <= 10; ++i) {

            list.add(i);

        }

        // Lambda表达式降序排序

        Collections.sort(list, (o1, o2) -> o2 - o1);

        for (var i : list) {

            System.out.print(i + " ");

        }

    }

}

结果如下：

10 9 8 7 6 5 4 3 2 1 0

这三种方法还是需要根据实际情况使用的，假如这个排序规则需要多次使用，还是单独创建一个类实现比较好；
如果只是使用一次，那么就用匿名内部类或者Lambda表达式，相对而言Lambda表达式更简单；

自定义数据类型的排序

如果想要对自己定义的类实例化的对象进行排序，那么同样需要Comparator<T> 去指定排序的规则；
下面例子通过创建一个类的方式来实现接口；

代码如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedList;

import java.util.List;

public class SortTest05 {

    public static void main(String[] args) {

        List<Student> list = new LinkedList<>(); // 创建一个链表

        list.add(new Student(18, "202101", "张三"));

        list.add(new Student(28, "202180", "李四"));

        list.add(new Student(11, "202135", "王五"));

        list.add(new Student(18, "202169", "赵六"));

        list.add(new Student(11, "202122", "小七"));

        list.add(new Student(48, "202156", "碧萝"));

        // 排序前

        for (var i : list) {

            System.out.println("name:" + i.getName() + " age:" + i.getAge() + " ID:" + i.getID());

        }

        Collections.sort(list, new StuCompare()); // 自定义排序规则排序

        // 排序后

        System.out.println("=======================");

        for (var i : list) {

            System.out.println("name:" + i.getName() + " age:" + i.getAge() + " ID:" + i.getID());

        }

    }

}

// 学生类

class Student {

    private int age; // 年龄

    private String ID; // 学号

    private String name; // 姓名

    public Student() {

    }

    public Student(int age, String ID, String name) {

        this.age = age;

        this.ID = ID;

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getID() {

        return ID;

    }

    public void setID(String ID) {

        this.ID = ID;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

// 学生排序类

class StuCompare implements Comparator<Student> {

    // 升序

    @Override

    public int compare(Student o1, Student o2) {

        int flag;

        // 先通过年龄排序

        flag = o1.getAge() - o2.getAge();

        // 如果年龄相同，则通过学号比较排序

        if (flag == 0) {

            flag = o1.getID().compareTo(o2.getID());

        }

        return flag;

    }

}

结果如下：

name:张三 age:18 ID:202101
name:李四 age:28 ID:202180
name:王五 age:11 ID:202135
name:赵六 age:18 ID:202169
name:小七 age:11 ID:202122
name:碧萝 age:48 ID:202156
=======================
name:小七 age:11 ID:202122
name:王五 age:11 ID:202135
name:张三 age:18 ID:202101
name:赵六 age:18 ID:202169
name:李四 age:28 ID:202180
name:碧萝 age:48 ID:202156

可以看出来我们可以自己定义自定义类型的排序规则，非常简单；
这里我使用一个类实现了Comparator<T> ，匿名内部类和Lambda表达式也可以；但是还是一样，如果经常需要排序还是推荐定义一排序类，这样用起来更方便；

总结：

需要掌握的就是两点：

  • sort基本方法使用
  • Comparator<T> 接口的使用（这里注意一下：不要和Comparable<T>弄混）

sort还是挺实用的，希望这篇文章能够让你真正学会使用sort方法！

# java # windows # 开发语言
Logo
GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

【目标检测】目标检测的一些常用神经网络模型及方法

我的阶段性总结????文章目录1.概述1.2 目标检测的任务1.3 目标检测的分类2.R-CNN系列2.1 [R-CNN（Region with CNN features）](https://arxiv.org/pdf/1311.2524.pdf)2.2 [Fast R-CNN](https://www.cv-foundation.org/openaccess/content_iccv_2015/

avatar GitCode 开源社区
cover

用C++实现4种YOLO目标检测（内附完整代码）

avatar GitCode 开源社区
cover

静态时序分析：SDC约束命令create_generated_clock详解（上）

avatar GitCode 开源社区