Liste in Liste aufteilen

Question

Angenommen, ich habe eine List<Object> mit 100 Objekten in. Was ist der beste Weg mit Java 8 (ohne irgendeine Tiering-Bibliothek), um eine List<List<Object>> zu bekommen, die 10 List von 10 Object enthält?

Answer 1

es ist einfacher Guave mit (erwähnt Sie in Ihnen without any tierce library poste ich diese setzen sowieso)

@Test 
public void givenList_whenParitioningIntoNSublists_thenCorrect() { 
    List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8); 
    List<List<Integer>> subSets = Lists.partition(intList, 3); 

    List<Integer> lastPartition = subSets.get(2); 
    List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8); 
    assertThat(subSets.size(), equalTo(3)); 
    assertThat(lastPartition, equalTo(expectedLastPartition)); 
} 

Answer 2

Sie benötigen eine externe final Zähler, aber das scheint zu funktionieren.

// Must be final (or implicitly final). 
    AtomicInteger n = new AtomicInteger(); 
    Map<String, List<Integer>> groups = IntStream.range(0, 100) 
      .boxed() 
      .collect(Collectors.groupingBy(
        // Group by n/10. 
        o -> String.valueOf(n.getAndIncrement()/10) 
        ) 
      ); 

Answer 3

Ich würde zuerst die Futtergröße nehmen (10 Elemente, in diesem Fall), und dann die Liste durchgehen und verwenden subList Brocken nehmen aus ihm heraus. Z.B .:

List<List<Object>> subLists = IntStream 
    .range(0, (int) Math.ceil((double) list.size()/subListSize)) 
    .mapToObj(i -> new ArrayList<> 
         (list.subList(i * subListSize, (i + 1) * subListSize))) 
    .collect(Collectors.toList()); 

Hinweis: Das Casting zu double und Decke nach unten, um Integer-Division zu vermeiden, falls die subListSize nicht list.size() genau nicht teilt.

Answer 4

in Java 9 Sie die Indizes mit einem IntStream erzeugen kann Takewhile und anschließend mit diesen Indizes nehmen Sublisten aus der ursprüngliche Liste. Dies sollte jede Liste der Objekte für arbeiten:

private static final int BATCH_SIZE = 10; 

public void test(){ 
    List<List<Object>> batchedLists = split(generateTestObjects()); 
} 

public List<List<Object>> split(List<Object> objects) { 
    return IntStream.iterate(0, n -> n + BATCH_SIZE) 
      .takeWhile(n -> n < objects.size()) 
      .map(t -> objects.subList(t, Math.min(t + BATCH_SIZE, objects.size())) 
      .collect(Collectors.toList()); 
} 

public List<Object> generateTestObjects(){ 
    return IntStream.range(0, 100) 
      .boxed() 
      .collect(Collectors.toList()); 
}