为什么用scala编写的代码比java慢6倍？ [英] Why is the code written in scala 6 times slower than in java?

问题描述

我不确定我是否在编写scala代码时犯了一些错误。

问题是：

I am not sure if I make some mistake writing the scala code.
the question is：

    The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.

    73167176531330624919225119674426574742355349194934 96983520312774506326239578318016984801869478851843 85861560789112949495459501737958331952853208805511 12540698747158523863050715693290963295227443043557 66896648950445244523161731856403098711121722383113 62229893423380308135336276614282806444486645238749 30358907296290491560440772390713810515859307960866 70172427121883998797908792274921901699720888093776 65727333001053367881220235421809751254540594752243 52584907711670556013604839586446706324415722155397 53697817977846174064955149290862569321978468622482 83972241375657056057490261407972968652414535100474 82166370484403199890008895243450658541227588666881 16427171479924442928230863465674813919123162824586 17866458359124566529476545682848912883142607690042 24219022671055626321111109370544217506941658960408 07198403850962455444362981230987879927244284909188 84580156166097919133875499200524063689912560717606 05886116467109405077541002256983155200055935729725 71636269561882670428252483600823257530420752963450

    Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?  

bloger（ http://www.ituring.com.cn/article/111574 ）说他只用 haskell 编写的代码需要 6ms ：

the bloger(http://www.ituring.com.cn/article/111574) says the code he written by haskell only takes 6ms:

    import Data.List
    import Data.Char

    main = do
      a <- readFile "008.txt"
      print . maximum . map (product . take 13) . tails $ map digitToInt $ filter isDigit a  

所以我尝试使用 scala ：

    object Main {

      def main(args: Array[String]): Unit = {
        val begin: Long = System.currentTimeMillis()
            val content = Source.fromFile("file/text").filter(_.isDigit).map(_.toInt - '0').toList
            val lists =
              for (i <- 0 to content.size - 13)
                yield content.drop(i).take(13)
            println(lists.maxBy(_.reduce(_ * _)))
        val end: Long = System.currentTimeMillis()
        println(end - begin)
      }
    }  

但平均需要 120ms 。我认为问题是I / O，但我发现它只花了 10ms （我试图使用 FileChannel 而不是来源，但它不会节省太多时间。）它是 map 和 flatmap（ for） op需要花费大量时间的事情。

But it takes 120ms averagely.I thought the problem is I/O,but I found it just took 10ms(I tried to use FileChannel instead of Source,but it doesn't save much time).It is map and flatmap(for) operations which takes the most of time.

然后我尝试使用java来查看原因是否是JVM。不足为奇，java版本的运行速度要快得多。只需 20ms ：

Then I try to use java to see if the reason is JVM. Unsurprising, java version runs much faster.Just took about 20ms:

    public static void main(String[] args) throws IOException {
        long begin = System.currentTimeMillis();

        byte[] bytes = Files.readAllBytes(Paths.get("file/text"));
        List<Integer> list=new ArrayList<>();
        for(int i=0;i<bytes.length;i++){
            if(bytes[i]-'0'>=0&&bytes[i]-'0'<=9) list.add(bytes[i]-'0');
        }

        int max=-1;
        List<Integer> maxList=new ArrayList<>();
        List<Integer> temp=new ArrayList<>();

        for(int i=0;i<=list.size()-13;i++){
            int value=1;
            for(int j=i;j<i+13;j++){
                temp.add(list.get(j));
                value*=list.get(j);
            }
            if(value > max) {
                max = value;
                maxList.clear();
                maxList.addAll(temp);
            }
            temp.clear();
        }
        System.out.println(maxList);
        long end = System.currentTimeMillis();
        System.out.println(end - begin);
    }  

我的问题是为什么scala版本的代码运行得这么慢？

My question is why the code of scala version runs so slowly?

推荐答案

正如@etherous所提到的：你在Java版本中使用可变状态，而你的Scala版本是完全不可变的，而且写得更低效。它们只是不同。

As @etherous mentioned: You use mutable state in the Java-version, whereas your Scala-version is completely immutable and also written more inefficiently. They are just different.

您可以尝试避免 maxBy 并尝试在一次迭代中保存已计算的结果。这个应该更接近你的Java版本。

You can try to avoid maxBy and also try to save already computed results in one iteration. This one should be closer to your Java-version.

val content = Source.fromFile("file/text").filter(_.isDigit).map(_.toLong - '0').toList

val result = (0 to content.size - 13).foldLeft((List.empty[Long], -1l)){case (current @(_, curMax), next) => {
    val temp = content.drop(next).take(13)
    val tempVal = temp.reduce(_*_)
    if(tempVal > curMax) (temp, tempVal) else current
  }
}

结果是一个元组，包含十三个数字的列表 _1 ，它的产品为 _2 ，因为看起来你想要两个。

result is a tuple here, containing the list of the thirteen numbers as _1 and it's product as _2, as it seems you wanted both.

奖金

现在我认为关于它。有一个名为 sliding 的方法可以解决这个问题。但我想它的运行速度和你的scala代码一样慢。至少这会很短：）。

Now that I think about it. There is a method called sliding that exactly deals with this problem. But I guess it runs as slow as your scala-code. At least this would be short :).

content.sliding(13).maxBy(_.reduce(_*_))

这篇关于为什么用scala编写的代码比java慢6倍？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！