Question

scala> val a = List(1,2)
a: List[Int] = List(1, 2)

scala> val b = List(3,4)
b: List[Int] = List(3, 4)

scala> val c = List(5,6)
c: List[Int] = List(5, 6)

scala> val d = List(7,8)
d: List[Int] = List(7, 8)

scala> (a,b,c).zipped.toList
res6: List[(Int, Int, Int)] = List((1,3,5), (2,4,6))

现在：

scala> (a,b,c,d).zipped.toList
<console>:12: error: value zipped is not a member of (List[Int], List[Int], List[Int],     List[Int])
              (a,b,c,d).zipped.toList
                       ^

我已在其他地方搜索过此内容，包括this one和this one，但没有确定答案。

我想做以下或类似的事情：

for((itemA,itemB,itemC,itemD) <- (something)) yield itemA + itemB + itemC + itemD

有什么建议吗？

Answer 1

简短回答：

for (List(w,x,y,z) <- List(a,b,c,d).transpose) yield (w,x,y,z)
  // List[(Int, Int, Int, Int)] = List((1,3,5,7), (2,4,6,8))

为什么你想要它们作为元组，我不确定，但是当你的列表属于不同类型时会有一个更有趣的情况，例如，你想将它们组合成一个对象列表：

case class Person(name: String, age: Int, height: Double, weight: Double)
val names =   List("Alf", "Betty")
val ages =    List(22, 33)
val heights = List(111.1, 122.2)
val weights = List(70.1, 80.2)
val persons: List[Person] = ???

解决方案1：使用transpose，如上所述：

for { List(name: String, age: Int, height: Double, weight: Double) <- 
        List(names, ages, heights, weights).transpose
    } yield Person(name, age, height, weight)

在这里，我们需要List提取器中的类型注释，因为transpose给出List[List[Any]]。

解决方案2：使用迭代器：

val namesIt   = names.iterator
val agesIt    = ages.iterator
val heightsIt = heights.iterator
val weightsIt = weights.iterator

for { name <- names } 
  yield Person(namesIt.next, agesIt.next, heightsIt.next, weightsIt.next)

有些人会避免使用迭代器，因为它们涉及可变状态，因此不具有“功能性”。但是如果你来自Java世界，它们很容易理解，如果你实际拥有的东西已经是迭代器（输入流等），它们可能是合适的。

Answer 2

无耻的插件 - product-collections做了类似的事情：

 a flatZip b flatZip c flatZip d
 res0: org.catch22.collections.immutable.CollSeq4[Int,Int,Int,Int] = 
 CollSeq((1,3,5,7),
         (2,4,6,8))

 scala> res0(0) //first row
 res1: Product4[Int,Int,Int,Int] = (1,3,5,7)

 scala> res0._1 //first column
 res2: Seq[Int] = List(1, 2)

Answer 3

找到了一个可能的解决方案，尽管这对我的口味非常重要：

  val a = List(1,2)
  val b = List(3,4)
  val c = List(5,6)
  val d = List(7,8)

  val g : List[Tuple4[Int,Int,Int,Int]] = {
    a.zipWithIndex.map { case (value,index) => (value, b(index), c(index), d(index))}  
  }

zipWithIndex允许我浏览所有其他集合。但是，我确信有更好的方法可以做到这一点。有什么建议？

以前的尝试包括：

Ryan LeCompte的zipMany或转置。

然而，它是一个List，而不是一个元组4。这不方便使用，因为我无法命名变量。

Tranpose它已经内置在标准库中，并且不需要更高种类的导入，因此它更受欢迎，但并不理想。

我也错误地使用Shapeless

尝试了以下示例

scala> import Traversables._
import Tuples._
import Traversables._
import Tuples._
import scala.language.postfixOps

scala> val a = List(1,2)
a: List[Int] = List(1, 2)

scala> val b = List(3,4)
b: List[Int] = List(3, 4)

scala> val c = List(5,6)
c: List[Int] = List(5, 6)

scala> val d = List(7,8)
d: List[Int] = List(7, 8)

scala> val x = List(a,b,c,d).toHList[Int :: Int :: Int :: Int :: HNil] map tupled
x: Option[(Int, Int, Int, Int)] = None

Answer 4

       val g = List(a,b,c,d)
   val result = ( g.map(x=>x(0)), g.map(x=>x(1) ) )

结果:(列表（1,3,5,7），列表（2,4,6,8））

基本的，压缩的assit tuple2，tuple3 http://www.scala-lang.org/api/current/index.html#scala.runtime.Tuple3Zipped 所以，你想要'tuple4zippped'你做到了

gool luck

使用4（或N）个集合一次只能产生一个值（1xN）（即为tuple4 +压缩）

4 个答案: