Dividir una lista en trozos en Java
-
Utilice el método
List.subList()para dividir una lista en trozos en Java -
Utilice el método
Collectors.groupingBy()para dividir una lista en fragmentos en Java - Utilice el método de colecciones de Apache Commons para dividir una lista en fragmentos en Java
- Utilice la biblioteca de guayaba de Google para dividir una lista en fragmentos en Java
A veces es necesario dividir una lista en un tamaño particular de fragmentos en Java. Hay diferentes funcionalidades para lograr esto en Java.
Este tutorial demuestra diferentes métodos para dividir una lista en fragmentos en Java.
Utilice el método List.subList() para dividir una lista en trozos en Java
El método List.subList se puede usar junto con un bucle for para dividir una lista en un tamaño particular de fragmentos en Java. El método subList() obtendrá una sublista de la lista dada dentro de un índice de inicio y final específico.
Veamos un ejemplo:
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);
}
}
El código anterior creará fragmentos de tamaño tres de la lista dada. Ver la salida:
De manera similar, podemos usar Java 9 IntStream.iterate() para dividir una lista en fragmentos en Java. Ver el ejemplo:
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);
}
}
El código anterior utilizará IntStream.iterate() de Java 9 para realizar la misma operación que el primer ejemplo. Ver la salida:
También podemos usar Java 8 Stream API para realizar la misma operación. Ver ejemplo:
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);
}
}
El código anterior utilizará la API de flujo de Java 8 para dividir la lista en tres partes. Ver la salida:
Utilice el método Collectors.groupingBy() para dividir una lista en fragmentos en Java
El método Collectors.groupingBy() de Java Stream API también se puede usar para dividir una lista en fragmentos, donde agrupamos por elementos de lista para crear fragmentos. Este método devolverá los fragmentos en forma de mapas.
Veamos un ejemplo:
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);
}
}
El código anterior utilizará la funcionalidad de agrupación para crear fragmentos de la lista dada en Java. Ver la salida:
De manera similar, podemos simplificar el código anterior usando un contador mutable. Ver el ejemplo:
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);
}
}
El código anterior usa el contador mutable AtomicInteger para agrupar por la lista para crear fragmentos de tamaño tres. Ver la salida:
Utilice el método de colecciones de Apache Commons para dividir una lista en fragmentos en Java
Apache Commons es una biblioteca de terceros que proporciona muchas operaciones, incluida una lista. La colección de Apache Commons también se puede usar para crear fragmentos de listas en Java.
Primero, asegúrese de agregar Apache Commons a su ruta de compilación. Probemos un ejemplo para crear fragmentos de la lista usando Apache Commons Collections:
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 proporciona un método llamado partición, que se utiliza para crear fragmentos de la lista dada. Ver la salida:
Utilice la biblioteca de guayaba de Google para dividir una lista en fragmentos en Java
El paquete Guava de Google también proporciona muchas funcionalidades con respecto a las listas en Java. Proporciona un método, Lists.partition(), que se utiliza para crear fragmentos de una lista en Java.
Asegúrese de agregar el paquete Guava a su ruta de compilación porque es un paquete de terceros y no está incluido en JDK. Probemos un ejemplo:
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);
}
}
El código anterior creará de manera similar fragmentos de la lista dada en forma de tres utilizando el método de partición () de la biblioteca Guava. Ver la salida:
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