如何在scala中从现有映射派生出新的不可变映射

我认为这将是相对简单的。 因此，我会解释：

我有一张地图如下：这是我在REPL中尝试的

scala> val entriesList = List(("tPolicyId" -> "MasterCard"), ("SSN" -> "0"), ("MasterCard" -> "3"));
entriesList: List[(String, String)] = List((tPolicyId,MasterCard), (US SSN,0), (MasterCard,3))

然后，我将列表转换为地图，如下所示

scala> val entriesMap = entriesList.toMap
entriesMap: scala.collection.immutable.Map[String,String] = Map(tPolicyId -> MasterCard,SSN -> 0, MasterCard -> 3)

到目前为止还不错。现在我想完成的是迭代这个映射的方法，有一个保护条件或谓词：如果我用来迭代这个映射的函数遇到一个名为tpolicMap的键，请返回或生成一个新的不可变映射，newMap，如下所示：

  ***newMap: scala.collection.immutable.Map[String,String] = Map(tPolicyId -> MasterCard)***

我认为这会很容易，下面是我迄今为止所有失败的尝试

    scala> val tPolicyMap = for (entry <- entriesMap if entry.contains("tPolicyId")) yield  entry
<console>:10: error: value contains is not a member of (String, String)
       val tPolicyMap = for (entry <- entriesMap if entry.contains("tPolicyId")) yield  entry
                                                                   ^

scala> val tPolicyMap = for (entry <- entriesMap if ( entry.contains("tPolicyId"))) yield  entry
<console>:10: error: value contains is not a member of (String, String)
       val tPolicyMap = for (entry <- entriesMap if ( entry.contains("tPolicyId"))) yield  entry
                                                                     ^

scala> val tPolicyMap = for (entry <- entriesMap if ( entry.contains("tPolicyId"))) yield  (entry)
<console>:10: error: value contains is not a member of (String, String)
       val tPolicyMap = for (entry <- entriesMap if ( entry.contains("tPolicyId"))) yield  (entry)
                                                                     ^

scala> val tPolicyMap = for (entry <- entriesMap; if ( entry.contains("tPolicyId"))) yield  (entry)
<console>:10: error: value contains is not a member of (String, String)
       val tPolicyMap = for (entry <- entriesMap; if ( entry.contains("tPolicyId"))) yield  (entry)
                                                                      ^

scala> val tPolicyMap = for (entry <- entriesMap; if ( entry contains("tPolicyId"))) yield  (entry)
<console>:10: error: value contains is not a member of (String, String)
       val tPolicyMap = for (entry <- entriesMap; if ( entry contains("tPolicyId"))) yield  (entry)
                                                                      ^

scala> val tPolicyMap = for (entry <- entriesMap; if entry contains("tPolicyId"))) yield  entry
<console>:1: error: illegal start of simple expression
       val tPolicyMap = for (entry <- entriesMap; if entry contains("tPolicyId"))) yield  entry
                                                                                                   ^

scala> val tPolicyMap = for (entry <- entriesMap; if entry contains("tPolicyId")) yield  entry
<console>:10: error: value contains is not a member of (String, String)
       val tPolicyMap = for (entry <- entriesMap; if entry contains("tPolicyId")) yield  entry
                                                                    ^

scala> val tPolicyMap = for (entry <- entriesMap) yield  entry
tPolicyMap: scala.collection.immutable.Map[String,String] = Map(tPolicyId -> MasterCard/Diner's Club U
S Number, US SSN -> 0, MasterCard -> 3)

scala> val tPolicyEntry = entriesMap.contains("tPolicyId")
tPolicyEntry: Boolean = true

scala> val tPolicyEntry = if (entriesMap.contains("tPolicyId")) yield entriesMap
<console>:1: error: illegal start of simple expression
       val tPolicyEntry = if (entriesMap.contains("tPolicyId")) yield entriesMap
                                                                                  ^

scala> val tPolicyEntry = for(entry <- entriesMap; if entry == "tPolicyId" yield entry
<console>:1: error: ')' expected but 'yield' found.
       val tPolicyEntry = for(entry <- entriesMap; if entry == "tPolicyId" yield entry
                                                                                             ^

scala> val tPolicyEntry = for(entry <- entriesMap; if entry == "tPolicyId") yield entry
<console>:10: warning: comparing values of types (String, String) and String using `==' will always yield false
       val tPolicyEntry = for(entry <- entriesMap; if entry == "tPolicyId") yield entry
                                                                     ^
tPolicyEntry: scala.collection.immutable.Map[String,String] = Map()

scala> val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)) yield entry
<console>:1: error: illegal start of simple expression
       val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)) yield entry
                                                                                                      ^

scala> val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)))) yield entry
<console>:1: error: illegal start of simple expression
       val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)))) yield entry
                                                                                                     ^

scala> val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)) yield entry)
<console>:1: error: illegal start of simple expression
       val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)) yield entry)
                                                                                                      ^

scala> val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)) yield entry))
<console>:1: error: illegal start of simple expression
       val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry)) yield entry))
                                                                                                      ^

scala> val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry) yield entry))
<console>:1: error: ')' expected but 'yield' found.
       val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry) yield entry))
                                                                                                     ^

scala> val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry) yield entry)
<console>:1: error: ')' expected but 'yield' found.
       val tPolicyEntry = entriesMap.keys.foreach( (entry) => if(entriesMap.contains(entry) yield entry)

scala>val tpolicMap=for（条目if（entriesMap.contains（条目））收益条目
：1:错误：简单表达式的开始非法
val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目））收益条目
^
scala>val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目）））生成条目
：1:错误：简单表达式的开始非法
val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目）））生成条目
^
scala>val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目））收益条目）
：1:错误：简单表达式的开始非法
val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目））收益条目）
^
scala>val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目））收益条目）
：1:错误：简单表达式的开始非法
val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目））收益条目）
^
scala>val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目）收益条目））
：1:错误：“）”应为，但找到“收益率”。
val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目）收益条目））
^
scala>val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目）收益条目）
：1:错误：“）”应为，但找到“收益率”。
val tPolicyEntry=entriesMap.keys.foreach（（条目）=>if（entriesMap.contains（条目）收益条目）

正如你们所看到的，我尝试在各种组合中使用filter、yield、foreach、for等，但都没有成功，我仍然不明白/

所以，我已经努力了，我可能犯了一些基本上幼稚的错误

如果有人能帮我弄清楚如何得到这张我想要的地图，我会非常感谢你的学习经验

提前谢谢

这很简单

 entriesMap.filter { case (k, _) => k == "tPolicyId" }
 //> res0: scala.collection.immutable.Map[String,String] = Map(tPolicyId -> MasterCard)

或者干脆

 entriesMap filterKeys { _ == "tPolicyId"  }

简单到

 entriesMap.filter { case (k, _) => k == "tPolicyId" }
 //> res0: scala.collection.immutable.Map[String,String] = Map(tPolicyId -> MasterCard)

或者干脆

 entriesMap filterKeys { _ == "tPolicyId"  }

简单到

 entriesMap.filter { case (k, _) => k == "tPolicyId" }
 //> res0: scala.collection.immutable.Map[String,String] = Map(tPolicyId -> MasterCard)

或者干脆

 entriesMap filterKeys { _ == "tPolicyId"  }

简单到

 entriesMap.filter { case (k, _) => k == "tPolicyId" }
 //> res0: scala.collection.immutable.Map[String,String] = Map(tPolicyId -> MasterCard)

或者干脆

 entriesMap filterKeys { _ == "tPolicyId"  }

---

您必须考虑（迭代、比较，如果匹配，则执行此操作），而不是Scala不可变集合所倾向的更高级别：

// get looks up value from a map using the key (fast)
// will give you an Option[String] back - 
// Some(value) if the key exists, None if it doesn't
tpPolicyMap.get("tPolicyId").fold[Map[String, String]](
  // result for None - no "tPolicyId"-key in the source map
  Map.empty
)(value => 
  // found, create a new map with that entry
  Map("tPolicyId" -> value)
)

---

您必须考虑（迭代、比较，如果匹配，则执行此操作），而不是Scala不可变集合所倾向的更高级别：

// get looks up value from a map using the key (fast)
// will give you an Option[String] back - 
// Some(value) if the key exists, None if it doesn't
tpPolicyMap.get("tPolicyId").fold[Map[String, String]](
  // result for None - no "tPolicyId"-key in the source map
  Map.empty
)(value => 
  // found, create a new map with that entry
  Map("tPolicyId" -> value)
)

---

您必须考虑（迭代、比较，如果匹配，则执行此操作），而不是Scala不可变集合所倾向的更高级别：

// get looks up value from a map using the key (fast)
// will give you an Option[String] back - 
// Some(value) if the key exists, None if it doesn't
tpPolicyMap.get("tPolicyId").fold[Map[String, String]](
  // result for None - no "tPolicyId"-key in the source map
  Map.empty
)(value => 
  // found, create a new map with that entry
  Map("tPolicyId" -> value)
)

---

您必须考虑（迭代、比较，如果匹配，则执行此操作），而不是Scala不可变集合所倾向的更高级别：

// get looks up value from a map using the key (fast)
// will give you an Option[String] back - 
// Some(value) if the key exists, None if it doesn't
tpPolicyMap.get("tPolicyId").fold[Map[String, String]](
  // result for None - no "tPolicyId"-key in the source map
  Map.empty
)(value => 
  // found, create a new map with that entry
  Map("tPolicyId" -> value)
)

---

过滤器

解决方案很好。如果您计划在

过滤器

entriemap.collect{case（k，v）if k==“tPolicyId”=>（k，s“test${v}”）}//示例而不是普通（k，v）
//scala.collection.immutable.Map[String，String]=Map（tPolicyId->testMasterCard）

同：

（entriesMap filterKeys{{{u==“tPolicyId”}）.map（（kv）=>（kv.\u1，s“test${kv.\u2}”））
//scala.collection.immutable.Map[String，String]=Map（tPolicyId->testMasterCard）

过滤解决方案很好。您还可以进行

收集

，如果您计划在

过滤后进行
映射
，这可能会很方便

entriemap.collect{case（k，v）if k==“tPolicyId”=>（k，s“test${v}”）}//示例而不是普通（k，v）
//scala.collection.immutable.Map[String，String]=Map（tPolicyId->testMasterCard）

同：

（entriesMap filterKeys{{{u==“tPolicyId”}）.map（（kv）=>（kv.\u1，s“test${kv.\u2}”））
//scala.collection.immutable.Map[String，String]=Map（tPolicyId->testMasterCard）
过滤解决方案很好。您还可以进行
收集
，如果您计划在
过滤后进行
映射
，这可能会很方便

entriemap.collect{case（k，v）if k==“tPolicyId”=>（k，s“test${v}”）}//示例而不是普通（k，v）
//scala.collection.immutable.Map[String，String]=Map（tPolicyId->testMasterCard）

同：

（entriesMap filterKeys{{{u==“tPolicyId”}）.map（（kv）=>（kv.\u1，s“test${kv.\u2}”））
//scala.collection.immutable.Map[String，String]=Map（tPolicyId->testMasterCard）
过滤解决方案很好。您还可以进行
收集
，如果您计划在
过滤后进行
映射
，这可能会很方便

entriemap.collect{case（k，v）if k==“tPolicyId”=>（k，s“test${v}”）}//示例而不是普通（k，v）
//scala.collection.immutable.Map[String，String]=Map(