Question

有两个列表：

 val list1 : List[List[(String, String)]] = List(List("1" -> "a" , "1" -> "b"))
                                                  //> list1  : List[List[(String, String)]] = List(List((1,a), (1,b)))
 val list2 : List[List[(String, String)]] = List(List("2" -> "a" , "2" -> "b"))
                                                  //> list2  : List[List[(String, String)]] = List(List((2,a), (2,b)))
 //Expecting
 val toConvert = List(List(Map("1" -> "a" , "2" -> "b"), Map("1" -> "b" , "2" -> "a")))

尝试将这些列表转换为键入：

 List[List[scala.collection.immutable.Map[String,String]]] = Lis
                                                  //| t(List(Map(1 -> a, 2 -> b), Map(1 -> b, 2 -> a)))

使用此代码：

val ll = list1.zip(list2).map(m => List(m._1.toMap , m._2.toMap))

但缺少地图条目：

 List[List[scala.collection.immutable.Map[String,String]]] = List(List(
                                                  //| Map(1 -> b), Map(2 -> b)))

如何将list1，list2转换为List[List[scala.collection.immutable.Map[String,String]]]类型，其中包含值(List(Map(1 -> a, 2 -> b), Map(1 -> b, 2 -> a)))？

更新：

逻辑：Map("1" -> "a" , "2" -> "b")

使用zip函数组合每个List：

  val p1 : List[(List[(String, String)], List[(String, String)])] = list1.zip(list2);

将新创建的List的每个元素转换为Map，然后添加到新创建的List：

val p2 = p1.map(m => List(m._1.toMap , m._2.toMap))

Answer 1

如何将list1和list2转换为List[List[Map[...
类型

从类型List[List[(String, String)]]开始，我们希望转到List[List[Map[String, String]]]类型。

内部类型

我们想要的内部类型是Map[String, String]。正如我在评论中提到的那样，我并不完全理解构建此Map的预期逻辑，因此我假设您要从元组Map[String, String]列表中创建List[(String, String)]。< / p>

使用Map创建.toMap时，具有相同key-value的{{1}}元素将被覆盖，因为我们可以从其key中清楚地看到实现：

b += x

（来源TraversableOnce.scala）

因此，我们用来创建def toMap[T, U](implicit ev: A <:< (T, U)): immutable.Map[T, U] = { val b = immutable.Map.newBuilder[T, U] for (x <- self) b += x b.result() }的逻辑将决定生成的List[(String, String)] 。

列表外

使用zip函数
组合每个List

Map[String, String]

压缩type A = List[(String, String)] val list12: List[(A, A)] = list1 zip list2和list1为我们提供了一个元组列表，但我们想要的类型实际上是一个元组列表列表：list2

在您的示例中，您将该类型映射到列表List[List[(A, A)]]。这是关键部分。让我把它分成两部分，以便更清楚：

m => List(...)

让我们把它提取到一个单独的函数中：

list12.map(m => List(m._1 , m._2)).map(_.map(_.toMap))

结果当然与你问题中的结果相同：

def keyPart: ((A, A)) => List[A] = { case (l1, l2) => List(l1, l2) }
val resultNotExpected = list12.map(keyPart).map(_.map(_.toMap))

“keyPart”

在您的问题中，您提到了预期的结果：

resultNotExpected == List(List(Map("1" -> "b"), Map("2" -> "b")))

我仍然不明白你现在提取的List(List(Map("1" -> "a", "2" -> "b"), Map("1" -> "b", "2" -> "a")))函数的逻辑，所以我会给你我的...当然过于复杂：

keyPart

也许您更了解在val resultExpected = list12.map { case (l1, l2) => List(l1, l2) } .map(_.map(_.zipWithIndex)).map(_.zipWithIndex) .map(_.map { case (l, i) => l.map { case ((k, v), j) => (k, v, i, j) } }).map(_.flatten) .map(_.groupBy { case (k, v, i, j) => i == j }).map(_.values.toList) .map(_.map(_.map { case (k, v, _, _) => k -> v }.sorted).sortBy(_.head._2)) .map(_.map(_.toMap)) scala> resultExpected == List(List(Map("1" -> "a", "2" -> "b"), Map("1" -> "b", "2" -> "a"))) Boolean = true中实施的逻辑。

将两个列表转换为类型：List [List [scala.collection.immutable.Map [String，String]]]

1 个答案:

内部类型

列表外

“keyPart”