scala - 在 Scala 中对集合求和的最快方法是什么

Question

我在 Scala 中尝试了不同的集合来对它的元素求和，它们比 Java 对它的数组求和要慢得多(使用 for 循环)。有没有办法让 Scala 和 Java 数组一样快？

我听说 scala 2.8 中的数组与 java 中的相同，但实际上它们要慢得多

Answer 1

在 while 循环中索引数组在 Scala 中与在 Java 中一样快。 (Scala 的“for”循环不是 Java 的低级结构，因此它不会以您想要的方式工作。)

因此，如果在 Java 中你看到

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

在 Scala 中你应该写

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

如果你适本地进行基准测试，你会发现速度没有差异。

如果你有迭代器，那么 Scala 在大多数情况下都和 Java 一样快。例如，如果您有一个 double 数组列表，并且在 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)才能让它工作，并且通常会有也装箱基元。

无论如何，对于基准测试，这两个函数是你的 friend :

def time[F](f: => F) = {
  val t0 = System.nanoTime
  val ans = f
  printf("Elapsed: %.3f\n",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, time( lots(100,(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, time( lots(100,{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, time( lots(100,adSum(a)) ) )              
Elapsed: 0.185
Elapsed: 0.183
Elapsed: 0.186
res6: Double = 4.999995E11