11-1-1 按照成绩对学生进行排序

题干

按照成绩对学生进行排序。

要求： 1) 编写学生类Student，成员变量包括姓名和成绩；

2) Student实现Comparable<E>接口；

3) 编写测试类，创建Student数组,数组长度为3，由用户输入3个学生的信息，调用java.util.Arrays的静态方法sort()，按照成绩进行排序，并输出学生的信息。

【试题输入输出】

程序的输入输出格式如下：

代码如下

import java.util.Arrays;
import java.util.Scanner;

class Student implements Comparable<Student> {
    private String name;
    private int  score;

    public Student(String name, int  score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

    @Override
    public int compareTo(Student student) {
        return Double.compare(this.score, student.getScore());
    }

    @Override
    public String toString() {
        return "\n姓名：" + name + "\n成绩：" + score;
    }
}

public class TestStudent {
    public static void main(String[] args) {
        Student[] students = createStudentArray();
        Arrays.sort(students);
        printStudentArray(students);
    }

    public static Student[] createStudentArray() {
        Student[] students = new Student[3];
        Scanner input = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
             String name = input.next();
             int score = input.nextInt();
            students[i] = new Student(name, score);
        }
        input.close();
        return students;
    }

    public static void printStudentArray(Student[] students) {
         for (Student student : students) {
            System.out.println(student);
        }
    }
}

总结

Comparable

Comparable 是 Java 中的一个接口，它属于 java.lang 包，因此在使用时不需要显式地导入。这个接口主要用于定义对象的自然排序和比较规则。当一个类实现了 Comparable 接口，它就承诺提供了一种方法来确定该类的实例与其他实例之间的相对顺序。

Comparable 接口只定义了一个方法：

public interface Comparable<T> { public int compareTo(T o); }

• T 是一个类型参数，代表 compareTo 方法要比较的对象的类型。使用类型参数允许 Comparable 接口与各种类型的对象一起工作。

compareTo 方法的实现应该遵循以下规则：

• 如果调用对象应该排在参数对象之前，返回一个负整数。
• 如果调用对象和参数对象相等，返回 0。
• 如果调用对象应该排在参数对象之后，返回一个正整数。

这个接口通常用于：

1. 排序：实现 Comparable 接口的对象可以被 Collections.sort() 或者 Arrays.sort() 方法直接排序，因为这些方法需要对象有一个自然的排序顺序。

2. 搜索和检索：在一些数据结构中，如二叉搜索树，对象的自然顺序可以用于快速搜索和检索。

3. 流操作：在 Java 8 引入的 Stream API 中，对象的自然排序顺序可以用于排序流中的元素。

示例：

public class Person implements Comparable<Person> {

private String name;

private int age;

public Person(String name, int age) { this.name = name; this.age = age; }

// compareTo 方法根据年龄排序 @Override

public int compareTo(Person other)

{ return Integer.compare(this.age, other.age); }

// Getters and setters public String getName() { return name; }

public int getAge() { return age; } }

在这个例子中，Person 类实现了 Comparable<Person> 接口，并且定义了 compareTo 方法，该方法根据 Person 对象的年龄进行比较。这意味着如果使用 Collections.sort 方法对 Person 对象的列表进行排序，列表将按照年龄升序排列。

---

Arrays.sort(students);

Arrays.sort(students); 是 Java 中的一个方法调用，它使用 java.util.Arrays 类中的 sort 方法对一个对象数组进行排序。这个方法可以对实现了 Comparable 接口的对象数组或者使用 Comparator 对象的数组进行排序。

在您提供的上下文中，students 是 Student 对象的数组。由于 Student 类实现了 Comparable<Student> 接口，并且提供了 compareTo 方法的实现，Arrays.sort 方法可以根据 Student 对象的自然排序顺序（在这个例子中，是按照成绩排序）对 students 数组进行排序。

Arrays.sort 方法有多个重载版本，可以用于不同的排序需求：

1. 对基本类型数组排序：如 int、double 等。

   int[] numbers = {5, 3, 2, 4, 1}; Arrays.sort(numbers); // 对整型数组进行排序

2. 对对象数组排序：当对象实现了 Comparable 接口。

   Student[] students = { ... }; Arrays.sort(students); // 对Student对象数组进行排序

3. 对对象数组使用自定义的比较器排序：当需要自定义排序规则时，可以使用 Comparator。

   Arrays.sort(students, new Comparator<Student>() { public int compare(Student s1, Student s2) { return s1.getName().compareTo(s2.getName()); // 按名字排序 } });

4. 对部分数组排序：可以指定数组的一部分进行排序。

   int[] numbers = {5, 3, 2, 4, 1}; Arrays.sort(numbers, 1, 4); // 从索引1开始到索引4（不包括）的子数组排序

当调用 Arrays.sort(students); 时，如果没有提供自定义的比较器，排序将遵循 Student 类中 compareTo 方法定义的规则。在前面提供的 Student 类实现中，compareTo 方法是基于学生的成绩进行排序的。因此，调用 Arrays.sort(students); 将根据学生的成绩对 students 数组进行升序排序。

---

增强型for循环

在这个循环中，students是一个集合（比如List或者数组），而Student是集合元素的类型。这个循环的作用是遍历集合中的每一个元素，并将每个元素赋值给student这个变量，然后执行相应的操作。

换句话说，这个for循环的意思是：对于students集合中的每一个元素，将其赋值给student变量，并执行循环体内的操作。