我为自己编写了一个实用程序，将列表分解为给定大小的批次。我只是想知道是否已经有任何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;
}
请让我知道是否有任何现有的公用事业已经相同。
当前回答
利用网上的各种作弊方法，我找到了这个解决方案:
int[] count = new int[1];
final int CHUNK_SIZE = 500;
Map<Integer, List<Long>> chunkedUsers = users.stream().collect( Collectors.groupingBy(
user -> {
count[0]++;
return Math.floorDiv( count[0], CHUNK_SIZE );
} )
);
我们使用count来模拟普通的集合索引。 然后，以代数商作为桶号，将集合元素分组到桶中。 最后一个映射包含作为键的桶号，作为值的桶本身。
然后，您可以轻松地对每个桶执行操作:
chunkedUsers.values().forEach( ... );
其他回答
在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]]
另一种方法是使用收集器。索引的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]
下面是使用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);
});
使用Apache Commons ListUtils.partition。
org.apache.commons.collections4.ListUtils.partition(final List<T> list, final int size)
还有一个问题和这个问题完全一样，但如果你仔细阅读，你会发现它有微妙的不同。因此，如果有人(比如我)真的想将一个列表分割成给定数量的几乎相同大小的子列表，那么请继续阅读。
我只是简单地将这里描述的算法移植到Java。
@Test
public void shouldPartitionListIntoAlmostEquallySizedSublists() {
List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f", "g");
int numberOfPartitions = 3;
List<List<String>> split = IntStream.range(0, numberOfPartitions).boxed()
.map(i -> list.subList(
partitionOffset(list.size(), numberOfPartitions, i),
partitionOffset(list.size(), numberOfPartitions, i + 1)))
.collect(toList());
assertThat(split, hasSize(numberOfPartitions));
assertEquals(list.size(), split.stream().flatMap(Collection::stream).count());
assertThat(split, hasItems(Arrays.asList("a", "b", "c"), Arrays.asList("d", "e"), Arrays.asList("f", "g")));
}
private static int partitionOffset(int length, int numberOfPartitions, int partitionIndex) {
return partitionIndex * (length / numberOfPartitions) + Math.min(partitionIndex, length % numberOfPartitions);
}
