Gruppieren Sie durch Zählen in der Java 8-Stream-API

Ich versuche, in der Java 8-Stream-API einen einfachen Weg zu finden, um die Gruppierung durchzuführen. Ich komme mit diesem komplexen Weg heraus!

List<String> list = new ArrayList<>();

list.add("Hello");
list.add("Hello");
list.add("World");

Map<String, List<String>> collect = list.stream().collect(
        Collectors.groupingBy(o -> o));
System.out.println(collect);

List<String[]> collect2 = collect
        .entrySet()
        .stream()
        .map(e -> new String[] { e.getKey(),
                String.valueOf(e.getValue().size()) })
        .collect(Collectors.toList());

collect2.forEach(o -> System.out.println(o[0] + " >> " + o[1]));

Ich freue mich über Ihren Beitrag.

Ich denke, Sie suchen nur nach der Überlastung, die eine andere benötigt, Collectorum anzugeben, was mit jeder Gruppe Collectors.counting()zu tun ist ... und dann um zu zählen:

import java.util.*;
import java.util.stream.*;

class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("Hello");
        list.add("Hello");
        list.add("World");

        Map<String, Long> counted = list.stream()
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        System.out.println(counted);
    }
}

Ergebnis:

{Hello=2, World=1}

(Es besteht auch die Möglichkeit, die groupingByConcurrentEffizienz zu steigern. Beachten Sie dies für Ihren echten Code, wenn er in Ihrem Kontext sicher wäre.)

List<String> list = new ArrayList<>();

list.add("Hello");
list.add("Hello");
list.add("World");

Map<String, List<String>> collect = list.stream()
                                        .collect(Collectors.groupingBy(o -> o));
collect.entrySet()
       .forEach(e -> System.out.println(e.getKey() + " - " + e.getValue().size()));

Hier ist ein Beispiel für eine Liste von Objekten

Map<String, Long> requirementCountMap = requirements.stream().collect(Collectors.groupingBy(Requirement::getRequirementType, Collectors.counting()));

Hier sind etwas andere Optionen, um die vorliegende Aufgabe zu erfüllen.

mit toMap:

list.stream()
    .collect(Collectors.toMap(Function.identity(), e -> 1, Math::addExact));

mit Map::merge:

Map<String, Integer> accumulator = new HashMap<>();
list.forEach(s -> accumulator.merge(s, 1, Math::addExact));

Hier ist die einfache Lösung von StreamEx

StreamEx.of(list).groupingBy(Function.identity(), Collectors.countingInt());

Reduzieren Sie den Boilerplate-Code: collect(Collectors.

Wenn Sie eine Drittanbieter - Bibliothek mit Open sind, können Sie die Verwendung der Collectors2Klasse in Eclipse - Kollektionen auf die konvertieren Listzu einem Bageiner Verwendung Stream. A Bagist eine Datenstruktur, die zum Zählen erstellt wurde .

Bag<String> counted =
        list.stream().collect(Collectors2.countBy(each -> each));

Assert.assertEquals(1, counted.occurrencesOf("World"));
Assert.assertEquals(2, counted.occurrencesOf("Hello"));

System.out.println(counted.toStringOfItemToCount());

Ausgabe:

{World=1, Hello=2}

In diesem speziellen Fall können Sie einfach collectdie Listdirekt in eine Bag.

Bag<String> counted = 
        list.stream().collect(Collectors2.toBag());

Sie können das auch Bagohne Verwendung eines erstellen, Streamindem Sie das Listmit den Eclipse Collections-Protokollen anpassen .

Bag<String> counted = Lists.adapt(list).countBy(each -> each);

oder in diesem speziellen Fall:

Bag<String> counted = Lists.adapt(list).toBag();

Sie können die Tasche auch direkt erstellen.

Bag<String> counted = Bags.mutable.with("Hello", "Hello", "World");

A Bag<String>ist insofern wie a Map<String, Integer>, als es intern die Schlüssel und ihre Anzahl verfolgt. Wenn Sie jedoch Mapnach einem Schlüssel fragen , der nicht enthalten ist, wird er zurückgegeben null. Wenn Sie a Bagnach einem Schlüssel fragen , der nicht using enthält occurrencesOf, wird 0 zurückgegeben.

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.