Wie erzeuge ich zusammenfassenden Bericht mit verschachtelten Sammlung mit Java 8 Streams?

Question

Ich habe eine Liste von Objekten mit Klasse wie folgt:

class TestResult{ 
    int userId; 
    Set<String> subjects; 
    int score; 
} 

Ich möchte in jedem Fach

Map<String,Map<Integer, Integer>> 

Die äußeree Karte hat als zentrales Thema eine Zusammenfassung der Partitur für jeden userId zu produzieren. Die innere Karte hat userId als Schlüssel, Summe der Punkte als Wert.

Answer 1

(Bitte beachten Sie: Im Folgenden ich auf Ihre (derzeit unbenannt) Klasse als MixedScores refere)

Lassen Sie uns ein sumScores eine Methode definieren, die eine Collection<MixedScores> nimmt und gibt ein Map<String, Map<Integer, Integer>> zusammengesetzt, wie Sie gefragt.

Sie könnten eine lokale Klasse SingleScore verwenden, um eine einzelne MixedScores Instanz in mehreren Instanzen aufzuteilen, sie dann nach Thema, nach userId zu gruppieren und schließlich alle gefundenen Ergebnisse zu summieren.

In Code:

Map<String, Map<Integer, Integer>> sumScores(Collection<MixedScores> scores) { 
    class SingleScore { 
     int userId; 
     String subject; 
     int score; 

     SingleScore(MixedScores mixedScores, String subject) { 
      this.userId = mixedScores.userId; 
      this.subject = subject; 
      this.score = mixedScores.score; 
     } 

     String getSubject() { 
      return subject; 
     } 

     int getUserId() { 
      return userId; 
     } 

     int getScore() { 
      return score; 
     } 
    } 

    return scores.stream() 
      .flatMap(x -> x.subjects.stream().map(subject -> new SingleScore(x, subject))) 
      .collect(groupingBy(SingleScore::getSubject, 
        groupingBy(SingleScore::getUserId, summingInt(SingleScore::getScore)))); 
} 

Natürlich gibt es einige Importe:

import static java.util.stream.Collectors.groupingBy; 
import static java.util.stream.Collectors.summingInt; 

import java.util.Collection; 
import java.util.Map; 
import java.util.Set; 

diese Arbeit für Sie?

Answer 2

Eine andere Möglichkeit, ohne eine neue Klasse zu schaffen, vorgeschlagen von @Flown

   scores.stream() 
        .flatMap(x -> x.subjects.stream() 
          .map(subject -> new AbstractMap.SimpleEntry<String, Entry<Integer, Integer>>(subject, 
            new AbstractMap.SimpleEntry<Integer, Integer>(x.userId, x.score)))) 
        .collect(Collectors.groupingBy(Entry<String, Entry<Integer, Integer>>::getKey, 
          Collectors.groupingBy(p -> p.getValue().getKey(), 
            Collectors.summingInt((p -> p.getValue().getValue())))));