Limit groupBy in Java 8

Question

Wie kann ich groupBy durch jeden Eintrag begrenzen?

Zum Beispiel (in diesem Beispiel basieren: 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")); 

Diese Methode einfache Gruppe zurück:

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

Was passiert, wenn ich die zurückgegebenen Sammlungen beschränken möchten? Nehmen wir an, ich möchte nur die ersten N Klassen für jeden Lehrer. Wie kann es gemacht werden?

Answer 1

Es wäre möglich, einen neuen Sammler einzuführen, Begrenzt die Anzahl der Elemente in der resultierenden Liste.

Dieser Kollektor behält die Kopfelemente der Liste (in encounter order). Der Akkumulator und der Kombinator werfen alle Elemente weg, wenn die Grenze während der Sammlung erreicht ist. Der Combiner-Code ist ein wenig kompliziert, aber das hat den Vorteil, dass keine zusätzlichen Elemente hinzugefügt werden, die später einfach weggeworfen werden.

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; 
       } 
      ); 
} 

Und dann ist es wie folgt verwenden:

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

Answer 2

Dazu müssen Sie .stream() das Ergebnis Ihrer Karte. Sie können dies tun, indem Sie:

// 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() 
     )); 

Dies ist kein sehr optimaler Weg, es zu tun. Aber wenn Sie .limit() auf der ersten Liste, dann die Gruppierung Ergebnisse wären falsch. Dies ist der sicherste Weg, um das Limit zu garantieren.

EDIT:

Wie in den Kommentaren erklärt dies den Lehrer begrenzt, nicht die Klasse pro Lehrer. In diesem Fall können Sie tun:

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

Dies würde Ihnen das gewünschte Ergebnis, aber es stuft noch alle Elemente des Stroms:

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

Sie collectingAndThen verwenden könnte einen Finisher Betrieb auf der Ergebnisliste zu definieren. Auf diese Weise können begrenzen, filtern, sortieren, ... die Listen:

int limit = 2; 

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