我为自己编写了一个实用程序，将列表分解为给定大小的批次。我只是想知道是否已经有任何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;
}
请让我知道是否有任何现有的公用事业已经相同。
当前回答
Java 8中的一行代码是:
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.*;
private static <T> Collection<List<T>> partition(List<T> xs, int size) {
return IntStream.range(0, xs.size())
.boxed()
.collect(collectingAndThen(toMap(identity(), xs::get), Map::entrySet))
.stream()
.collect(groupingBy(x -> x.getKey() / size, mapping(Map.Entry::getValue, toList())))
.values();
}
其他回答
下面是一个使用普通java和超级秘密模运算符的解决方案:)
考虑到块的内容/顺序并不重要，这将是最简单的方法。(当为多线程准备东西时，这通常并不重要，例如哪个元素在哪个线程上处理，只需要均匀分布)。
public static <T> List<T>[] chunk(List<T> input, int chunkCount) {
List<T>[] chunks = new List[chunkCount];
for (int i = 0; i < chunkCount; i++) {
chunks[i] = new LinkedList<T>();
}
for (int i = 0; i < input.size(); i++) {
chunks[i % chunkCount].add(input.get(i));
}
return chunks;
}
用法:
List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f", "g", "h", "i", "j");
List<String>[] chunks = chunk(list, 4);
for (List<String> chunk : chunks) {
System.out.println(chunk);
}
输出:
[a, e, i]
[b, f, j]
[c, g]
[d, h]
我想到了这个:
private static <T> List<List<T>> partition(Collection<T> members, int maxSize)
{
List<List<T>> res = new ArrayList<>();
List<T> internal = new ArrayList<>();
for (T member : members)
{
internal.add(member);
if (internal.size() == maxSize)
{
res.add(internal);
internal = new ArrayList<>();
}
}
if (internal.isEmpty() == false)
{
res.add(internal);
}
return res;
}
下面的例子演示了一个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]]
在Java 9中，你可以使用带有hasNext条件的IntStream.iterate()。所以你可以把方法的代码简化成这样:
public static <T> List<List<T>> getBatches(List<T> collection, int batchSize) {
return IntStream.iterate(0, i -> i < collection.size(), i -> i + batchSize)
.mapToObj(i -> collection.subList(i, Math.min(i + batchSize, collection.size())))
.collect(Collectors.toList());
}
使用{0,1,2,3,4,5,6,7,8,9}，getbatch (numbers, 4)的结果将是:
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9]]
您可以使用下面的代码来获得该批列表。
Iterable<List<T>> batchIds = Iterables.partition(list, batchSize);
你需要导入谷歌番石榴库来使用上面的代码。
