map(k,v) 与list<map(k,v)> list<list<map(k,v)>>区别

map(k,v)是一种键值对存储的数据结构，其中k表示键，v表示值。它可以用于存储一组相关的信息，例如一个人的姓名、年龄、性别等。通过键可以快速查找对应的值，时间复杂度为O(1)。

list<map(k,v)>是一个嵌套的数据结构，它表示一个列表，其中每个元素都是一个map(k,v)类型的键值对。这种数据结构可以用于存储多个对象的属性信息，每个map表示一个对象的属性，而所有对象的列表则由list来存储。

list<list<map(k,v)>>是一个更加复杂的嵌套数据结构，它表示一个列表，其中每个元素都是一个list<map(k,v)>类型的嵌套列表。这种数据结构可以用于存储更为复杂的数据结构，例如一个包含多个子列表的数据集合，每个子列表又由多个map表示。

总的来说，map(k,v)适合用于存储单个对象的属性信息，list<map(k,v)>适合用于存储多个对象的属性信息，而list<list<map(k,v)>>则适合用于存储更为复杂的数据结构。在实际应用中，需要根据具体的需求来选择不同的数据结构。

相关问题

Map<String, List<>>转List<List<>>且均匀分配

假设你的 `Map<String, List<?>>` 是这样的：

Map<String, List<?>> map = new HashMap<>();
map.put("key1", Arrays.asList("a", "b", "c"));
map.put("key2", Arrays.asList(1, 2, 3, 4));
map.put("key3", Arrays.asList(true, false));

如果你想把这个 Map 转成一个 List<List<?>>，并且希望每个 List<?> 都具有相同的大小，可以按照以下步骤进行：

1. 计算每个 List<?> 应该具有的大小。

   int totalSize = map.values().stream()
                            .mapToInt(List::size)
                            .sum();
   int subListSize = (int) Math.ceil((double) totalSize / map.size());

`totalSize` 计算了所有 List<?> 的总大小，`subListSize` 则是每个 List<?> 应该具有的大小。使用 `Math.ceil()` 取整能够确保每个 List<?> 的大小都不小于 `subListSize`。

2. 将 Map 转成一个 List<List<?>>。

   List<List<?>> result = new ArrayList<>();
   map.values().forEach(list -> {
       for (int i = 0; i < list.size(); i += subListSize) {
           result.add(list.subList(i, Math.min(i + subListSize, list.size())));
       }
   });

这里使用了两个循环。外层循环遍历 Map 中的每个 List<?>；内层循环则将每个 List<?> 按照 `subListSize` 进行分割，将得到的子列表添加到 `result` 中。

最终，`result` 中的每个元素都是一个具有相同大小的 List<?>。完整代码如下：

Map<String, List<?>> map = new HashMap<>();
map.put("key1", Arrays.asList("a", "b", "c"));
map.put("key2", Arrays.asList(1, 2, 3, 4));
map.put("key3", Arrays.asList(true, false));

int totalSize = map.values().stream()
                         .mapToInt(List::size)
                         .sum();
int subListSize = (int) Math.ceil((double) totalSize / map.size());

List<List<?>> result = new ArrayList<>();
map.values().forEach(list -> {
    for (int i = 0; i < list.size(); i += subListSize) {
        result.add(list.subList(i, Math.min(i + subListSize, list.size())));
    }
});

System.out.println(result); // [[a, b], [c, 1, 2], [3, 4, true], [false]]

Map<String, List<>>转List<List<>>且均匀分配，List<List<>>大小为20

假设Map<String, List<String>>为例，可以按照以下方式转换成List<List<String>>并进行均匀分配：

Map<String, List<String>> map = new HashMap<>();
// 假设map中已经存储了数据

// 将map转换为List<List<String>>
List<List<String>> resultList = new ArrayList<>();
for (Map.Entry<String, List<String>> entry : map.entrySet()) {
    List<String> list = entry.getValue();
    resultList.add(list);
}

// 均匀分配，List<List<>>大小为20
int totalSize = resultList.size();
int maxSize = 20;
int groupCount = totalSize % maxSize == 0 ? totalSize / maxSize : totalSize / maxSize + 1;

List<List<List<String>>> groups = new ArrayList<>();
for (int i = 0; i < groupCount; i++) {
    int startIndex = i * maxSize;
    int endIndex = Math.min(startIndex + maxSize, totalSize);
    List<List<String>> group = new ArrayList<>(resultList.subList(startIndex, endIndex));
    groups.add(group);
}

这段代码中，首先将Map<String, List<String>>转换为List<List<String>>，然后计算出需要分成几组，每组大小为20。最后将List<List<String>>按照均匀分配的规则分成多个List<List<String>>。