什么是最快捷的方法来合并Scala中的一个集合

因此,如果在Java中看到

for (int i=0 ; i < array.length ; i++) sum += array(i)

在斯卡拉你应该写

var i=0
while (i < array.length) {
  sum += array(i)
  i += 1
}

如果您恰当地做出了基准测试,速度就没有差别.

如果您有迭代器,那么Scala在大多数情况下与Java一样快.例如,如果您的ArrayList为双精度,并且在Java中,则可以使用它们添加它们

for (double d : arraylist) { sum += d }

那么在Scala中,如果使用像ArrayBuffer这样的等效数据结构,那么你将会是一样快

arraybuffer.foreach( sum += _ )

而且不要太过分了

sum = (0 /: arraybuffer)(_ + _)
sum = arraybuffer.sum  // 2.8 only

请记住,混合高级别和低级别的结构有一个惩罚.例如,如果您决定从数组开始,但是使用“foreach”而不是索引,Scala必须将其包装在一个集合(2.8中的ArrayOps)中以使其正常工作,并且通常将不得不使用框原文以及.

无论如何,对于基准测试,这两个功能是你的朋友：

def time[F](f: => F) = {
  val t0 = System.nanoTime
  val ans = f
  printf("Elapsed: %.3fn",1e-9*(System.nanoTime-t0))
  ans
}

def lots[F](n: Int,f: => F): F = if (n <= 1) f else { f; lots(n-1,f) }

例如：

val a = Array.tabulate(1000000)(_.toDouble)
val ab = new collection.mutable.ArrayBuffer[Double] ++ a
def adSum(ad: Array[Double]) = {
  var sum = 0.0
  var i = 0
  while (i<ad.length) { sum += ad(i); i += 1 }
  sum
}

// Mixed array + high-level; convenient,not so fast
scala> lots(3,time( lots(100,(0.0 /: a)(_ + _)) ) )
Elapsed: 2.434
Elapsed: 2.085
Elapsed: 2.081
res4: Double = 4.999995E11

// High-level container and operations,somewhat better
scala> lots(3,(0.0 /: ab)(_ + _)) ) )    
Elapsed: 1.694
Elapsed: 1.679
Elapsed: 1.635
res5: Double = 4.999995E11

// High-level collection with simpler operation
scala> lots(3,{var s=0.0;ab.foreach(s += _);s}) ) )
Elapsed: 1.171
Elapsed: 1.166
Elapsed: 1.162
res7: Double = 4.999995E11

// All low level operations with primitives,no boxing,fast!
scala> lots(3,adSum(a)) ) )              
Elapsed: 0.185
Elapsed: 0.183
Elapsed: 0.186
res6: Double = 4.999995E11