Java怎样实现升序降序

数组排序

升序排序

使用 Arrays.sort() 默认实现升序：

import java.util.Arrays;
public class ArraySort {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 9, 1, 3};
        Arrays.sort(numbers); // 默认升序
        System.out.println("升序结果: " + Arrays.toString(numbers)); 
        // 输出: [1, 2, 3, 5, 9]
    }
}

降序排序

结合 Collections.reverseOrder() 实现降序（需转为包装类数组）：

import java.util.Arrays;
import java.util.Collections;
public class ArraySort {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 9, 1, 3}; // 必须用包装类
        Arrays.sort(numbers, Collections.reverseOrder()); // 降序
        System.out.println("降序结果: " + Arrays.toString(numbers)); 
        // 输出: [9, 5, 3, 2, 1]
    }
}

---

集合排序（如ArrayList）

升序排序

使用 Collections.sort() 默认升序：

import java.util.ArrayList;
import java.util.Collections;
public class ListSort {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(2);
        list.add(9);
        Collections.sort(list); // 升序
        System.out.println("升序结果: " + list); // [2, 5, 9]
    }
}

降序排序

通过 Comparator.reverseOrder() 实现：

Collections.sort(list, Comparator.reverseOrder()); // 降序
System.out.println("降序结果: " + list); // [9, 5, 2]

---

自定义对象排序

假设有 Student 类,需按分数排序：

class Student {
    String name;
    int score;
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    @Override
    public String toString() {
        return name + ":" + score;
    }
}

实现 Comparable 接口（自然排序）

class Student implements Comparable<Student> {
    // ... 同上代码 ...
    @Override
    public int compareTo(Student s) {
        return this.score - s.score; // 升序
        // return s.score - this.score; // 降序
    }
}
// 使用示例
ArrayList<Student> students = new ArrayList<>();
students.add(new Student("Alice", 85));
students.add(new Student("Bob", 70));
Collections.sort(students); // 按compareTo()规则排序
System.out.println(students); // 升序输出: [Bob:70, Alice:85]

使用 Comparator 定制排序（更灵活）

// 按分数升序
Comparator<Student> byScoreAsc = Comparator.comparingInt(s -> s.score);
Collections.sort(students, byScoreAsc);
// 按分数降序
Comparator<Student> byScoreDesc = Comparator.comparingInt(Student::getScore).reversed();
Collections.sort(students, byScoreDesc);

---

Java 8+ 新特性

Lambda表达式简化排序

// 升序
students.sort((s1, s2) -> s1.score - s2.score);
// 降序
students.sort((s1, s2) -> s2.score - s1.score);

Stream API排序

import java.util.stream.Collectors;
// 升序
List<Student> sortedAsc = students.stream()
        .sorted(Comparator.comparingInt(s -> s.score))
        .collect(Collectors.toList());
// 降序
List<Student> sortedDesc = students.stream()
        .sorted(Comparator.comparingInt(Student::getScore).reversed())
        .collect(Collectors.toList());

---

关键注意事项

1. 基本类型数组：降序需转为包装类（如 int[] → Integer[]）。
2. 稳定性：Collections.sort() 和 Arrays.sort() 是稳定排序。
3. 性能：时间复杂度为 O(n log n),归并排序实现。
4. 空值处理：若集合含 null，需在Comparator中明确处理逻辑（如 Comparator.nullsLast()）。

---

场景	升序方法	降序方法
基本类型数组	Arrays.sort()	转为包装类 + Arrays.sort(array, Collections.reverseOrder())
集合（List）	Collections.sort(list)	Collections.sort(list, Comparator.reverseOrder())
自定义对象	实现 Comparable 或 Comparator	调用 Comparator.reversed() 或反转比较逻辑
Java 8+ 简化写法	Lambda表达式或 Comparator.comparing()	同上 + .reversed()

通过灵活组合 Comparator 和Lambda表达式，可高效实现各类排序需求，实际开发中推荐使用 Comparator 接口，避免修改原有类的代码,符合开闭原则。

引用说明
本文代码示例基于 Java SE 17 语法规范，参考 Oracle 官方文档：

• Arrays.sort()
• Collections.sort()
• Comparator API