按元素出现计数对列表进行分组，按键和值对地图进行排序[关闭]

Question

我有一个输入数组 ["Setra","Mercedes","Volvo","Mercedes","Skoda","Iveco","MAN",null,"Skoda","Iveco"]

预期的输出应该是

{Iveco=2, Mercedes=2, Skoda=2, MAN=1, Setra=1, Volvo=1}

表示以Vehicle 品牌为键、以值作为其出现次数的地图以及类似值的元素应按键的字母顺序和值排序。

我试过了

public static String busRanking(List<String> busModels) {
    Map<String, Long> counters = busModels.stream().skip(1).filter(Objects::nonNull)
            .filter(bus ->  !bus.startsWith("V"))
             .collect(Collectors.groupingBy(bus-> bus, Collectors.counting()));
    Map<String, Long> finalMap = new LinkedHashMap<>(); 
    counters.entrySet().stream()
                       .sorted(Map.Entry.comparingByValue(
                                      Comparator.reverseOrder()))
                       .forEachOrdered(
                                  e -> finalMap.put(e.getKey(), 
                                                    e.getValue()));
    return finalMap.toString();
}

public static void main(String[] args) {
    List<String> busModels = Arrays.asList( "Setra","Mercedes","Volvo","Mercedes","Skoda","Iveco","MAN",null,"Skoda","Iveco");
    String busRanking = busRanking(busModels);
    System.out.println(busRanking);
}

我得到的输出 {Skoda=2, Mercedes=2, Iveco=2, Setra=1, MAN=1}

有什么建议吗？并且必须使用单流（）获得输出

Answer 1

我认为不错的解决方案是：

public static void main(String... args) {
    List<String> busModels = Arrays.asList( "Setra","Mercedes","Volvo","Mercedes","Skoda","Iveco","MAN",null,"Skoda","Iveco");

    Map<String, Long> collect = busModels.stream()
        .filter(Objects::nonNull)
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

    TreeMap<String, Long> stringLongTreeMap = new TreeMap<>(collect);

    Set<Map.Entry<String, Long>> entries = stringLongTreeMap.entrySet();

    ArrayList<Map.Entry<String, Long>> list = new ArrayList<>(entries);

    list.sort((o1, o2) -> o2.getValue().compareTo(o1.getValue()));

    String busRanking = list.toString();

    System.out.println(busRanking);
}

Answer 2

如果您可以使用第三方库，这应该可以使用带有Eclipse Collections 的 Streams：

Comparator<ObjectIntPair<String>> comparator = 
    Comparators.fromFunctions(each -> -each.getTwo(), ObjectIntPair::getOne);

String[] strings = {"Setra", "Mercedes", "Volvo", "Mercedes", "Skoda", "Iveco", 
    "MAN", null, "Skoda", "Iveco"};

List<ObjectIntPair<String>> pairs = Stream.of(strings).collect(Collectors2.toBag())
        .select(Predicates.notNull())
        .collectWithOccurrences(PrimitiveTuples::pair, Lists.mutable.empty())
        .sortThis(comparator);

System.out.println(pairs);

输出：

[Iveco:2, Mercedes:2, Skoda:2, MAN:1, Setra:1, Volvo:1]

这也可以通过不使用 Streams 来稍微简化。

List<ObjectIntPair<String>> pairs = Bags.mutable.with(strings)
        .select(Predicates.notNull())
        .collectWithOccurrences(PrimitiveTuples::pair, Lists.mutable.empty())
        .sortThis(comparator);

注意：我是 Eclipse Collections 的提交者

Answer 3

使用标准 Java API 的“单线”：

Map<String, Long> map = busModels.stream()
    .filter(Objects::nonNull)
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
    .entrySet().stream()
    .sorted(Comparator
        .comparing((Entry<String, Long> e) -> e.getValue()).reversed()
        .thenComparing(e -> e.getKey()))
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue, (left, right) -> left + right, LinkedHashMap::new));

会发生什么：

• 它首先过滤掉空值。
• 然后它收集到一个地图中，按出现次数分组。
• 然后它遍历结果映射的条目，以便首先按值对其进行排序，然后比较键（因此，如果两次出现的次数相同，则依维柯排在 MAN 之前）。
• 最后，我们将条目提取到 LinkedHashMap 中，这会保留插入顺序。

输出：

{Iveco=2, Mercedes=2, Skoda=2, MAN=1, Setra=1, Volvo=1}

这使用单个方法链接语句。但是，我不会将此称为单个流操作，因为实际上创建了两个流，一个用于收集事件，另一个用于排序条目集。

流通常不会被设计为多次遍历，至少在标准 Java API 中不会。

可以用 StreamEx 完成吗？

有一个名为StreamEx 的库，它可能包含一个允许我们使用单个流操作来完成它的方法。

Map<String, Long> map = StreamEx.of(buses)
    .filter(Objects::nonNull)
    .map(t -> new AbstractMap.SimpleEntry<>(t, 1L))
    .sorted(Comparator.comparing(Map.Entry::getKey))
    .collapse(Objects::equals, (left, right) -> new AbstractMap.SimpleEntry<>(left.getKey(), left.getValue() + right.getValue()))
    .sorted(Comparator
        .comparing((Entry<String, Long> e) -> e.getValue()).reversed()
        .thenComparing(e -> e.getKey()))
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue, (left, right) -> left + right, LinkedHashMap::new));

会发生什么：

• 我们过滤掉空值。
• 我们将其映射到Entrys 流，每个键是总线名称，每个值是初始出现次数，即1。
• 然后我们按每个键对流进行排序，确保所有相同的总线在流中都是相邻的。
• 这允许我们使用collapse 方法，该方法使用合并函数合并满足给定谓词的一系列相邻元素。所以Mercedes => 1 + Mercedes => 1 变成了Mercedes => 2。
• 然后我们如上所述进行分类和收集。

这至少似乎是在单个流操作中进行的。