Liste in kleinere Listen von N-Größe mit Stream teilen

Question

Wie kann ich eine Java-Liste nehmen und in kleinere Listen der Größe n in Java mit Streams teilen?

In JavaScript ich die reduce() Funktion verwenden würde, und so etwas tun:

const n = 3; 
 
const sublists = [1,2,3,4,5,6,7,8,9,0] 
 
    .reduce((r, i) => { 
 
    r[r.length - 1].length == n 
 
     ? r.push([i]) 
 
     : r[r.length - 1].push(i); 
 
    return r; 
 
    }, [[]]); 
 
console.log(sublists);

Ich versuche, mit einem Java-Stream zu tun, aber ich kann nicht scheinen herauszufinden, wie ich es bekommen kann, um einen ArrayList<ArrayList<Integer>> als meinen Anfangswert zu verwenden und dann die Listen hinzuzufügen. Ich bin ein wenig verwirrt, wie der Kombinator und der Akkumulator spielen, um mich benutzen zu lassen, oder selbst wenn reduce() der beste Ansatz für Java ist.

Answer 1

Es sieht so aus, als ob Sie ein JavaScript-Array haben, also würde der entsprechende Java-Code vermutlich ein IntStream verwenden. Berechnen Sie zuerst die korrekte Anzahl von rows und verwenden Sie dann Arrays.copyOfRange sammeln zu einem List und dann zu einem int[][] konvertieren. Verwenden Sie schließlich Arrays.deepToString, um das Array zu drucken. Wie,

final int n = 3; 
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; 
int rows = 1 + arr.length/n; 
int[][] sublists = IntStream.range(0, rows) 
     .mapToObj(i -> 
       Arrays.copyOfRange(arr, n * i, Math.min(n + (n * i), arr.length))) 
     .collect(Collectors.toList()).toArray(new int[rows][n]); 
System.out.println(Arrays.deepToString(sublists)); 

welche Ausgänge

[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0]] 

Für eine List<Integer> es könnte wie

final int n = 3; 
List<Integer> arr = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 0); 
int rows = 1 + arr.size()/n; 
List<List<Integer>> sublists = IntStream.range(0, rows) 
     .mapToObj(i -> arr.subList(n * i, Math.min(n + (n * i), arr.size()))) 
     .collect(Collectors.toList()); 
System.out.println(sublists); 

für die gleiche (angefragt) Ausgabe erfolgen.

Answer 2

Ziemlich einfach:

List<Integer> list = List.of(1, 2, 3, 4, 5, 7, 8, 9, 10, 11); 
    int n = 3; 
    List<List<Integer>> result = new LinkedList<>(); 
    int size = list.size(); 
    for (int i = 0; i <= size; i += n) { 
     result.add(list.subList(i, Math.min(i + n, size))); 
    }   
    System.out.println(result); // [[1, 2, 3], [4, 5, 7], [8, 9, 10], [11]] 

Eine Java-8-Lösung:

List<Integer> list = List.of(1, 2, 3, 4, 5, 7, 8, 9, 10, 11); 
int n = 3; 
List<List<Integer>> result = IntStream.range(0, list.size()) 
    .filter(i -> i % n == 0) 
    .mapToObj(i -> list.subList(i, Math.min(i + n, list.size()))) 
    .collect(Collectors.toList()); 
System.out.println(result); // [[1, 2, 3], [4, 5, 7], [8, 9, 10], [11]]