在某些业务中，当一个list的数据量很大时， 就可能会考虑进行拆分。比如导出数据， 每N条追加写入表格； 提交数据库，每N条执行一次insert 等诸多场景。下面写了三种拆分list 的方法。

package com.yulisao.util;

import org.springframework.util.CollectionUtils;

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

/**
 * 把list拆分成多个 三个不同的方法，任选一个调用即可
 * @param <E>
 */
public class BatchListUtil<E> {
    
    

    /**
     * 拆分list
     * @param list
     * @param batchSize 每个批次多少条数据
     * @Desc 遍历list，每N条添加一次
     * @return
     */
    public List<List<E>> batchList(List<E> list, int batchSize){
    
    
        List<List<E>> resp = new ArrayList<>();
        List<E> batchList = new ArrayList<E>(); // 批次list
        for(E e : list){
    
    
            if(batchList.size() == batchSize){
    
     // 每当batchList达到batchSize时，新建一个batchList存放后续的数据
                resp.add(batchList);
                batchList = new ArrayList<E>();
            }
            batchList.add(e);
        }

        resp.add(batchList);// 最后一个批次不足或者刚好等于batchSize时不会进入上面的if，所以这里补充添加进去
        return resp;
    }

    /**
     * 拆分list
     * @param list
     * @param batchSize 每个批次多少条数据
     * @Desc 遍历list，每N条遍历一次，每次添加了N条
     * @return
     */
    public List<List<E>> batchList2(List<E> list, int batchSize) {
    
    
        List<List<E>> resp = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
    
    
            for (int i = 0; i < list.size(); i += batchSize) {
    
    
                if (i + batchSize > list.size()) {
    
     // 最后一次循环剩余条数不足batchSize则剩余多少条装实际装多少条
                    batchSize = list.size() - i;
                }
                resp.add(list.subList(i, i + batchSize)); // list的分页
            }
        }
        return resp;
    }

    /**
     * 拆分list
     * @param list
     * @param batchSize 每个批次多少条数据
     * @Desc 每添加N条 总数-N
     * @return
     */
    public List<List<E>> batchList3(List<E> list, int batchSize) {
    
    
        List<List<E>> resp = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
    
    
            int tatolSize = list.size(); // 待处理条数
            int k = 0; // 已处理的条数
            while (tatolSize > batchSize) {
    
    
                resp.add(list.stream().skip(k).limit(batchSize).collect(Collectors.toList())); // list的分页
                k = k + batchSize;
                tatolSize = tatolSize - batchSize;
            }
            if (tatolSize > 0) {
    
     // 最后一次数量不足或刚好等于batchSize时，作为一个批次
                resp.add(list.stream().skip(k).limit(tatolSize).collect(Collectors.toList()));
            }
        }

        return resp;
    }

}

测试方法

package com.yulisao.test;

import com.yulisao.util.BatchListUtil;

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

/**
 * author yulisao
 * createDate 2023/4/26
 */
public class Test {
    
    

    public static void main(String[] args) {
    
    
        
        // 造测试数据
        List<Integer> list = initList();
        // 每10条进行拆分list
        List<List<Integer>> resp = new BatchListUtil<Integer>().batchList(list,10);
        System.out.println();
        List<List<Integer>> resp1 = new BatchListUtil<Integer>().batchList2(list,10);
        System.out.println();
        List<List<Integer>> resp2 = new BatchListUtil<Integer>().batchList3(list,10);
        System.out.println();
    }

    /**
     * 添加测试数据
     * @return
     */
    private static List<Integer> initList() {
    
    
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 103; i++) {
    
    
            list.add(i);
        }
        return list;
    }
}