streams - Wie sortiere Hash-Map basierend auf der Anzahl der Schlüssel für einen Wert mit Flatmap Java8?



java streams erklärung (1)

Du könntest folgendes haben:

Map<Integer, List<Integer>> sorted = 
    map.entrySet()
       .stream()
       .sorted(comparing(e -> ex.get(e.getKey()), reverseOrder()))
       .collect(toMap(
           Map.Entry::getKey,
           e -> e.getValue().stream().sorted(comparing(ex::get, reverseOrder())).collect(toList()),
           (v1, v2) -> { throw new IllegalStateException(); },
           LinkedHashMap::new
       ));

Dies erzeugt einen Stream der Einträge der Map, sortiert sie in umgekehrter Reihenfolge entsprechend der Anzahl der Schlüssel für den Schlüssel dieses Eintrags und sammelt sie schließlich in einer Map, in der der neue Wert in umgekehrter Reihenfolge in Bezug auf die Zählung jeder Ganzzahl sortiert wird ( ex::get ). Die Sammelkarte ist eine LinkedHashMap , um die Reihenfolge der Begegnungen zu erhalten.

Ausgabe:

{1=[2, 3, 0], 2=[4, 1, 0], 3=[4, 1, 5], 4=[2, 3, 5], 0=[1, 2], 5=[4, 3]}

Statische Importe verwendet:

import static java.util.Comparator.comparing;
import static java.util.Comparator.reverseOrder;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toMap;

Dies ist ein Follow-up von So erhalten Sie die Anzahl der Schlüssel für Werte in einer Hash-Map mit Lambda . Ich habe eine HashMap und ich möchte die Anzahl der Schlüssel für jeden Wert finden

Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>() {{
    put(0, Arrays.asList(1, 2));
    put(1, Arrays.asList(2, 0, 3));
    put(2, Arrays.asList(4,0,1));
    put(3, Arrays.asList(4,1, 5));
    put(4, Arrays.asList(5,2,3));
    put(5, Arrays.asList(4,3));
}};

Laut dem obigen Beitrag habe ich versucht, flach zu mappen:

Map<Object, Long> ex = 
                map.values()
                .stream()
                .flatMap(Collection::stream)
                .collect(Collectors.groupingBy(v -> v, Collectors.counting()));

System.out.println(ex);

Die Ausgabe ist

{0=2, 1=3, 2=3, 3=3, 4=3, 5=2}. 

Das heißt, 0 hat zwei Schlüssel, einer hat drei Schlüssel und so weiter. Jetzt möchte ich die Schlüssel und Werte in absteigender Reihenfolge basierend auf der Anzahl der Schlüssel sortieren. Ich habe so etwas versucht:

Map<Object, Long> ex = 
                map.values()
                .stream()
                .flatMap(Collection::stream)
                .collect(Collectors.groupingBy(v -> v, Collectors.counting()));

                        .entrySet()
                        .stream()
                        .sorted(Map.Entry.<String, Long>comparingByValue(reverseOrder()).thenComparing(Map.Entry.comparingByKey()))
                        .collect(LinkedHashMap::new, (m,e) -> m.put(e.getKey(), e.getValue()), Map::putAll);

Ich möchte folgende Ausgabe:

1=[2, 3, 0], 2=[1,4,0], 3=[1, 4, 5], 4=[2, 3, 5], 0=[1, 2], 5=[3, 4]

Die Schlüssel und Werte sollten nach dieser Anzahl von Schlüsseln absteigend angeordnet werden {0=2, 1=3, 2=3, 3=3, 4=3, 5=2} : 1, 2, 3, 4 hat drei Die Tasten 0 und 5 haben zwei Tasten.

Zum Beispiel: 1=[2, 3, 0] : 1 hat drei Tasten, so erscheint es zuerst mit [2, 3, 0] : 2 und 3 haben drei Tasten und 0 hat nur zwei Tasten.





java-stream