Java中用于对对象的数组或列表进行排序

假如我们现在有以下需求：

从键盘录入5个学生的数据，保存到容器对象ar中，然后按照成绩score从高到低排序之后输出。

我们先看代码：

import java.util.*;

class Student {
    String number;
    String name;
    float score;

    Student(String number1, String name1, float score1) {
        number = number1;
        name = name1;
        score = score1;
    }

    public String toString() {
        return this.number + " " + this.name + " " + this.score;
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> ar = new ArrayList<Student>();

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 5; i++) {
            String number = sc.next();
            String name = sc.next();
            float score = sc.nextFloat();
            ar.add(new Student(number, name, score));
        }

        Collections.sort(ar, new Comparator<Student>() {
            public int compare(Student s1, Student s2) {
                if (s1.score < s2.score) {
                    return 1;
                } else if (s1.score > s2.score) {
                    return -1;
                }
                return 0;
            }
        });

        for (Student student : ar) {
            System.out.println(student);
        }
    }
}

 

 重点分析：

Collections.sort(ar, new Comparator<Student>() {
    public int compare(Student s1, Student s2) {
        if (s1.score < s2.score) {
            return 1;
        } else if (s1.score > s2.score) {
            return -1;
        }
        return 0;
    }
});

1. Collections.sort(ar, ...)：这是Collections类的一个静态方法，用于对指定列表中的元素进行排序。sort方法接受两个参数：要排序的列表（这里是ar）和一个比较器（Comparator），用于定义列表中元素的排序顺序。

2. new Comparator<Student>() {...}：这是一个匿名内部类，它实现了Comparator接口。Comparator接口用于定义对象比较的规则。在这个匿名内部类中，我们定义了如何比较两个Student对象。

3. public int compare(Student s1, Student s2)：这是Comparator接口中的唯一方法，用于比较两个对象。这个方法应该返回一个整数：

   • 如果s1应该排在s2之前，返回一个小于0的值。
   • 如果s1和s2相等，返回0。
   • 如果s1应该排在s2之后，返回一个大于0的值。

 在实际应用中，你也可以使用Java 8及以上版本的lambda表达式来简化这段代码，如下所示：

Collections.sort(ar, (s1, s2) -> {
            if (s1.score < s2.score) {
                return -1;
            } else if (s1.score > s2.score) {
                return 1;
            }
            return 0;
        });

 

 或者更简洁地：

Collections.sort(ar, (s1, s2) -> Float.compare(s2.score, s1.score));

现在，我会详细解释这段代码的每一部分：

1. Collections.sort(ar, ...)

   • Collections.sort是Java Collections类的一个静态方法，用于对列表进行排序。
   • 第一个参数ar是要排序的列表。
   • 第二个参数是一个Comparator对象，它定义了排序的规则。在这个例子中，我们使用了一个lambda表达式来创建这个Comparator。

2. Lambda表达式

   • (s1, s2) -> Float.compare(s2.score, s1.score) 是一个lambda表达式，它定义了一个函数，该函数接受两个Student类型的参数s1和s2，并返回一个整数，用于表示s1和s2的相对顺序。

3. Lambda表达式的主体

   Float.compare(s2.score, s1.score)
   • 如果s2.score等于s1.score，Float.compare会返回0，表示s1和s2的相对顺序没有区别。
   • 如果s2.score小于s1.score，Float.compare会返回一个负数，表示s1应该排在s2前面（在降序排序中，这意味着s1在列表中的位置更靠后）。
   • 如果s2.score大于s1.score，Float.compare会返回一个正数，表示在排序后的列表中s2应该排在s1前面（虽然是降序排序，但这里的“前面”指的是在列表中的位置更靠后）。
   • 第一个参数是s2的score属性值，第二个参数是s1的score属性值。注意这里参数的顺序与常规的升序排序不同，这是因为我们想要实现降序排序。
   • 这里调用了Float类的compare静态方法，用于比较两个浮点数。

整个lambda表达式定义了一个比较器，它告诉Collections.sort方法如何根据Student对象的score属性对列表进行降序排序。当Collections.sort方法遍历列表时，它会使用这个比较器来确定列表中每个元素的顺序，并最终得到一个按score属性降序排列的列表。

需要注意的是，为了这段代码能够正常工作，Student类必须有一个名为score的浮点数类型的公共字段（或有一个公共的getter方法，但在这个lambda表达式中我们直接访问了字段），并且这个字段或getter方法是用来获取score属性的值的。如果score是一个私有字段，并且没有提供公共的getter方法，那么这段代码将无法编译通过。