探索Kotlin的隐性成本-2

原文转自探索Kotlin的隐性成本-2

第二部分将继续Kotlin编程语言，如果未读第一部分，请先阅读part 1.
让我们重新审视幕后并且发现更多的实现细节关于Kotlin特性。

Local functions(局部函数)

这种函数在第一篇文章中没有涉及：使用正规语法在其他函数内部声明的函数。这些被称为局部函数，他们能够访问外部函数的作用域。

fun someMath(a: Int): Int {
    fun sumSquare(b: Int) = (a + b) * (a + b)

    return sumSquare(1) + sumSquare(2)
}

让我们从他们最大的限制开始，局部函数不能被声明为内联（yet?）并且一个函数包含一个局部函数也不能被声明为内联。没有办法去避免这种方式调用方法的损耗。
编译之后，这些局部函数被转化成函数对象，就像lambdas以及在上篇文章中描述的相关的有相同限制的非内联函数。编译后等效的Java代码如下：

public static final int someMath(final int a) {
   Function1 sumSquare$ = new Function1(1) {
      // $FF: synthetic method
      // $FF: bridge method
      public Object invoke(Object var1) {
         return Integer.valueOf(this.invoke(((Number)var1).intValue()));
      }

      public final int invoke(int b) {
         return (a + b) * (a + b);
      }
   };
   return sumSquare$.invoke(1) + sumSquare$.invoke(2);
}

但是与lambdas相比性能却下降了：因为实际的函数实例是从调用者得知，它特定的方法将被直接调用而不是从函数接口中通用的合成方法。当从外部调用局部函数，这也意味着没有强转或者原始类型的装箱将会发生。我们可以通过查看字节码来证明这点。

ALOAD 1
ICONST_1
INVOKEVIRTUAL be/myapplication/MyClassKt$someMath$1.invoke (I)I
ALOAD 1
ICONST_2
INVOKEVIRTUAL be/myapplication/MyClassKt$someMath$1.invoke (I)I
IADD
IRETURN

我们可以看到方法被调用了两次。一次接收了一个int并返回了一个int。并且附加部分立即执行没有任何拆箱操作。
当然，在每个方法调用期间，仍然有创建新函数对象的损耗。它能够被避免通过把局部函数写为非捕获函数。

fun someMath(a: Int): Int {
    fun sumSquare(a: Int, b: Int) = (a + b) * (a + b)

    return sumSquare(a, 1) + sumSquare(a, 2)
}

现在同一个函数实例将被重用，还是没有强转和装箱将会发生。与经典的私有函数相比局部函数唯一的处罚是将会生成一个带有一些方法的额外的类。

局部函数是私有函数的另一种选择，其附加的好处是能够访问外部函数的局部变量。对于每次调用外部函数这个好处将伴随着创建函数对象的隐性成本。所以非捕获局部函数是首选的。

Null safety（空指针安全）

Kotlin语言最好的特性它有清晰的区别在可空和非空类型。这能够让编译器在运行时有效的阻止空指针异常通过禁止任何代码赋一个null或者可空的值给非空的变量。

Non-null arguments runtime checks（非空参数运行时检查）

让我们声明一个公共函数并且接受一个非空字符串作为参数。

fun sayHello(who: String) {
    println("Hello $who")
}

现在看看编译后等效的Java表示

public static final void sayHello(@NotNull String who) {
   Intrinsics.checkParameterIsNotNull(who, "who");
   String var1 = "Hello " + who;
   System.out.println(var1);
}

Kotlin编译器是Java的好市民并且给参数增加了@NotNull注解,所以Java工具能够使用这个暗示并给出警告当传的参数值为空的时候。
但是一个注解不足以强制空指针安全。所以这是为什么编译器在我们函数的最开始添加了一个将会检查参数的静态方法调用并在为空时抛出IllegalArgumentException 。
为了使不安全的代码更容易修复，这个函数将会提前失败而不是后期随机的抛出NullPointerException.
实际上，每个公共函数有一个静态调用Intrinsics.checkParameterIsNotNull()对于每个非空的引用参数。
这些检查将不被添加到私有函数因为编译器保证Kotlin类中的代码是空指针安全的。
这些静态调用的性能影响是可忽略不计的并且他们真的很有用当调试和测试应用时。话虽这么说，你可能认为他们是不必要的损耗对于release版本。这种情况下，禁用运行时空指针检查是可能的通过使用-Xno-param-assertions编译选项或者添加如下的ProGuard rule:

-assumenosideeffects class kotlin.jvm.internal.Intrinsics {
    static void checkParameterIsNotNull(java.lang.Object, java.lang.String);
}

注意这个ProGuard规则只在优化被启用的时候生效，在默认的Android ProGuard配置中，优化使被禁用的。

Nullable primitive types（可空的原始类型）

这看起来很明显但是需要被提醒：一个可空类型总是引用类型。为一个原始类型声明一个变量阻止Kotlin使用Java原始类型像int或者float而不使用涉及到额外损耗的装箱和拆箱操作的boxed reference types（装箱引用类型）像Integer或者Float.
与Java相反，Kotlin允许你粗心并且使用Interger变量几乎像使用一个int变量，归功于自动装箱和不管空指针安全，Kotlin强制你写安全代码当使用可空类型。所以使用非空类型的好处是显而易见的。

fun add(a: Int, b: Int): Int {
    return a + b
}
fun add(a: Int?, b: Int?): Int {
    return (a ?: 0) + (b ?: 0)
}

为了更好的可读性和性能，请使用非空原始类型无论任何时候可能的情况下。

About arrays（关于数组）

在Kotlin中有三种类型数组。

• IntArray,FloatArray 和其他：原始类型的数组被编译成int[],float[]和其他
• Array:非空的引用类型数组。这涉及为原始类型的装箱。
• Array

fun printDouble(vararg values: Int) {
    values.forEach { println(it * 2) }
}

像java一样，vararg 参数实际被编译成给定类型的一组参数。你接着可以调用这些函数通过三种方式：

• Passing multiple arguments（传多个参数）

printDouble(1, 2, 3)

Kotlin编译器将会把这些代码转化成一个创建和实例化的新数组，像Java编译做的那样。

printDouble(new int[]{1, 2, 3});

所以这里有创建新数组的开销，但是没什么新的东西与Java相比。

• Passing a single array（传入一个数组）

val values = intArrayOf(1, 2, 3)
printDouble(*values)

在Java ，数组引用通过“原样”传递给函数。然而，Kotlin扩展操作符编译不同，你可以看等效的Java表示：

int[] values = new int[]{1, 2, 3};
printDouble(Arrays.copyOf(values, values.length));

现有的数组总是被拷贝当调用这个函数。好处是更安全的代码:它允许函数改变数组而不影响其他调用者代码。但是它分配额外的空间。
注意调用一个带有可变数量参数的函数从Kotlin代码中有一样效果。

• Passing a mix of arrays and arguments(传入一个混合的数组和参数)

主要的优势关于扩展操作符是它也允许带有其他参数的混合数组在同样的调用中。

val values = intArrayOf(1, 2, 3)
printDouble(0, *values, 42)

它如何被编译？结果代码是相当有趣的：

int[] values = new int[]{1, 2, 3};
IntSpreadBuilder var10000 = new IntSpreadBuilder(3);
var10000.add(0);
var10000.addSpread(values);
var10000.add(42);
printDouble(var10000.toArray());

除了创建新的数组之外，一个临时的建造者对象被用于计算最终的数组大小并且赋值于它。这有些额外的损耗对于函数调用。

调用一个可变参数的函数在Kotlin中造成创建一个新数组的开销，及时使用一个存在的数组。对于重复调用的关键性能的代码，考虑增加一个带有数组参数的函数而不是可变参数。