Limit groupBy in Java 8

Question

Come posso limitare groupBy ad ogni voce?

Per esempio (basato su questo esempio: stream groupBy):

studentClasses.add(new StudentClass("Kumar", 101, "Intro to Web")); 
studentClasses.add(new StudentClass("White", 102, "Advanced Java")); 
studentClasses.add(new StudentClass("Kumar", 101, "Intro to Cobol")); 
studentClasses.add(new StudentClass("White", 101, "Intro to Web")); 
studentClasses.add(new StudentClass("White", 102, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 106, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 103, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 104, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 105, "Advanced Web")); 

Questo metodo di ritorno semplice gruppo:

Map<String, List<StudentClass>> groupByTeachers = studentClasses 
      .stream().collect(
        Collectors.groupingBy(StudentClass::getTeacher)); 

Che cosa devo fare per limitare le collezioni restituiti? Supponiamo che voglio solo le prime classi N per ogni insegnante. Come può essere fatto?

Answer 1

sarebbe possibile introdurre un nuovo collettore che limita il numero di elementi nella lista risultante.

Questo collettore manterrà gli elementi di testa dell'elenco (in encounter order). L'accumulatore e il combinatore gettano via ogni elemento quando il limite è stato raggiunto durante la raccolta. Il codice del combinatore è un po 'complicato, ma questo ha il vantaggio che non vengono aggiunti elementi aggiuntivi solo per essere gettati via più tardi.

private static <T> Collector<T, ?, List<T>> limitingList(int limit) { 
    return Collector.of(
       ArrayList::new, 
       (l, e) -> { if (l.size() < limit) l.add(e); }, 
       (l1, l2) -> { 
        l1.addAll(l2.subList(0, Math.min(l2.size(), Math.max(0, limit - l1.size())))); 
        return l1; 
       } 
      ); 
} 

e quindi utilizzarlo in questo modo:

Map<String, List<StudentClass>> groupByTeachers = 
     studentClasses.stream() 
        .collect(groupingBy(
          StudentClass::getTeacher, 
          limitingList(2) 
        )); 

Answer 2

Per questo è necessario .stream() il risultato della mappa. È possibile farlo facendo:

// Part that comes from your example 
Map<String, List<StudentClass>> groupByTeachers = studentClasses 
      .stream().collect(
        Collectors.groupingBy(StudentClass::getTeacher)); 

// Create a new stream and limit the result 
groupByTeachers = 
    groupByTeachers.entrySet().stream() 
     .limit(N) // The actual limit 
     .collect(Collectors.toMap(
      e -> e.getKey(), 
      e -> e.getValue() 
     )); 

Questo non è un modo molto ottimale per farlo. Ma se si .limit() nell'elenco iniziale, i risultati del raggruppamento non sarebbero corretti. Questo è il modo più sicuro per garantire il limite.

EDIT:

Come indicato nei commenti questo limita l'insegnante, non la classe per insegnante. In questo caso si può fare:

groupByTeachers = 
     groupByTeachers.entrySet().stream() 
      .collect(Collectors.toMap(
       e -> e.getKey(), 
       e -> e.getValue().stream().limit(N).collect(Collectors.toList()) // Limit the classes PER teacher 
      )); 

Answer 3

Questo darebbe il risultato desiderato, ma categorizza ancora tutti gli elementi del flusso:

final int N = 10; 
final HashMap<String, List<StudentClass>> groupByTeachers = 
     studentClasses.stream().collect(
      groupingBy(StudentClass::getTeacher, HashMap::new, 
       collectingAndThen(toList(), list -> list.subList(0, Math.min(list.size(), N))))); 

Answer 4

Si potrebbe utilizzare collectingAndThen per definire un'operazione di finitura nella lista risultante. In questo modo è possibile limitare, filtrare, ordinare, ... le liste:

int limit = 2; 

Map<String, List<StudentClass>> groupByTeachers = 
    studentClasses.stream() 
        .collect(
         groupingBy(
          StudentClass::getTeacher, 
          collectingAndThen(
           toList(), 
           l -> l.stream().limit(limit).collect(toList()))));