建议在多个值上优化简单的Scala foldLeft？

以下是Java代码的片段：

// initialize
    double lP  = Math.log(prior);
    double lPC = Math.log(1-prior);

    // accumulate probabilities from each annotation object into lP and lPC
    for (Annotation annotation : annotations) {
        float prob = annotation.getProbability();
        if (isValidProbability(prob)) {
            lP  += logProb(prob);
            lPC += logProb(1 - prob);
        }
    }

很简单吧？所以我决定在第一次尝试时使用Scala foldLeft和map方法.由于我有两个值,我正在积累,累加器是一个元组：

val initial  = (math.log(prior),math.log(1-prior))
    val probs    = annotations map (_.getProbability)
    val (lP,lPC) = probs.foldLeft(initial) ((r,p) => {
      if(isValidProbability(p)) (r._1 + logProb(p),r._2 + logProb(1-p)) else r
    })

不幸的是,这段代码的执行速度比Java快5倍(使用简单且不精确的度量标准;只需在循环中调用代码10000次).一个缺点很明显;我们遍历列表两次,一次是在map中调用,另一次是在foldLeft中.所以这是一个遍历列表的版本.

val (lP,lPC) = annotations.foldLeft(initial) ((r,annotation) => {
      val  p = annotation.getProbability
      if(isValidProbability(p)) (r._1 + logProb(p),r._2 + logProb(1-p)) else r
    })

这个更好！它的执行速度比Java代码差3倍.我的下一个预感是,在折叠的每个步骤中创建所有新元组可能需要花费一些成本.所以我决定尝试两次遍历列表的版本,但不创建元组.

val lP = annotations.foldLeft(math.log(prior)) ((r,annotation) => {
       val  p = annotation.getProbability
       if(isValidProbability(p)) r + logProb(p) else r
    })
    val lPC = annotations.foldLeft(math.log(1-prior)) ((r,annotation) => {
      val  p = annotation.getProbability
      if(isValidProbability(p)) r + logProb(1-p) else r
    })

这与先前版本大致相同(比Java版本慢3倍).并不奇怪,但我很有希望.

所以我的问题是,是否有更快的方法在Scala中实现这个Java代码段,同时保持Scala代码干净,避免不必要的可变性并遵循Scala惯用法？我确实希望最终在并发环境中使用此代码,因此保持不变性的价值可能会超过单个线程中较慢的性能.