Java将List平均分成多少份或者按照指定大小进行分割

目录

• • [1. 将List平均分成多少份](#1. 将List平均分成多少份)
  • [2. 将List按照每份指定的大小进行分割](#2. 将List按照每份指定的大小进行分割)
  • [3. 完整代码示例以及测试](#3. 完整代码示例以及测试)

前言：此方法其实就是将一个列表按照指定份数或者指定大小对数据列表进行分割，如果不能整除则会将剩余的放到最后一个数组

1. 将List平均分成多少份

/**
 * 将List平均分成多少份
 *
 * @param list  数据列表
 * @param parts 份数
 * @param <T>
 * @return
 */
public static <T> List<List<T>> splitListForParts(List<T> list, int parts) {
    List<List<T>> res = new ArrayList<>();
    // 总数
    int total = list.size();
    // 计算每份多少个, 下面两种写法效果一致
    int chunkSize = (total + parts - 1) / parts; // 向下取整
    //int chunkSize = total % parts == 0 ? total / parts : total / parts + 1;

    // 第一种写法
    for (int i = 0; i < total; i += chunkSize) {
        // 计算end的大小, 如果大于总数则取总数, 下面两种写法效果一致
        //int end = i + chunkSize > total ? total : i + chunkSize;
        int end = Math.min(i + chunkSize, total);
        res.add(list.subList(i, end));
    }
    return res;
}

2. 将List按照每份指定的大小进行分割

/**
 * 将List按照每份指定的大小进行分割
 *
 * @param list      数据列表
 * @param chunkSize 每份的大小
 * @param <T>
 * @return
 */
public static <T> List<List<T>> splitListForChunkSize(List<T> list, int chunkSize) {
    List<List<T>> res = new ArrayList<>();
    // 总数
    int total = list.size();
    // 如果每份的大小大于或等于总数则直接返回
    if (chunkSize >= total) {
        res.add(list);
        return res;
    }

    // 第二种写法
    int page = 0;
    while (true) {
        int start = page * chunkSize;
        int end = (page + 1) * chunkSize;
        // 如果end大于total则说明是最后一页
        if (end > total) {
            if (start < total) {
                res.add(list.subList(start, total));
            }
            break;
        }

        // 非最后一页正常获取
        res.add(list.subList(start, end));

        // 页码每次加1
        page += 1;
    }
    return res;
}

3. 完整代码示例以及测试

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

public class ListTest {

    /**
     * 将List平均分成多少份
     *
     * @param list  数据列表
     * @param parts 份数
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> splitListForParts(List<T> list, int parts) {
        List<List<T>> res = new ArrayList<>();
        // 总数
        int total = list.size();
        // 计算每份多少个, 下面两种写法效果一致
        int chunkSize = (total + parts - 1) / parts; // 向下取整
        //int chunkSize = total % parts == 0 ? total / parts : total / parts + 1;

        // 第一种写法
        for (int i = 0; i < total; i += chunkSize) {
            // 计算end的大小, 如果大于总数则取总数, 下面两种写法效果一致
            //int end = i + chunkSize > total ? total : i + chunkSize;
            int end = Math.min(i + chunkSize, total);
            res.add(list.subList(i, end));
        }

//        // 第二种写法
//        int page = 0;
//        while (true) {
//            int start = page;
//            int end = page + chunkSize;
//            // 如果end大于total则说明是最后一页
//            if (end > total) {
//                if (start < total) {
//                    res.add(list.subList(start, total));
//                }
//                break;
//            }
//
//            // 非最后一页正常获取
//            res.add(list.subList(start, end));
//
//            // 页码加每份的大小
//            page += chunkSize;
//        }

//        // 第三种写法
//        int page = 0;
//        while (true) {
//            int start = page * chunkSize;
//            int end = (page + 1) * chunkSize;
//            // 如果end大于total则说明是最后一页
//            if (end > total) {
//                if (start < total) {
//                    res.add(list.subList(start, total));
//                }
//                break;
//            }
//
//            // 非最后一页正常获取
//            res.add(list.subList(start, end));
//
//            // 页码每次加1
//            page += 1;
//        }

        return res;
    }

    /**
     * 将List按照每份指定的大小进行分割
     *
     * @param list      数据列表
     * @param chunkSize 每份的大小
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> splitListForChunkSize(List<T> list, int chunkSize) {
        List<List<T>> res = new ArrayList<>();
        // 总数
        int total = list.size();
        // 如果每份的大小大于或等于总数则直接返回
        if (chunkSize >= total) {
            res.add(list);
            return res;
        }

//        // 第一种写法
//        for (int i = 0; i < total; i += chunkSize) {
//            // 计算end的大小, 如果大于总数则取总数, 下面两种写法效果一致
//            //int end = i + chunkSize > total ? total : i + chunkSize;
//            int end = Math.min(i + chunkSize, total);
//            res.add(list.subList(i, end));
//        }

        // 第二种写法
        int page = 0;
        while (true) {
            int start = page * chunkSize;
            int end = (page + 1) * chunkSize;
            // 如果end大于total则说明是最后一页
            if (end > total) {
                if (start < total) {
                    res.add(list.subList(start, total));
                }
                break;
            }

            // 非最后一页正常获取
            res.add(list.subList(start, end));

            // 页码每次加1
            page += 1;
        }

        return res;
    }


    public static void main(String[] args) {
        int total = 500;
        List<Integer> numbers = new LinkedList<>();
        for (int i = 1; i < total; i++) numbers.add(i);

        // 将列表平均分成7份
        List<List<Integer>> parts = splitListForParts(numbers, 7);
        parts.forEach(System.out::println);
        System.out.println("----------------splitListForParts 将List平均分成多少份结束");

        // 将列表按照每份133的大小进行分割
        List<List<Integer>> chunkSize = splitListForChunkSize(numbers, 133);
        chunkSize.forEach(System.out::println);
        System.out.println("----------------splitListForChunkSize 将List按照每份指定的大小进行分割");
    }

}