Scala：优雅的迭代解决方案（列表，列表）_Scala

Scala：优雅的迭代解决方案（列表，列表）

scala

Scala：优雅的迭代解决方案（列表，列表）,scala,Scala,我试图提出一个“优雅”的解决方案来迭代两个列表（值对），并对结果值执行一些测试有什么想法吗？这是我到目前为止得到的，但我得到“值过滤器不是（List[Int]，List[Int]）的成员”，这让我感到惊讶，我认为这会起作用。而且，我觉得必须有一种更简洁的方式来用Scala表达这一点 val accounts = random(count = 100, minimum = 1, maximum = GPDataTypes.integer._2) val ids = random(count =

我试图提出一个“优雅”的解决方案来迭代两个列表（值对），并对结果值执行一些测试

有什么想法吗？这是我到目前为止得到的，但我得到“值过滤器不是（List[Int]，List[Int]）的成员”，这让我感到惊讶，我认为这会起作用。而且，我觉得必须有一种更简洁的方式来用Scala表达这一点

val accounts = random(count = 100, minimum = 1, maximum = GPDataTypes.integer._2)
val ids = random(count = 100, minimum = 1, maximum = GPDataTypes.integer._2)

for ((id, accountId) <- (ids, accounts)) {
  val g = new GPGlimple(Some(id), Some(timestamp), accountId, false, false, 2)
  println(g)
  g.accountId mustEqual accountId
  g.id mustEqual id
  g.created.get must beLessThan(System.currentTimeMillis)
  g.layers must beNone
  g.version must be equalTo 2
}

val accounts=random（计数=100，最小值=1，最大值=GPDataTypes.integer.\u 2）
valids=random（计数=100，最小值=1，最大值=GPDataTypes.integer.\u 2）
对于（（id，accountId）使用：
对于（（id，accountId）使用：
对于（（id，accountId）使用：
对于（（id，accountId）使用：
对于（（id，accountId）最简单的解决方案是：
zip
的文档说明：
通过成对组合相应的元素，返回从此列表和另一个iterable集合形成的列表
换句话说，zip
将返回元组列表
zipped
方法也可以在这里工作：
(ids, accounts).zipped

您可以找到2元组的zip
源代码。请注意，这是通过丰富（T，U）实现的
其中T
可隐式查看为TraversableLike
，U
可隐式查看为iterablellike
。该方法返回一个ZippedTraversable2
，这是封装这种压缩返回的最小接口，通过inhib可以更有效地处理大型序列它正在创建中间集合。这些集合通常性能更高，因为它们在内部使用迭代器
，如源代码所示
请注意，这里的返回类型不同，可能会影响下游行为。一个重要的区别是ZippedTraversable2
上的普通组合方法与元组的可遍历的方法略有不同。ZippedTraversable2
上的方法通常期望函数为2参数，而那些在元组的可遍历的
上的参数将期望一个具有一个元组参数的函数。例如，您可以在foreach
方法的REPL中检查这一点：
val s1 = List(1, 2, 3)
val s2 = List('a', 'b', 'c')

(s1 -> s2).zipped.foreach _
// ((Int, Char) => Any) => Unit = <function1>
(s1 zip s2).foreach _
// (((Int, Char)) => Any) => Unit = <function1> 
//Notice the extra parens here, signifying a method with a tuple argument

请注意，如果使用大小写
表示法，则以下两种方式均适用：
//case works for both syntaxes
(s1, s2).zipped.map { case (x, y) => x + y } \
(s1 zip s2).map { case (x, y) => x + y }

这是因为编译器对具有两个参数或一个元组参数的方法理解此符号，如中所述：
最简单的解决方案是：
zip
的文档说明：
通过成对组合相应的元素，返回从此列表和另一个iterable集合形成的列表
换句话说，zip
将返回元组列表
zipped
方法也可以在这里工作：
(ids, accounts).zipped

您可以找到2元组的zip
源代码。请注意，这是通过丰富（T，U）实现的
其中T
可隐式查看为TraversableLike
，U
可隐式查看为iterablellike
。该方法返回一个ZippedTraversable2
，这是封装这种压缩返回的最小接口，通过inhib可以更有效地处理大型序列它正在创建中间集合。这些集合通常性能更高，因为它们在内部使用迭代器
，如源代码所示
请注意，这里的返回类型不同，可能会影响下游行为。一个重要的区别是ZippedTraversable2
上的普通组合方法与元组的可遍历的方法略有不同。ZippedTraversable2
上的方法通常期望函数为2参数，而那些在元组的可遍历的
上的参数将期望一个具有一个元组参数的函数。例如，您可以在foreach
方法的REPL中检查这一点：
val s1 = List(1, 2, 3)
val s2 = List('a', 'b', 'c')

(s1 -> s2).zipped.foreach _
// ((Int, Char) => Any) => Unit = <function1>
(s1 zip s2).foreach _
// (((Int, Char)) => Any) => Unit = <function1> 
//Notice the extra parens here, signifying a method with a tuple argument

请注意，如果使用大小写
表示法，则以下两种方式均适用：
//case works for both syntaxes
(s1, s2).zipped.map { case (x, y) => x + y } \
(s1 zip s2).map { case (x, y) => x + y }

这是因为编译器对具有两个参数或一个元组参数的方法理解此符号，如中所述：
最简单的解决方案是：
zip
的文档说明：
通过成对组合相应的元素，返回从此列表和另一个iterable集合形成的列表
换句话说，zip
将返回元组列表
zipped
方法也可以在这里工作：
(ids, accounts).zipped

您可以找到2元组的zip
源代码。请注意，这是通过丰富（T，U）实现的
其中T
可隐式查看为TraversableLike
，U
可隐式查看为iterablellike
。该方法返回一个ZippedTraversable2
，这是封装这种压缩返回的最小接口，通过inhib可以更有效地处理大型序列它正在创建中间集合。这些集合通常性能更高，因为它们在内部使用迭代器
，如源代码所示
请注意，这里的返回类型不同，可能会影响下游行为。一个重要的区别是ZippedTraversable2
上的普通组合方法与元组的可遍历的方法略有不同。ZippedTraversable2
上的方法通常期望函数为2参数，而那些在元组的可遍历的
上的参数将期望一个具有一个元组参数的函数。例如，您可以在foreach
方法的REPL中检查这一点：
val s1 = List(1, 2, 3)
val s2 = List('a', 'b', 'c')

(s1 -> s2).zipped.foreach _
// ((Int, Char) => Any) => Unit = <function1>
(s1 zip s2).foreach _
// (((Int, Char)) => Any) => Unit = <function1> 
//Notice the extra parens here, signifying a method with a tuple argument

请注意，如果使用案例