java 怎么将list 均分成多个

### 回答1：
可以使用 Java 中的 sublist 方法将 List 均分成多个子 List。具体实现可以参考以下代码：

public static <T> List<List<T>> splitList(List<T> list, int size) {
    List<List<T>> result = new ArrayList<>();
    int count = (list.size() + size - 1) / size;
    for (int i = ; i < count; i++) {
        int fromIndex = i * size;
        int toIndex = Math.min((i + 1) * size, list.size());
        result.add(list.subList(fromIndex, toIndex));
    }
    return result;
}

其中，list 表示要分割的 List，size 表示每个子 List 的大小。该方法返回一个 List，其中每个元素都是一个子 List。

### 回答2：
在Java中，可以通过以下方式将List均分为多个子列表。

首先，确定每个子列表的大小，即每个子列表中元素的个数。可以通过计算List的大小除以子列表的个数来得到这个值。

然后，通过循环迭代的方式将List中的元素按照确定的每个子列表的大小进行分割。可以使用List的subList方法来截取对应大小的子列表。

下面是一个示例代码：

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

public class ListPartitioning {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        // 假设有一个大小为10的List
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        
        // 假设要将List均分成3份
        int partitionSize = list.size() / 3;
        
        List<List<Integer>> partitions = new ArrayList<>();
        int fromIndex = 0;
        int toIndex = partitionSize;

        // 循环迭代分割List并添加到子列表中
        for (int i = 0; i < 3; i++) {
            if (i == 2) {
                toIndex = list.size();  // 最后一份可能不够分，将toIndex设为List的末尾
            }
            List<Integer> partition = list.subList(fromIndex, toIndex);
            partitions.add(partition);
            fromIndex = toIndex;
            toIndex += partitionSize;
        }
        
        // 打印结果
        for (List<Integer> partition : partitions) {
            System.out.println(partition);
        }
    }
}

以上代码将一个大小为10的List均分为3个子列表，结果如下：

[1, 2, 3]

[4, 5, 6]

[7, 8, 9, 10]

### 回答3：
要将一个List均分成多个子List，可以使用以下方法：

1. 获取原始List的大小，假设为totalSize。
2. 定义子List的大小，假设为subListSize。
3. 计算需要分成的子List数量，假设为subListCount，可以使用Math.ceil(totalSize / subListSize)来得到向上取整的结果。
4. 创建一个新的ArrayList来存储所有子List，假设为resultList。
5. 根据subListCount，循环subListCount次来创建子List：
1. 计算当前子List的起始索引，假设为start。
2. 计算当前子List的结束索引，假设为end。当达到最后一个子List时，结束索引为totalSize。
3. 使用List的subList方法，将原始List的[start, end)区间的元素作为一个新的子List，并将其添加到resultList中。
6. 返回resultList作为分割好的子List集合。

下面是一个示例代码：

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

public class ListPartition {
    public static List<List<Integer>> partitionList(List<Integer> originalList, int subListSize) {
        int totalSize = originalList.size();
        int subListCount = (int) Math.ceil((double) totalSize / subListSize);
        List<List<Integer>> resultList = new ArrayList<>();
        
        for (int i = 0; i < subListCount; i++) {
            int start = i * subListSize;
            int end = Math.min(start + subListSize, totalSize);
            List<Integer> subList = originalList.subList(start, end);
            resultList.add(subList);
        }
        
        return resultList;
    }

    public static void main(String[] args) {
        List<Integer> originalList = new ArrayList<>();
        originalList.add(1);
        originalList.add(2);
        originalList.add(3);
        originalList.add(4);
        originalList.add(5);

        List<List<Integer>> partitionedList = partitionList(originalList, 2);
        for (List<Integer> subList : partitionedList) {
            System.out.println(subList);
        }
    }
}

以上示例代码将会把原始List [1, 2, 3, 4, 5] 分成两个子List [1, 2] 和 [3, 4, 5]，并打印出来。