list的分批处理实现的几种方式

在项目中，我们经常会遇到list集合数据量过大，考虑到处理性能，需要对这个list集合进行分批处理的情况；

---

以下是自己参考和整理list的分批处理的几种常用处理方法：

1、使用Sublist实现list的分批处理

		// 创建模拟list
        List<Integer> dataList = new ArrayList<>();
        for (int i = 1; i <= 22; i++) {
            dataList.add(i);
        }
        // 每批次数据记录数量
        int partialLimit = 5;
        //判断是否有必要分批
        if (partialLimit < dataList.size()) {
            //当前数据按限制条数可分为多少批次
            int part = dataList.size()/partialLimit;
            List<Integer> partList;
            for (int i = 0; i < part; i++) {
                // 截取批次长度的list
                partList = dataList.subList(0, partialLimit);
                // 分批业务逻辑处理- 打印替代
                System.out.println(partList);
                // 去除已经处理的部分 (Arrays.asList()方式生成的数据不能进行此修改操作，会报错)
                partList.clear();
            }
            // 获取最后一次截取后的剩余列表数据
            if (!dataList.isEmpty()) {
                // 业务逻辑数据处理， - 打印替代
                System.out.println(dataList);
            }
        } else {
            System.out.println("数据不需要分批，直接进行业务逻辑处理！");
        }

结果集：

[1, 2, 3, 4, 5]
[6, 7, 8, 9, 10]
[11, 12, 13, 14, 15]
[16, 17, 18, 19, 20]
[21, 22]

2、使用stream流实现list的分批处理方式1

		// 按每5个一组分割
        Integer partialLimit = 5;
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7,8,9,10);
        // 获取需要分割的次数，注意不能直接除以批次数量
        int limit = (list.size()+partialLimit -1)/partialLimit;
        // 使用流遍历操做
        List<List<Integer>> mglist = new ArrayList<>();
        Stream.iterate(0, n -> n + 1).limit(limit).forEach(i -> {
            mglist.add(list.stream().skip(i * partialLimit).limit(partialLimit).collect(Collectors.toList()));
        });
        System.out.println(mglist);

结果集：

使用stream流做list分批处理方式1
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]

3、使用stream的parallel实现list的分批处理

		// 按每5个一组分割
        Integer partialLimit = 5;
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7,8,9,10);
        // 获取需要分割的次数，注意不能直接除以批次数量,会丢失数据;
        int limit = (list.size()+partialLimit -1)/partialLimit;
        // 获取分割后的集合
        List<List<Integer>> splitList = Stream.iterate(0, n -> n + 1).limit(limit).parallel()
                .map(a -> list.stream().skip(a * partialLimit).limit(partialLimit).parallel()
                .collect(Collectors.toList())).collect(Collectors.toList());
        // 执行具体业务方法。打印代替
        System.out.println(splitList);

结果集：

使用stream流做list分批处理方式2
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]

4、手动循环添加新的list实现分批

		// 创建模拟list
        List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 分批的list
        List<Integer> partialList = new ArrayList();
        // 分批的大小，每组5条
        int partialDataLimit = 5;
        //分批处理判断
        if(partialDataLimit < intList.size()) {
           // 开始对数据进行分批处理
            for (int i = 0; i < intList.size(); i++) {
                partialList.add(intList.get(i));
                // 达到批次数量后执行业务处理，在清空
                if (partialDataLimit == partialList.size() || i == intList.size() - 1) {
                    // 对分批list的具体业务处理 process(list) - 打印代替
                    System.out.println(partialList);
                    // 清空分批list数据，再次循环分批处理
                    partialList.clear();
                }
            }
        } else {
            System.out.println("未达到分批处理数据量，直接处理！");
        }

结果集：

手动循环添加新的list实现分区；
[1, 2, 3, 4, 5]
[6, 7, 8, 9, 10]

5、使用apache 的 collection 工具提供方法实现lsit分批

		// 创建模拟list
        List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 按5个每组进行分割
        List<List<Integer>> subs = ListUtils.partition(intList, 5);
        // 对分批list的具体业务处理 process(list) - 打印代替
        System.out.println(subs);

结果集：

使用apache common collection 实现分批
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]

此方式需要在项目中引入apache 的pom包依赖：

		<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>

6、使用google guava 工具提供方法对List进行分割

		// 创建模拟list
        List<Integer> tempList = new ArrayList<>();
        for (int i = 1; i <= 20; i++) {
            tempList.add(i);
        }
        //按每5个一组分割
        List<List<Integer>> parts = Lists.partition(tempList, 5);
        // 对分批list的具体业务处理 process(list) - 打印代替
        System.out.println(parts);

结果集：

使用google guava分割
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]

此方式需要在项目中引入guava的pom包依赖：

		<dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>18.0</version>
        </dependency>

以上为自己整理平常可用来实现list分批的方式，具体要选择哪种可根据项目实际情况而定！

后附部分方式借鉴原出地址：
https://www.jianshu.com/p/447a26a6127d