如何在Java中将List拆分为指定大小的多个List

在Java开发中，将大List按指定大小拆分为多个小List是常见需求，比如批量插入数据库、分批调用接口时，都需要控制每次处理的数据量。除了手动编写循环拆分代码，还可以借助Stream的分批归约特性和Guava工具包快速实现，两种方式各有优势，适配不同的开发场景。

手动循环拆分的基础实现

如果不依赖第三方工具，最基础的实现方式是遍历原List，按指定大小切割并添加到结果集合中，核心逻辑是计算起始和结束索引，避免索引越界。以下是手动拆分的示例代码：

import java.util.ArrayList;
import java.util.List;

public class ListSplitDemo {
    public static <T> List<List<T>> splitByLoop(List<T> sourceList, int batchSize) {
        List<List<T>> result = new ArrayList<>();
        if (sourceList == null || sourceList.isEmpty() || batchSize <= 0) {
            return result;
        }
        int totalSize = sourceList.size();
        // 遍历原List，按batchSize切割
        for (int i = 0; i < totalSize; i += batchSize) {
            int end = Math.min(i + batchSize, totalSize);
            result.add(new ArrayList<>(sourceList.subList(i, end)));
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> testList = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            testList.add(i);
        }
        List<List<Integer>> splitResult = splitByLoop(testList, 3);
        for (List<Integer> subList : splitResult) {
            System.out.println(subList);
        }
    }
}

手动拆分的方式逻辑清晰，不需要额外依赖，但是代码量相对较多，如果项目中频繁需要拆分List，重复编写这类代码会降低开发效率。

使用Stream API的分批归约实现

Java 8引入的Stream API提供了强大的集合处理能力，我们可以通过IntStream生成索引区间，结合mapToObj操作实现List拆分，这种方式代码更简洁，符合函数式编程的风格。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class StreamSplitDemo {
    public static <T> List<List<T>> splitByStream(List<T> sourceList, int batchSize) {
        if (sourceList == null || sourceList.isEmpty() || batchSize <= 0) {
            return new ArrayList<>();
        }
        int totalSize = sourceList.size();
        // 计算需要拆分成多少个子List
        int batchCount = (totalSize + batchSize - 1) / batchSize;
        return IntStream.range(0, batchCount)
                .mapToObj(i -> {
                    int start = i * batchSize;
                    int end = Math.min(start + batchSize, totalSize);
                    return new ArrayList<>(sourceList.subList(start, end));
                })
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<String> testList = List.of("a", "b", "c", "d", "e", "f", "g");
        List<List<String>> splitResult = splitByStream(testList, 2);
        splitResult.forEach(System.out::println);
    }
}

这种实现方式不需要手动写循环，代码更紧凑，适合已经广泛使用Stream API的项目，但是需要理解Stream的索引生成逻辑，对不熟悉函数式编程的开发者来说有一定学习成本。

使用Guava工具包快速拆分

Google的Guava工具包提供了现成的List拆分方法，位于Lists工具类中，只需要一行代码就能完成拆分，是最高效的实现方式。使用前需要先引入Guava依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

拆分的具体代码示例如下：

import com.google.common.collect.Lists;
import java.util.List;

public class GuavaSplitDemo {
    public static void main(String[] args) {
        List<Integer> testList = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        // 直接调用Lists.partition方法拆分，第二个参数是每个子List的大小
        List<List<Integer>> splitResult = Lists.partition(testList, 4);
        splitResult.forEach(System.out::println);
    }
}

Guava的Lists.partition方法内部已经处理了空集合、边界索引等所有边界情况，调用非常简单，适合快速开发场景，但是需要额外引入第三方依赖，如果项目本身没有使用Guava，为了一个拆分功能引入依赖会增加项目的包体积。

三种方式的对比与选择

我们可以通过下表对比三种拆分方式的特性，根据项目实际情况选择：

总的来说，三种方式都能实现List按指定大小拆分的需求，开发者可以根据项目的技术栈和实际需求选择最合适的方案，避免重复编写冗余的拆分代码。

JavaList拆分Stream分批归约Guava修改时间：2026-06-26 09:06:32