深入浅出Java排序：从基础算法到实战优化(下)

文章目录

- - 一、核心概念与底层实现
  - 二、常用.sort方法用法
  - - [1. Arrays.sort()（数组排序）](#1. Arrays.sort()（数组排序）)
    - [2. Collections.sort()（List集合排序）](#2. Collections.sort()（List集合排序）)
  - 三、关键注意事项
  - 总结

书接上回,在从基础算法到实战优化上咱们较为详细的讨论了数据结构中常见的八大排序.今天咱们来介绍一下java自带的.sort方法.

一、核心概念与底层实现

Java的排序方法遵循最佳实践，底层根据数据类型做了优化：

对int、long等基本类型数组 ：使用双轴快速排序（Dual-Pivot QuickSort），效率更高（时间复杂度O(n log n)）。
对String、自定义对象等引用类型 ：使用TimSort（归并排序+插入排序的混合算法），稳定且高效。

二、常用.sort方法用法

1. Arrays.sort()（数组排序）

适用于所有数组类型（基本类型、引用类型），默认升序排列。

示例1：基本类型数组排序（int数组）

java 复制代码

import java.util.Arrays;

public class SortDemo {
    public static void main(String[] args) {
        // 定义无序int数组
        int[] nums = {5, 2, 9, 1, 5, 6};
        
        // 核心：数组排序（原地排序，直接修改原数组）
        Arrays.sort(nums);
        
        // 输出结果：[1, 2, 5, 5, 6, 9]
        System.out.println(Arrays.toString(nums));
    }
}

示例2：自定义对象数组排序（实现Comparable）

如果要排序自定义对象，需让对象类实现Comparable接口，重写compareTo方法定义"自然排序规则"。

java 复制代码

import java.util.Arrays;

// 自定义User类，实现Comparable接口
class User implements Comparable<User> {
    private String name;
    private int age;

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

    // 定义排序规则：按年龄升序（this.age - o.age），降序则反过来
    @Override
    public int compareTo(User o) {
        return this.age - o.age;
    }

    // 重写toString，方便打印
    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + "}";
    }
}

public class ObjectSortDemo {
    public static void main(String[] args) {
        User[] users = {
            new User("张三", 25),
            new User("李四", 20),
            new User("王五", 30)
        };
        
        // 排序自定义对象数组
        Arrays.sort(users);
        
        // 输出结果：按年龄升序排列
        // [User{name='李四', age=20}, User{name='张三', age=25}, User{name='王五', age=30}]
        System.out.println(Arrays.toString(users));
    }
}

示例3：自定义排序规则（Comparator）

如果不想修改对象类（比如第三方类），或需要临时自定义排序规则，可使用带Comparator的重载方法：

java 复制代码

import java.util.Arrays;
import java.util.Comparator;

public class ComparatorSortDemo {
    public static void main(String[] args) {
        String[] strs = {"apple", "Banana", "cherry", "date"};
        
        // 按字符串长度降序排序（忽略大小写）
        Arrays.sort(strs, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                // 降序：s2长度 - s1长度
                int lenCompare = s2.length() - s1.length();
                // 长度相同则按字母序（忽略大小写）
                return lenCompare != 0 ? lenCompare : s1.compareToIgnoreCase(s2);
            }
        });
        
        // 输出：[cherry, Banana, apple, date]
        System.out.println(Arrays.toString(strs));
    }
}

2. Collections.sort()（List集合排序）

专门用于List接口的实现类（如ArrayList、LinkedList），用法和Arrays.sort()类似，默认升序。

示例：List集合排序（Lambda简化Comparator）

Java 8+支持Lambda表达式，可简化Comparator的写法：

java 复制代码

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

public class ListSortDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(8);
        list.add(2);
        list.add(7);
        list.add(1);
        
        // 方式1：默认升序
        Collections.sort(list);
        System.out.println("升序：" + list); // [1, 2, 7, 8]
        
        // 方式2：Lambda自定义降序
        Collections.sort(list, (a, b) -> b - a);
        System.out.println("降序：" + list); // [8, 7, 2, 1]
    }
}

三、关键注意事项

Arrays.sort()是原地排序：直接修改原数组，不会返回新数组；
基本类型数组的排序是不稳定 的，引用类型排序是稳定的；
Java 8+还提供了List.sort()方法（替代Collections.sort()），写法更简洁：
java 复制代码
```
list.sort((a, b) -> b - a); // 等价于Collections.sort(list, ...)
```

总结

Java的.sort核心分为Arrays.sort()（数组）和Collections.sort()（List），底层优化保证高性能；
排序规则分两种：实现Comparable定义"自然排序"，或传入Comparator实现"定制排序"；
Java 8+推荐用Lambda简化Comparator，List.sort()替代Collections.sort()更简洁。

上面就是.sort的一些基本的用法,我是Dylan ,下期见~