Aufteilen einer Liste in Chunks in Java
-
Verwenden Sie die Methode
List.subList(), um eine Liste in Java in Chunks aufzuteilen -
Verwenden Sie die Methode
Collectors.groupingBy(), um eine Liste in Java in Chunks aufzuteilen - Verwenden Sie die Apache Commons Collections-Methode, um eine Liste in Java in Chunks aufzuteilen
- Verwenden Sie die Google Guava Library, um eine Liste in Java in Chunks aufzuteilen
Manchmal ist es erforderlich, eine Liste in Java in Blöcke einer bestimmten Größe aufzuteilen. Um dies zu erreichen, gibt es in Java verschiedene Funktionalitäten.
Dieses Tutorial zeigt verschiedene Methoden zum Aufteilen einer Liste in Chunks in Java.
Verwenden Sie die Methode List.subList(), um eine Liste in Java in Chunks aufzuteilen
Die Methode List.subList kann zusammen mit einer for-Schleife verwendet werden, um in Java eine Liste in Chunks einer bestimmten Größe aufzuteilen. Die Methode subList() ruft eine Unterliste aus der angegebenen Liste innerhalb eines bestimmten Start- und Endindex ab.
Sehen wir uns ein Beispiel an:
package delftstack;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Example {
public static void main(String[] args) {
List<Integer> DemoList = IntStream.rangeClosed(100, 120).boxed().collect(Collectors.toList());
int ChunckSize = 3;
List<List<Integer>> Chunks = new ArrayList<>();
for (int x = 0; x < DemoList.size(); x += ChunckSize) {
Chunks.add(DemoList.subList(x, Math.min(x + ChunckSize, DemoList.size())));
}
System.out.println(Chunks);
}
}
Der obige Code erstellt Chunks der Größe drei aus der angegebenen Liste. Siehe die Ausgabe:
In ähnlicher Weise können wir Java 9 IntStream.iterate() verwenden, um eine Liste in Java in Chunks aufzuteilen. Siehe das Beispiel:
package delftstack;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Example {
private static <T> List<List<T>> Chunks(List<T> DemoList, int ChunkSize) {
return IntStream.iterate(0, x -> x < DemoList.size(), x -> x + ChunkSize)
.mapToObj(x -> DemoList.subList(x, Math.min(x + ChunkSize, DemoList.size())))
.collect(Collectors.toList());
}
public static void main(String[] args) {
List<Integer> DemoList = IntStream.rangeClosed(100, 120).boxed().collect(Collectors.toList());
int ChunkSize = 3;
List<List<Integer>> Chunks = Chunks(DemoList, ChunkSize);
System.out.println(Chunks);
}
}
Der obige Code verwendet IntStream.iterate() von Java 9, um dieselbe Operation wie im ersten Beispiel auszuführen. Siehe die Ausgabe:
Wir können auch die Java 8 Stream API verwenden, um dieselbe Operation auszuführen. Siehe Beispiel:
package delftstack;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Example {
private static <T> List<List<T>> Chunk(List<T> DemoList, int ChunkSize) {
return IntStream.rangeClosed(0, (DemoList.size() - 1) / ChunkSize)
.mapToObj(
x -> DemoList.subList(x * ChunkSize, Math.min((x + 1) * ChunkSize, DemoList.size())))
.collect(Collectors.toList());
}
public static void main(String[] args) {
List<Integer> DemoList = IntStream.rangeClosed(100, 120).boxed().collect(Collectors.toList());
int ChunkSize = 3;
List<List<Integer>> Chunks = Chunk(DemoList, ChunkSize);
System.out.println(Chunks);
}
}
Der obige Code verwendet die Java 8 Stream API, um die Liste in drei Blöcke aufzuteilen. Siehe die Ausgabe:
Verwenden Sie die Methode Collectors.groupingBy(), um eine Liste in Java in Chunks aufzuteilen
Die Methode Collectors.groupingBy() der Java Stream API kann auch verwendet werden, um eine Liste in Chunks aufzuteilen, wobei wir nach Listenelementen gruppieren, um Chunks zu erstellen. Diese Methode gibt die Chunks in Form von Maps zurück.
Sehen wir uns ein Beispiel an:
package delftstack;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Example {
private static <T> Collection<List<T>> Chunk(List<T> DemoList, int GroupBy) {
return IntStream.range(0, DemoList.size())
.boxed()
.collect(Collectors.groupingBy(
x -> x / GroupBy, Collectors.mapping(DemoList::get, Collectors.toList())))
.values();
}
public static void main(String[] args) {
List<Integer> DemoList = IntStream.rangeClosed(100, 120).boxed().collect(Collectors.toList());
int ChunkSize = 3;
Collection<List<Integer>> Chunks = Chunk(DemoList, ChunkSize);
System.out.println(Chunks);
}
}
Der obige Code verwendet die Gruppierungsfunktion, um Chunks der angegebenen Liste in Java zu erstellen. Siehe die Ausgabe:
In ähnlicher Weise können wir den obigen Code vereinfachen, indem wir einen veränderlichen Zähler verwenden. Siehe das Beispiel:
package delftstack;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Example {
private static <T> Collection<List<T>> Chunk(List<T> DemoList, int Groupby) {
AtomicInteger counter = new AtomicInteger();
return DemoList.stream()
.collect(Collectors.groupingBy(it -> counter.getAndIncrement() / Groupby))
.values();
}
public static void main(String[] args) {
List<Integer> DemoList = IntStream.rangeClosed(100, 120).boxed().collect(Collectors.toList());
int ChunkSize = 3;
Collection<List<Integer>> Chunks = Chunk(DemoList, ChunkSize);
System.out.println(Chunks);
}
}
Der obige Code verwendet den veränderlichen Zähler AtomicInteger, um nach der Liste zu gruppieren, um Blöcke der Größe drei zu erstellen. Siehe die Ausgabe:
Verwenden Sie die Apache Commons Collections-Methode, um eine Liste in Java in Chunks aufzuteilen
Apache Commons ist eine Bibliothek eines Drittanbieters, die viele Operationen bereitstellt, einschließlich einer Liste. Die Sammlung von Apache Commons kann auch verwendet werden, um Listenblöcke in Java zu erstellen.
Stellen Sie zunächst sicher, dass Apache Commons zu Ihrem Build-Pfad hinzugefügt wurde. Versuchen wir ein Beispiel, um Teile der Liste mit Apache Commons Collections zu erstellen:
package delftstack;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.apache.commons.collections4.ListUtils;
public class Example {
public static void main(String[] args) {
List<Integer> DemoList = IntStream.rangeClosed(100, 120).boxed().collect(Collectors.toList());
int ChunkSize = 3;
List<List<Integer>> Chunks = ListUtils.Chunk(DemoList, ChunkSize);
System.out.println(Chunks);
}
}
Apache Commons stellt eine Methode namens partition zur Verfügung, die verwendet wird, um Chunks der gegebenen Liste zu erstellen. Siehe die Ausgabe:
Verwenden Sie die Google Guava Library, um eine Liste in Java in Chunks aufzuteilen
Das Guava-Paket von Google bietet auch viele Funktionalitäten bezüglich Listen in Java. Es bietet eine Methode, Lists.partition(), die verwendet wird, um Chunks einer Liste in Java zu erstellen.
Bitte stellen Sie sicher, dass das Guava-Paket zu Ihrem Erstellungspfad hinzugefügt wird, da es sich um ein Paket eines Drittanbieters handelt und nicht in JDK enthalten ist. Versuchen wir es an einem Beispiel:
package delftstack;
import com.google.common.collect.Lists;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Example {
public static void main(String[] args) {
List<Integer> DemoList = IntStream.rangeClosed(100, 120).boxed().collect(Collectors.toList());
int ChunkSize = 3;
List<List<Integer>> Chunk = Lists.partition(DemoList, ChunkSize);
System.out.println(Chunk);
}
}
Der obige Code erstellt auf ähnliche Weise Chunks der angegebenen Liste in Form von drei mithilfe der Methode partition() der Guava-Bibliothek. Siehe die Ausgabe:
Sheeraz is a Doctorate fellow in Computer Science at Northwestern Polytechnical University, Xian, China. He has 7 years of Software Development experience in AI, Web, Database, and Desktop technologies. He writes tutorials in Java, PHP, Python, GoLang, R, etc., to help beginners learn the field of Computer Science.
LinkedIn Facebook