Java 中的排序（Sorted in Java）

简介

在 Java 编程中，排序是一项非常常见且重要的操作。无论是对数组元素进行排序，还是对集合中的元素进行排序，都有多种方式可以实现。理解并掌握 sorted 在 Java 中的使用，能够极大地提升数据处理和算法实现的效率。本文将深入探讨 sorted 在 Java 中的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地运用这一特性。

目录

1. 基础概念
2. 使用方法
   • 数组排序
   • 集合排序
3. 常见实践
   • 自定义对象排序
   • 多条件排序
4. 最佳实践
   • 性能优化
   • 代码可读性优化
5. 小结
6. 参考资料

基础概念

在 Java 中，排序是将一组数据按照特定的顺序（如升序或降序）进行排列的操作。sorted 并非 Java 中的一个特定关键字，而是与排序相关的方法和功能的统称。

Java 提供了多种排序算法的实现，最常用的是快速排序（Quick Sort）和归并排序（Merge Sort）。不同的排序算法在时间复杂度、空间复杂度和稳定性上有所差异。例如，快速排序平均时间复杂度为 $O(n log n)$，空间复杂度为 $O(log n)$，但它是不稳定的排序算法；而归并排序时间复杂度始终为 $O(n log n)$，空间复杂度为 $O(n)$，是稳定的排序算法。

使用方法

数组排序

Java 标准库中的 Arrays 类提供了排序方法，可以对基本数据类型数组和对象数组进行排序。

基本数据类型数组排序

import java.util.Arrays;

public class ArraySortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9};
        Arrays.sort(numbers);
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

上述代码使用 Arrays.sort 方法对 int 类型数组进行排序，默认是升序排序。输出结果为：1 2 5 8 9。

对象数组排序

对于对象数组，对象必须实现 Comparable 接口，该接口定义了 compareTo 方法，用于定义对象之间的比较规则。

import java.util.Arrays;

class Person implements Comparable<Person> {
    private String name;
    private int age;

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

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ObjectArraySortExample {
    public static void main(String[] args) {
        Person[] people = {
                new Person("Alice", 25),
                new Person("Bob", 20),
                new Person("Charlie", 30)
        };
        Arrays.sort(people);
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

在上述代码中，Person 类实现了 Comparable 接口，compareTo 方法按照年龄对 Person 对象进行升序排序。输出结果为：

Person{name='Bob', age=20}
Person{name='Alice', age=25}
Person{name='Charlie', age=30}

集合排序

Java 中的集合框架（如 List）也提供了排序方法。

使用 Collections.sort 对 List 排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListSortExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);
        numbers.add(9);
        Collections.sort(numbers);
        System.out.println(numbers);
    }
}

上述代码使用 Collections.sort 方法对 List<Integer> 进行排序，输出结果为：[1, 2, 5, 8, 9]。

使用流（Stream）对集合排序

Java 8 引入的流（Stream）API 也可以对集合进行排序。

import java.util.ArrayList;
import java.util.List;

public class StreamSortExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);
        numbers.add(9);
        List<Integer> sortedNumbers = numbers.stream()
              .sorted()
              .toList();
        System.out.println(sortedNumbers);
    }
}

上述代码使用流的 sorted 方法对 List<Integer> 进行排序，输出结果与上例相同。

常见实践

自定义对象排序

在实际应用中，常常需要对自定义对象进行排序，并且排序规则可能不止一种。除了实现 Comparable 接口，还可以使用 Comparator 接口来定义不同的比较规则。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Person {
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.age - p2.age;
    }
}

class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.name.compareTo(p2.name);
    }
}

public class CustomObjectSortExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 20));
        people.add(new Person("Charlie", 30));

        Collections.sort(people, new AgeComparator());
        System.out.println("Sorted by age: " + people);

        Collections.sort(people, new NameComparator());
        System.out.println("Sorted by name: " + people);
    }
}

在上述代码中，定义了两个实现 Comparator 接口的类 AgeComparator 和 NameComparator，分别按照年龄和名字对 Person 对象进行排序。

多条件排序

有时候需要根据多个条件对对象进行排序。可以通过组合多个 Comparator 来实现。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Student {
    private String name;
    private int age;
    private double gpa;

    public Student(String name, int age, double gpa) {
        this.name = name;
        this.age = age;
        this.gpa = gpa;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gpa=" + gpa +
                '}';
    }
}

public class MultiConditionSortExample {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20, 3.5));
        students.add(new Student("Bob", 21, 3.2));
        students.add(new Student("Alice", 20, 3.8));

        Comparator<Student> multiComparator = Comparator.comparing(Student::getName)
              .thenComparingInt(Student::getAge)
              .thenComparingDouble(Student::getGpa);

        Collections.sort(students, multiComparator);
        System.out.println(students);
    }
}

上述代码中，Comparator.comparing 方法首先按照名字排序，thenComparingInt 方法在名字相同的情况下按照年龄排序，thenComparingDouble 方法在名字和年龄都相同的情况下按照 GPA 排序。

最佳实践

性能优化

• 选择合适的排序算法：根据数据规模和特性选择合适的排序算法。对于小规模数据，插入排序（Insertion Sort）可能更高效；对于大规模数据，快速排序或归并排序通常是更好的选择。
• 避免不必要的排序：在某些情况下，可以通过数据结构的设计或算法优化来避免对数据进行排序，从而提高性能。

代码可读性优化

• 使用清晰的比较器命名：在定义 Comparator 时，使用清晰、描述性的类名，以便代码易于理解。
• 利用方法引用和 Lambda 表达式：在 Java 8 及以上版本中，利用方法引用和 Lambda 表达式可以使排序代码更加简洁和易读。例如：

List<Person> people = new ArrayList<>();
// 添加元素
people.sort(Comparator.comparing(Person::getAge));

小结

本文全面介绍了 sorted 在 Java 中的相关知识，包括基础概念、使用方法、常见实践以及最佳实践。通过对数组和集合排序方法的学习，以及自定义对象和多条件排序的实践，读者能够更好地掌握在不同场景下进行排序的技巧。同时，遵循最佳实践原则可以进一步提升代码的性能和可读性。

参考资料

• Oracle Java Documentation
• 《Effective Java》by Joshua Bloch
• Baeldung - Java Sorting Tutorial