為什么與 Java 相比，Kotlin 提交速度明顯慢？

Question

我對 Kotlin 很陌生。 所以為了練習，我嘗試用它來解決 LeetCode 中的問題。 這是我今天解決的一個問題：
不同的子序列(Leetcode)
首先我嘗試解決Java中的問題：

class Solution {
    public int numDistinct(String s, String t) {
        int[][] dp = new int[t.length() + 1][s.length() + 1];
        for (int i = 0; i <= s.length(); i++) {
            dp[0][i] = 1;
        }
        for (int i = 1; i <= t.length(); i++) {
            for (int j = 1; j <= s.length(); j++) {
                if (t.charAt(i - 1) != s.charAt(j - 1)) {
                    dp[i][j] = dp[i][j - 1];
                } else {
                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
                }
            }
        }
        return dp[t.length()][s.length()];
    }
}

這是該算法的運行時間：

Runtime: 6 ms
Memory Usage: 39.4 MB

然后我嘗試在 Kotlin 中解決問題（代碼如下）：

class Solution {
    fun numDistinct(s: String, t: String): Int {
        var dp = Array(t.count() + 1) {Array(s.count() + 1) {0} }
        for (i in 0 until s.count()) {
            dp[0][i] = 1;
        }
        for (i in 1..t.count()) {
            for (j in 1..s.count()) {
                if (t[i - 1] != s[j - 1]) {
                    dp[i][j] = dp[i][j - 1];
                } else {
                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
                }
            }
        }
        return dp[t.count()][s.count()]
    }
}

令人震驚的是，上述 Kotlin 實現的算法的運行時間如下：

Runtime: 176 ms
Memory Usage: 34.2 MB

問題是，與 Java 相比，為什么 Kotlin 解決方案的運行時間要長？

Answer 1

將int[][]翻譯成 Kotlin 是Array<IntArray> ； 你有Array<Array<Int>> ，它對應於 Java 中的Integer[][] 。 所以你的 Kotlin 代碼做了很多裝箱和拆箱，而 Java 沒有。 有關更多詳細信息，請參閱https://kotlinlang.org/docs/reference/java-interop.html#java-arrays 。

Array(t.count() + 1) {IntArray(s.count() + 1) }

至少應該解決這個問題（不指定 lambda 會將所有元素初始化為0 ）。

Answer 2

我認為這可以歸結為他們的后端如何啟動 VM 和測量時間。 因為這也需要大約 200 毫秒，這很荒謬：

class Solution {
    fun numDistinct(s: String, t: String): Int {
        return 3
    }
}

我懷疑無論代碼多么簡單，您都可以指望大約 200 毫秒的預熱時間。 雖然奇怪的是，我嘗試編輯這兩個以在返回之前重復該算法一百萬次，並且 Kotlin 代碼（在調整如下所述的等效性之后）始終顯示較低的運行時間。

不過，您的代碼並不完全等同於 Java。 另一個答案已經提到了您的內部數組類型。

與性能無關，但您的第一個循環在 Java 中比在 Kotlin 中多填充一個空間。