Java：转换列表<；列表>；在地图上

给定唯一值子列表的列表（即两个不同的子列表不能共享相同值的元素）-例如：

List[List[1,1,1]，List[2]，List[4,4]，List[7]

如何将其转换为具有（值、大小）键值对的映射

这将导致：

{
  1 : 3
  2 : 1
  4 : 2
  7 : 1
}

将我们的列表定义为

值

，我假设可以使用流并将其收集为地图：

values.stream（）.collect（Collectors.toMap（Integer:：intValue，？）

目前不确定为第二个参数输入什么，因为它需要一个
值映射器
，但不允许对任何子列表调用
.size（）
。
您可以展平列表，然后使用类似Collectors.groupingBy（Function.identity（），Collectors.counting（））的东西。
然而，在这种情况下，我想说一个好的旧（嵌套）for循环可能更易于编写和读取

List<List<Integer>> lst = Arrays.asList(Arrays.asList(1,1,1),Arrays.asList(2),Arrays.asList(4,4),Arrays.asList(7));

Map<Integer,Integer> result= new HashMap<Integer,Integer>();
System.out.println(lst);
//[[1, 1, 1], [2], [4, 4], [7]]

for(List<Integer> sub:lst){
  for(int n:sub){
    Integer last=result.get(n);
    int newCount=(last==null?0:last)+1;
    result.put(n, newCount);
  }
}
System.out.println(result);
//{1=3, 2=1, 4=2, 7=1}

List lst=Arrays.asList（Arrays.asList（1,1,1）、Arrays.asList（2）、Arrays.asList（4,4）、Arrays.asList（7））；
映射结果=新的HashMap（）；
系统输出打印项次（lst）；
//[[1, 1, 1], [2], [4, 4], [7]]
对于（列表子项：lst）{
用于（int n:sub）{
整数last=result.get（n）；
int newCount=（last==null？0:last）+1；
结果.put（n，newCount）；
}
}
系统输出打印项次（结果）；
//{1=3, 2=1, 4=2, 7=1}
使用收集器.toMap

时，需要指定如何从流的每个元素中获取键和值<代码>整数：：intValue在这里不起作用，因为流元素是列表，而不是整数

对于键，获取列表的第一个元素。（这假设内部列表都是非空的。）对于值，传递

size

方法引用

values.stream()
    .collect(Collectors.toMap(list -> list.get(0), List::size));

我认为这是最优雅的。但是，它假定所有列表都不是空的。当然，只需在

收集

还原操作之前添加

.filter（list->！list.isEmpty（））

即可轻松解决此问题

这是另一种方法，它不再认为列表是“二维的”，也就是说，

list

，而是将其扁平化为一个

Integer

s流

Map<Integer, Long> map = lists.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

Map Map=lists.stream（）
.flatMap（集合：：流）
.collect（Collectors.groupingBy（Function.identity（）、Collectors.counting（））；

当输入为

List[List[1,1,1,6]，List[2]，List[4,4]，List[7,6]]时，预期输出是什么真的很重要。

。在这种情况下，两个答案的结果会有所不同。这确实会产生完全不同的结果。目前，所有发布的答案都存在这种异常。当输入为

List[List[1,1,1,6]，List[2]，List[4,4]，List[7,6]]

时，预期的输出是什么？它应该是

{1:4,2:1,4:2,7:2}

还是

{1:3,2:1,4:2,6:2,7:1}

？@Naman我们假设输入只包含在各自列表中具有相等值的元素的列表<代码>列表[1, 1, 1，6 ] < /代码>不适合这个描述。好的，然后考虑输入<代码>列表[List]（1, 1, 1），列表[2 ]，列表[4, 4 ]，列表[7 ]，列表[1, 1 ]。，您现在对输出的期望是什么？您提出了很好的边缘案例-我将更新我的问题，以注意任何两个子列表中不包括自身的元素之间的唯一性。根据另一个答案，不清楚的是。可能值得一提。