当前位置：首页 > 后端开发 > 正文

Java怎样实现升序降序

admin
后端开发
2025-06-09
4844

Java中通过 Collections.sort()和 Comparator实现升序降序：，升序用默认排序或 Comparator.naturalOrder()；，降序用 Collections.reverseOrder()或自定义比较器反转逻辑，数组排序可先用 Arrays.sort()升序，再反转数组实现降序。

数组排序

升序排序

使用 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() 实现降序（需转为包装类数组）：

Java怎样实现升序降序第1张

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());

关键注意事项

基本类型数组：降序需转为包装类（如 int[] → Integer[]）。
稳定性：Collections.sort() 和 Arrays.sort() 是稳定排序。
性能：时间复杂度为 O(n log n),归并排序实现。
空值处理：若集合含 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()`