我为自己编写了一个实用程序，将列表分解为给定大小的批次。我只是想知道是否已经有任何apache commons util用于此。
public static <T> List<List<T>> getBatches(List<T> collection,int batchSize){
int i = 0;
List<List<T>> batches = new ArrayList<List<T>>();
while(i<collection.size()){
int nextInc = Math.min(collection.size()-i,batchSize);
List<T> batch = collection.subList(i,i+nextInc);
batches.add(batch);
i = i + nextInc;
}
return batches;
}
请让我知道是否有任何现有的公用事业已经相同。
当前回答
解决这个问题的另一个方法是:
public class CollectionUtils {
/**
* Splits the collection into lists with given batch size
* @param collection to split in to batches
* @param batchsize size of the batch
* @param <T> it maintains the input type to output type
* @return nested list
*/
public static <T> List<List<T>> makeBatch(Collection<T> collection, int batchsize) {
List<List<T>> totalArrayList = new ArrayList<>();
List<T> tempItems = new ArrayList<>();
Iterator<T> iterator = collection.iterator();
for (int i = 0; i < collection.size(); i++) {
tempItems.add(iterator.next());
if ((i+1) % batchsize == 0) {
totalArrayList.add(tempItems);
tempItems = new ArrayList<>();
}
}
if (tempItems.size() > 0) {
totalArrayList.add(tempItems);
}
return totalArrayList;
}
}
其他回答
下面是使用Java 8 Streams的解决方案:
//Sample Input
List<String> input = new ArrayList<String>();
IntStream.range(1,999).forEach((num) -> {
input.add(""+num);
});
//Identify no. of batches
int BATCH_SIZE = 10;
int multiples = input.size() / BATCH_SIZE;
if(input.size()%BATCH_SIZE!=0) {
multiples = multiples + 1;
}
//Process each batch
IntStream.range(0, multiples).forEach((indx)->{
List<String> batch = input.stream().skip(indx * BATCH_SIZE).limit(BATCH_SIZE).collect(Collectors.toList());
System.out.println("Batch Items:"+batch);
});
另一种方法是使用收集器。索引的groupingBy，然后将分组索引映射到实际元素:
final List<Integer> numbers = range(1, 12)
.boxed()
.collect(toList());
System.out.println(numbers);
final List<List<Integer>> groups = range(0, numbers.size())
.boxed()
.collect(groupingBy(index -> index / 4))
.values()
.stream()
.map(indices -> indices
.stream()
.map(numbers::get)
.collect(toList()))
.collect(toList());
System.out.println(groups);
输出:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11]
下面的例子演示了一个List的分块:
package de.thomasdarimont.labs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SplitIntoChunks {
public static void main(String[] args) {
List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
List<List<Integer>> chunks = chunk(ints, 4);
System.out.printf("Ints: %s%n", ints);
System.out.printf("Chunks: %s%n", chunks);
}
public static <T> List<List<T>> chunk(List<T> input, int chunkSize) {
int inputSize = input.size();
int chunkCount = (int) Math.ceil(inputSize / (double) chunkSize);
Map<Integer, List<T>> map = new HashMap<>(chunkCount);
List<List<T>> chunks = new ArrayList<>(chunkCount);
for (int i = 0; i < inputSize; i++) {
map.computeIfAbsent(i / chunkSize, (ignore) -> {
List<T> chunk = new ArrayList<>();
chunks.add(chunk);
return chunk;
}).add(input.get(i));
}
return chunks;
}
}
输出:
Ints: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
Chunks: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11]]
进口com.google.common.collect.Lists;
列表<列表<T>>批次 = 列表.分区（<T>列表，批量大小）
使用Lists.partition(列表、batchSize)。您需要从谷歌公共包(com.google.common.collect.Lists)导入列表。
它将返回List of List<T> with和每个元素的大小等于你的batchSize。
注意，List#subList()返回底层集合的视图，这在编辑较小的列表时可能会导致意想不到的结果——编辑将反映在原始集合中，或者可能抛出ConcurrentModificationException。
