等效于Scala中的Java summaryStatistics

Question

I am porting some Java code to Scala and need to extract some really basic statistical values, which include the count , maximum , minimum and average from a stream of long values.

In Java I have solved this problem with this method:

public static Stats calcStats(Iterable<Ad> iterable) {
    LongSummaryStatistics longSummaryStatistics = StreamSupport.stream(iterable.spliterator(), false).mapToLong(Ad::getEvent_time).summaryStatistics();
    return new Stats(longSummaryStatistics.getMin(), longSummaryStatistics.getMax(), round(longSummaryStatistics.getAverage()),
            longSummaryStatistics.getCount());
}

Is there a similar method to extract these values in one go in the Scala libraries (without using extra libraries like Spark)?

Right now I am using some code similar to this one:

def main(args: Array[String]): Unit = {
  val l = List(("s1", 1L), ("s2", 2L), ("s3", 3L), ("s4", 4L))
  val stats = summaryStatistics(l.iterator)
  println("min: %d, max: %d, avg: %f".format(stats._1, stats._2, stats._3))
}

def summaryStatistics(iter: Iterator[(String, Long)]): (Long, Long, Double) = {
  val stats = iter.map((tuple: (String, Long)) => tuple._2)
    .foldLeft((Long.MaxValue, Long.MinValue, 0L, 0L))((a, t) => (Math.min(t, a._1), Math.max(t, a._2), a._3 + 1, a._4 + t))
  (stats._1, stats._2, stats._4 / (stats._3 * 1.0))
}

This prints out:

min: 1, max: 4, avg: 2.500000

Answer 1

You can use the java lib directly, by going through the java world just a bit :)

import scala.collection.JavaConverters._

def main(args: Array[String]): Unit = {
    val l = List(("s1", 1L), ("s2", 2L), ("s3", 3L), ("s4", 4L))
    val stats = StreamSupport.stream(l.asJava.spliterator(), false).mapToLong(x => x._2).summaryStatistics()
    println("min: %d, max: %d, avg: %f".format(stats.getMin, stats.getMax, stats.getAverage))
}

Note the import of the JavaConverters, and the little "asJava" added in the code to match the StreamSupport API :)

Answer 2

Alternatively to C4stor, you can use more Scala collections like this:

import java.util.LongSummaryStatistics

def main(): Unit = {
  val l = List(("s1", 1L), ("s2", 2L), ("s3", 3L), ("s4", 4L))
  // .view here is a trick to make it semantically more similar to Java Streams i.e. to avoid materializaiton of the mapped list
  val stats = summaryStatistics(l.view.map(_._2))
  println("min: %d, max: %d, avg: %f".format(stats.getMin, stats.getMax, stats.getAverage))
}


def summaryStatistics(col: TraversableOnce[Long]): LongSummaryStatistics = {
  col.foldLeft(new LongSummaryStatistics)((stat, el) => {
    stat.accept(el)
    stat
  })
}

Or if you want to use a potential of parallel support that is implemented in LongSummaryStatistics , you may use aggregate instead of foldLeft such as:

def summaryStatistics(col: TraversableOnce[Long]): LongSummaryStatistics = {
  col.aggregate(new LongSummaryStatistics)((stat, el) => {
    stat.accept(el)
    stat
  }, (s1, s2) => {
    s1.combine(s2)
    s1
  })
}