Java Stream高效实现按字段分组计数及Top N数据提取

public class City {
    private int id;
    private String name;
    private String countryCode;

    // 构造函数, getters, setters
    public City(int id, String name, String countryCode) {
        this.id = id;
        this.name = name;
        this.countryCode = countryCode;
    }

    public String getCountryCode() {
        return countryCode;
    }

    // ... 其他方法
}

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class CityAnalyzer {

    public static List<String> getTopNCodes(List<City> cities, int limit) {
        return cities.stream()
            .collect(Collectors.groupingBy( // 1. 分组并计数
                City::getCountryCode,
                Collectors.counting()
            )) // 结果为 Map<String, Long>，例如 { "DE": 3, "FR": 1, "DK": 1 }
            .entrySet().stream() // 2. 转换为 Stream<Map.Entry<String, Long>>
            .sorted(Map.Entry.<String, Long>comparingByValue().reversed()) // 3. 按值降序排序
            .limit(limit) // 4. 截取前N个
            .map(Map.Entry::getKey) // 5. 提取键 (国家代码)
            .toList(); // 收集为List
    }

    public static void main(String[] args) {
        List<City> cities = List.of(
            new City(1, "Berlin", "DE"),
            new City(2, "Munich", "DE"),
            new City(3, "Köln", "DE"),
            new City(4, "Paris", "FR"),
            new City(5, "Copenhagen", "DK"),
            new City(6, "Hamburg", "DE"),
            new City(7, "Lyon", "FR")
        );

        List<String> top3CountryCodes = getTopNCodes(cities, 3);
        System.out.println("Top 3 country codes by city count: " + top3CountryCodes);
        // 预期输出: [DE, FR, DK] (或 [DE, DK, FR] 取决于FR和DK的相对顺序，但DE肯定排第一)
    }
}

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class CityAnalyzerOptimized {

    /**
     * 获取列表中按某个键分组后，计数最多的前N个键。
     *
     * @param list         原始数据列表
     * @param keyExtractor 提取分组键的函数
     * @param limit        需要获取的前N个元素数量
     * @param <T>          列表元素类型
     * @param <K>          分组键类型
     * @return 计数最多的前N个键的列表
     */
    public static <T, K> List<K> getTopN(List<T> list,
                                         Function<T, K> keyExtractor,
                                         int limit) {
        if (list == null || list.isEmpty() || limit <= 0) {
            return List.of();
        }

        // 1. 分组并计数，结果为 Map<K, Long>
        Map<K, Long> countedMap = list.stream()
            .collect(Collectors.groupingBy(
                keyExtractor,
                Collectors.counting()
            ));

        // 2. 使用自定义Collector进行部分排序
        return countedMap.entrySet().stream()
            .collect(getMaxNCollector(
                limit,
                Map.Entry.comparingByValue(), // PriorityQueue作为最小堆，基于值进行比较
                Map.Entry::getKey
            ));
    }

    /**
     * 创建一个自定义Collector，用于从Stream中找出最大的N个元素。
     *
     * @param size                 要保留的元素数量N
     * @param comparatorForMinHeap 用于PriorityQueue的比较器，应使PriorityQueue成为最小堆（例如，按值升序）
     * @param keyExtractor         从Map.Entry中提取最终结果键的函数
     * @param <T>                  Stream中元素的类型 (Map.Entry<K, Long>)
     * @param <R>                  最终结果列表元素的类型 (K)
     * @return 维护Top N元素的Collector
     */
    public static <T, R> Collector<T, ?, List<R>> getMaxNCollector(int size,
                                                                   Comparator<T> comparatorForMinHeap,
                                                                   Function<T, R> keyExtractor) {

        return Collector.of(
            () -> new PriorityQueue<>(size, comparatorForMinHeap), // Supplier: 创建一个指定大小和比较器的最小堆
            (Queue<T> queue, T next) -> { // Accumulator: 处理每个元素
                if (queue.size() < size) {
                    queue.add(next); // 队列未满，直接添加
                } else {
                    // 队列已满，与堆顶元素（当前最小的Top N元素）比较
                    if (comparatorForMinHeap.compare(queue.peek(), next) < 0) { // 如果新元素比堆顶元素大
                        queue.poll(); // 移除堆顶元素
                        queue.add(next); // 添加新元素
                    }
                }
            },
            (Queue<T> left, Queue<T> right) -> { // Combiner: 合并两个部分结果（两个PriorityQueue）
                // 将右侧队列的元素逐个添加到左侧队列，并保持Top N的逻辑
                right.forEach(next -> {
                    if