一文详解Java Stream的sorted自定义排序

// 自然排序示例
List<Integer> numbers = Arrays.asList(5, 3, 4, 1, 2);
List<Integer> sorted = numbers.stream()
    .sorted()  // 依赖Integer实现的Comparable接口
    .collect(Collectors.toList());  // [1, 2, 3, 4, 5]
 
// 自定义排序示例
List<String> words = Arrays.asList("apple", "Banana", "cherry");
List<String> caseInsensitive = words.stream()
    .sorted(String.CASE_INSENSITIVE_ORDER)  // 忽略大小写排序
    .collect(Collectors.toList());  // [apple, Banana, cherry]

// 按字符串长度排序
List<String> words = Arrays.asList("apple", "grape", "banana");
words.stream()
    .sorted(Comparator.comparing(String::length))
    .forEach(System.out::println);  // apple → grape → banana
 
// 复杂对象多字段排序（先按年龄降序，再按姓名升序）
List<User> users = Arrays.asList(
    new User("Alice", 25),
    new User("Bob", 20),
    new User("Charlie", 25)
);
users.stream()
    .sorted(Comparator.comparingInt(User::getAge).reversed()
        .thenComparing(User::getName))
    .forEach(u -> System.out.printf("%s: %d%n", u.getName(), u.getAge()));
/* 输出:
Alice: 25
Charlie: 25
Bob: 20
*/

class UserAgeComparator implements Comparator<User> {
    @Override
    public int compare(User u1, User u2) {
        return Integer.compare(u1.getAge(), u2.getAge());
    }
}
 
// 使用自定义Comparator
users.stream()
    .sorted(new UserAgeComparator())
    .collect(Collectors.toList());

List<String> wordsWithNulls = Arrays.asList("apple", null, "banana");
wordsWithNulls.stream()
    .sorted(Comparator.nullsLast(String::compareTo))
    .forEach(System.out::println);  // null → apple → banana

// 反例：对有序集合重复排序
List<Integer> sortedNumbers = Arrays.asList(1, 2, 3, 4, 5);
sortedNumbers.stream()
    .sorted()  // 不必要的排序操作
    .collect(Collectors.toList());
 
// 优化：确保数据源有序后直接处理

// 低效：对象流装箱
List<Integer> boxedResult = numbers.stream()
    .sorted()
    .collect(Collectors.toList());
 
// 高效：IntStream直接排序
int[] primitiveResult = numbers.stream()
    .mapToInt(Integer::intValue)
    .sorted()
    .toArray();

// 并行流排序示例
List<Integer> largeData = IntStream.range(0, 1000000)
    .boxed()
    .collect(Collectors.toList());
 
List<Integer> sortedParallel = largeData.parallelStream()
    .sorted()
    .collect(Collectors.toList());

// 传统排序：O(n log n)
List<Integer> topKTraditional = numbers.stream()
    .sorted(Comparator.reverseOrder())
    .limit(10)
    .collect(Collectors.toList());
 
// 优化：O(n log k)
PriorityQueue<Integer> heap = new PriorityQueue<>(10);
numbers.forEach(n -> {
    if (heap.size() < 10 || n > heap.peek()) {
        heap.offer(n);
        if (heap.size() > 10) heap.poll();
    }
});
List<Integer> topKOptimized = new ArrayList<>(heap);
Collections.sort(topKOptimized, Collections.reverseOrder());

// 按用户年龄、性别、姓名排序
users.stream()
    .sorted(Comparator.comparingInt(User::getAge)
        .thenComparing(User::getGender)
        .thenComparing(User::getName))
    .collect(Collectors.toList());

class User {
    private Optional<Integer> age;
    // getter省略
}
 
// 按年龄排序，空值放最后
users.stream()
    .sorted(Comparator.comparing(
        u -> u.getAge().orElse(Integer.MAX_VALUE)
    ))
    .collect(Collectors.toList());

// 错误：在并行流中使用非线程安全的Comparator
Comparator<String> unsafeComparator = new Comparator<String>() {
    private Collator collator = Collator.getInstance(Locale.CHINA);
    @Override
    public int compare(String s1, String s2) {
        return collator.compare(s1, s2);  // Collator非线程安全
    }
};
words.parallelStream().sorted(unsafeComparator);  // 可能抛出异常
 
// 正确：每次创建新的Comparator实例
words.parallelStream().sorted((s1, s2) -> 
    Collator.getInstance(Locale.CHINA).compare(s1, s2)
);

// 错误假设：认为所有排序都是稳定的
List<User> users = Arrays.asList(
    new User("Alice", 25),
    new User("Bob", 25)
);
// 两次排序可能导致顺序不一致（非稳定排序算法）
users.stream()
    .sorted(Comparator.comparingInt(User::getAge))
    .collect(Collectors.toList());

// 反例：多次排序操作
users.stream()
    .sorted(Comparator.comparingInt(User::getAge))
    .filter(u -> u.getAge() > 18)
    .sorted(Comparator.comparing(User::getName))
    .collect(Collectors.toList());
 
// 优化：合并排序条件，减少排序次数
users.stream()
    .filter(u -> u.getAge() > 18)
    .sorted(Comparator.comparingInt(User::getAge)
        .thenComparing(User::getName))
    .collect(Collectors.toList());