Java Stream 高效分组计数并获取Top N元素

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

// 假设 City 类定义如下
class City {
    private int id;
    private String name;
    private String countryCode;

    public City(int id, String name, String countryCode) {
        this.id = id;
        this.name = name;
        this.countryCode = countryCode;
    }

    public String getCountryCode() {
        return countryCode;
    }

    @Override
    public String toString() {
        return "City{" + "id=" + id + ", name='" + name + '\'' + ", countryCode='" + countryCode + '\'' + '}';
    }
}

public class StreamTopNMethods {

    /**
     * 使用全排序获取 Top N 国家代码
     * @param cities 城市列表
     * @param limit 需要获取的 Top N 数量
     * @return Top N 国家代码列表
     */
    public static List<String> getTopNCodesByFullSort(List<City> cities, int limit) {
        return cities.stream()
            .collect(Collectors.groupingBy( // 1. 按 countryCode 分组并计数
                City::getCountryCode,
                Collectors.counting()
            )) // 结果为 Map<String, Long>，例如 {DE=4, FR=2, DK=1, NO=1}
            .entrySet().stream() // 2. 获取 Map 的 entrySet 并转换为 Stream
            .sorted(Map.Entry.<String, Long>comparingByValue().reversed()) // 3. 按计数降序排序
            .limit(limit) // 4. 取前 limit 个元素
            .map(Map.Entry::getKey) // 5. 提取国家代码 (键)
            .toList(); // 6. 收集结果到 List
    }

    public static void main(String[] args) {
        List<City> cityList = 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, "Kopenhag", "DK"),
            new City(6, "Hamburg", "DE"),
            new City(7, "Lyon", "FR"),
            new City(8, "Oslo", "NO"),
            new City(9, "Frankfurt", "DE")
        );

        List<String> top3Countries = getTopNCodesByFullSort(cityList, 3);
        System.out.println("Top 3 Countries by city count (Full Sort): " + top3Countries);
        // 示例输出: Top 3 Countries by city count (Full Sort): [DE, FR, DK] (或 [DE, FR, NO]，取决于DK和NO在Map中的相对顺序，因为它们的计数相同)
    }
}

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;

// ... City 类定义同上

public class StreamTopNMethodsAdvanced {

    /**
     * 泛化方法：使用自定义 Collector 和 PriorityQueue 获取 Top N 元素
     * @param list 原始数据列表
     * @param keyExtractor 用于从原始数据中提取分组键的函数
     * @param limit 需要获取的 Top N 数量
     * @param <T> 原始数据类型
     * @param <K> 分组键类型
     * @return Top N 键的列表
     */
    public static <T, K> List<K> getTopNByPriorityQueue(List<T> list,
                                                         Function<T, K> keyExtractor,
                                                         int limit) {
        return list.stream()
            .collect(Collectors.groupingBy( // 1. 按 keyExtractor 提取的键分组并计数
                keyExtractor,
                Collectors.counting()
            )) // 结果为 Map<K, Long>
            .entrySet().stream() // 2. 获取 Map 的 entrySet 并转换为 Stream
            .collect(getMaxNCollector( // 3. 使用自定义 Collector 获取 Top N
                limit,
                Map.Entry.<K, Long>comparingByValue().reversed(), // 比较器，用于 PriorityQueue 维护最小堆
                Map.Entry::getKey // 提取最终结果的函数
            ));
    }

    /**
     * 辅助方法：向 PriorityQueue 中尝试添加元素
     * 确保队列始终只包含 'size' 个元素，且这些元素是当前遍历过所有元素中“最大”的 'size' 个。
     * @param queue PriorityQueue 实例
     * @param next 待添加的下一个元素
     * @param comparator 用于比较元素的比较器
     * @param size 队列的最大容量 (即 N 值)
     * @param <T> 队列中元素的类型
     */
    public static <T> void tryAdd(Queue<T> queue, T next, Comparator<T> comparator, int size) {
        // 如果队列已满，且新元素比队列中“最小”的元素（即堆顶元素）“更大”（根据比较器）
        // 注意：这里的 comparator 是 reversed 的，所以 compare(queue.element(), next) < 0 意味着 next 更大
        if (queue.size() == size && comparator.compare(queue.element(), next) < 0) {
            queue.remove(); // 移除堆顶元素（当前 Top N 中最小的那个）
        }
        // 如果队列未满，或者新元素被认为“更大”并已移除旧元素，则添加新元素
        if (queue.size() < size) {
            queue.add(next);
        }
    }

    /**
     * 自定义 Collector，用于从 Stream 中获取 Top N 元素。
     * @param size 需要获取的 Top N 数量
     * @param comparator 用于在 PriorityQueue 中排序元素的比较器。
     *                   如果需要 Top N 最大值，此比较器应使得“较小”的元素排在前面（即为最小堆）。
     *                   对于 Map.Entry<K, Long> 场景，若要获取计数最大的 N 个，则比较器应为 Map.Entry.comparingByValue()。
     *                   但由于 PriorityQueue 默认是最小堆，为了让“最大”的元素留在堆中，我们传入一个“反向”的比较器。
     *                   例如，`Map.Entry.<K, Long>comparingByValue().reversed()`，这样计数小的元素会在堆顶。
     * @param keyExtractor 用于从堆中的元素（Map.Entry）提取最终结果（键）的函数
     * @param <T> Stream 中元素的类型 (这里是 Map.Entry<K, Long