android kotlin - 函数引用是否由于反射而变慢？

Question

Reflection 被认为在 android 上有点耗时。所以我想知道这样的函数引用：

fun isOdd(x: Int) = x % 2 != 0
val numbers = listOf(1, 2, 3)
println(numbers.filter(::isOdd))

是::isOdd调用是不必要的负担？

不使用它们会更有效吗？

更新：做一些轻量级的指标我做了以下：

    class MainActivity : Activity() {

    val numbers = listOf(1, 2, 3)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        doRegular()
        doReflection()
    }

    fun isOdd(x: Int) = x % 2 != 0

    fun doRegular() {
        val start = System.currentTimeMillis()
        for (i in 0..999999) {
            numbers.filter { it % 2 != 0 }
        }
        Log.v("myTag", "regular: +${System.currentTimeMillis() - start}")
    }

    fun doReflection() {
        val start = System.currentTimeMillis()
        for (i in 0..999999) {
            numbers.filter(::isOdd)
        }
        Log.v("myTag", "reflection: ${System.currentTimeMillis() - start}")
    }
}

打印语句结果为：

//*****this was the first attempt before compiler could optimise anything
        regular: +577     
        reflection: 318
  //*********
  
    regular: +376
    reflection: 327
    
    regular: +593
     reflection: 343
    
     regular: +417
     reflection: 251
     
     regular: +243
     reflection: 238
     
     regular: +241
     reflection: 238
     
     regular: +238
     reflection: 237
     
     regular: +235
     reflection: 247
     
     regular: +237
     reflection: 247
     
     regular: +230
     reflection: 268

根据这些结果，您会得出什么结论？

更新：有些人问我为什么认为它使用反射。它基于此：

这个stackoverflow answer 似乎说明了它的反射：official doc 的标题以反射作为主要标题：因此我很困惑。

Answer 1

::isOdd 肯定是用来引用函数的，但除非确实需要使用“反射”，否则不使用它（反射）。类似于在字节码中将 Int 更改为 int，除非我们需要存储引用，如果我们创建集合，则只有它表示为 java.lang.Integer。

Kotlin 编译器很聪明，并且在幕后工作。

/**
 * Returns a list containing only elements matching the given [predicate].
 * 
 * @sample samples.collections.Collections.Filtering.filter
 */
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

过滤器函数是直接在调用点嵌入 lambda/引用而不实际使用反射的内联函数。

如果您看到 JVM 字节码，您将看到以下反编译的 Java 代码：

// of numbers.filter { it % 2 != 0 }
while(var6.hasNext()) {
    Object element$iv$iv = var6.next();
    int it = ((Number)element$iv$iv).intValue();
    int var9 = false;
    if (it % 2 != 0) {              // <- check this out
        destination$iv$iv.add(element$iv$iv);
    }
}

// of numbers.filter(::isOdd)
while(var6.hasNext()) {
    Object element$iv$iv = var6.next();
    int p1 = ((Number)element$iv$iv).intValue();
    int var9 = false;
    if (isOdd(p1)) {                  // <- check this out
        destination$iv$iv.add(element$iv$iv);
    }
}

实际上这里不涉及反射。

旁注：我在 here 上对 Kotlinlang 官方 slack 有过类似的问题，我得到了很多关注，但只有 1 条回复是仅关于 here in softwareengineering stackexchange subdomain 所述的元加工。

这是一个 ss：

Answer 2

函数引用不使用反射，它们就像访问一个字段，但用于函数。

因此，这些引用在编译时解决。如果您犯了错误，例如拼写错误的函数名称，它将无法编译。查找和调用同一个拼写错误的函数的反射在运行时会失败。

Answer 3

我想说解决这个问题的最好方法是计时！不过，我预计反射会更耗时。

val numbers = listOf(1, 2, 3)

fun isOdd(x: Int) = x % 2 != 0

fun doRegular() {
    val start = System.currentTimeMillis()
    for (i in 0..999999) {
        numbers.filter { it % 2 != 0 }
    }
    println(System.currentTimeMillis() - start)
}

fun doReflection() {
    val start = System.currentTimeMillis()
    for (i in 0..999999) {
        numbers.filter(::isOdd)
    }
    println(System.currentTimeMillis() - start)
}