Question

我有List[List[(Char,Int)]]。假设它是

List(List(('a',10), ('b',12)))

我想要做的是将一堆元素连接到它，但它们也应该来自列表。为了让自己更清楚一点：

我有清单：

List(List(('a',9),('a',8) ... ('a',1)))

我想对这个列表做些什么是采取每个元素（立即让我想到地图）并将它们添加到我的原始列表，但作为一个不同的列表。我不确定这是否有意义，所以让我以视觉方式向您展示我想要的东西：

// The original list should look something like this
List(List(('a',10),('b',12)), List('a',9), List('a',8) ... List('a',1))

到目前为止，我没有返回正确的结果，因为它将整个列表转换为列表本身，而不是将每个元素转换为列表。以下是我到目前为止的情况：

//This is hard coded. 
List(List(('a',10) , ('b',12))) :::  List((for(c <- 1 to 10) yield ('a',c)).toList)

这将返回以下内容：

List(List(('a',10),('b',12)), List( ('a',10), ('a',9 )... ('a', 1)))

我的想法一直困在你在ruby中的方式（每个声明）。

请您指出我应该可以用于这种事情的正确功能吗？有没有更简单的方法来做这样的事情？

Answer 1

val l1 = List(List(('a',10), ('b',12)))
val l2 = List(List(('a',9),('a',8),('a',1)))

val concat = l1 ::: l2.flatMap(x=>x.map(y=>List(y)))

将l2的每个元素添加到l1封装到自己的List中。

如何思考'功能'：找出每次应用函数将输入转换为输出的步骤：

l1没问题，所以我们保持原样
l2：最简单的方法是在第一个List结构“内部”并将每个第二级元素转换为列表封装元素。

你可以想到是一个嵌套的地图：

l2.map(internalList => internalList.map(element => List(element)))
res10: List[List[List[(Char, Int)]]] = List(List(List((a,9)), List((a,8)), List((a,1))))

但是正如您所看到的，这会留下外部结构。要打破“分组屏蔽”，您可以使用flatMap而不是map，有效地展平容器结构，并释放内部的List(elem)元素。

l2.flatMap(internalList => internalList.map(element => List(element)))
res11: List[List[(Char, Int)]] = List(List((a,9)), List((a,8)), List((a,1)))

这是与第一个列表匹配的类型，因此简单的列表连接将两者结合在一起：

l1 ::: l2.flatMap(internalList => internalList.map(element => List(element)))
res12: List[List[(Char, Int)]] = List(List((a,10), (b,12)), List((a,9)), List((a,8)), List((a,1)))

Answer 2

我想对这个列表做些什么是采取每个元素（立即让我想到地图）并将它们添加到我的原始列表中，但作为一个不同的清单。

据我所知：

val l1 = List(List(('a',10), ('b',12)))
val l2 = List(List(('a',9), ('a',8), ('a',1)), List(('b',12)))

val result = l1 ::: List(l2.flatten)
res3: List[List[(Char, Int)]] = List(List((a,10), (b,12)), List((a,9), (a,8), (a,1), (b,12)))

将给定列表的每个元素作为单个列表连接到另一个列表

2 个答案: