迹忆客 专注技术分享

有时需要在 Java 中将列表拆分为特定大小的块。 Java 中有不同的功能可以实现这一点。

本文介绍了在 Java 中将列表拆分为块的不同方法。

在 Java 中使用 List.subList() 方法将列表拆分为块

在 Java 中，List.subList 方法可以与 for 循环一起使用，将列表拆分为特定大小的块。 subList() 方法将从给定列表中获取特定开始和结束索引内的子列表。

让我们看一个例子：

package jiyik;

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);
    }
}

上面的代码将从给定列表中创建大小为 3 的块。 查看输出：

类似地，我们可以使用 Java 9 IntStream.iterate() 将列表拆分为 Java 中的块。 参见示例：

package jiyik;

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);
    }
}

上面的代码将使用 Java 9 中的 IntStream.iterate() 来执行与第一个示例相同的操作。 查看输出：

我们还可以使用Java 8 Stream API来执行相同的操作。 参见示例：

package jiyik;

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);
    }
}

上面的代码将使用 Java 8 Stream API 将列表拆分为三个块。 查看输出：

在 Java 中使用 Collectors.groupingBy() 方法将列表拆分为块

Java Stream API 中的 Collectors.groupingBy() 方法也可用于将列表拆分为块，其中我们按列表元素进行分组以创建块。 该方法将以Maps的形式返回块。

让我们看一个例子：

package jiyik;

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);
    }
}

上面的代码将使用分组功能在 Java 中创建给定列表的块。 查看输出：

同样，我们可以使用可变计数器来简化上面的代码。 参见示例：

package jiyik;

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);
    }
}

上面的代码使用可变计数器 AtomicInteger 按列表进行分组以创建大小为 3 的块。 查看输出：

使用 Apache Commons Collections 方法在 Java 中将列表拆分为块

Apache Commons 是一个第三方库，提供许多操作，包括列表。 Apache Commons 中的集合还可用于在 Java 中创建列表块。

首先，确保 Apache Commons 已添加到您的构建路径中。 让我们尝试使用 Apache Commons Collections 创建列表块的示例：

package jiyik;

import org.apache.commons.collections4.ListUtils;

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>> Chunks = ListUtils.Chunk(DemoList, ChunkSize);
        System.out.println(Chunks);
    }
}

Apache Commons 提供了一种称为分区的方法，用于创建给定列表的块。 查看输出：

使用 Google Guava 库在 Java 中将列表拆分为块

Google 的 Guava 包还提供了许多有关 Java 列表的功能。 它提供了一个方法 Lists.partition()，用于在 Java 中创建列表块。

请确保 Guava 包已添加到您的构建路径中，因为它是第三方包且不包含在 JDK 中。 让我们尝试一个例子：

package jiyik;

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);
    }
}

上面的代码将类似地使用 Guava 库的 partition() 方法以三个的形式创建给定列表的块。 查看输出：