[译]Effective Kotlin系列之考虑使用原始类型的数组优化性能(五)

一时失言乱红尘 2022-04-08 12:30 226阅读 0赞

**翻译说明:**

**原标题: Effective Kotlin: Consider Arrays with primitives for performance critical processing**

**原文地址: [https://blog.kotlin-academy.com/effective-kotlin-use-sequence-for-bigger-collections-with-more-than-one-processing-step-649a15bb4bf][https_blog.kotlin-academy.com_effective-kotlin-use-sequence-for-bigger-collections-with-more-than-one-processing-step-649a15bb4bf]**

**原文作者: [Marcin Moskala][]**

Kotlin底层实现是非常智能的。在Kotlin中我们不能直接声明原始类型(也称原语类型)的，但是当我们不像使用对象实例那样操作一个变量时，那么这个变量在底层将转换成原始类型处理。例如，请看以下示例：

var i = 10
    i = i * 2
    println(i)

上述的变量声明在Kotlin底层是使用了原始类型`int`.下面这是上述例子在Java中的内部表达:

// Java
    int i = 10;
    i = i * 2;
    System.out.println(i);

上述使用`int`的实现到底比使用`Integer`的实现要快多少呢? 让我们来看看。我们需要在Java中定义两种方式函数声明：

public class PrimitivesJavaBenchmark {
        
    
        public int primitiveCount() {
        
            int a = 1;
            for (int i = 0; i < 1_000_000; i++) {
        
                a = a + i * 2;
            }
            return a;
        }
    
        public Integer objectCount() {
        
            Integer a = 1;
            for (Integer i = 0; i < 1_000_000; i++) {
        
                a = a + i * 2;
            }
            return a;
        }
    }

当你测试这两种方法的性能时，您会发现一个巨大的差异。在我的机器中，使用Integer需要4905603ns, 而使用原始类型需要316954ns([这里是源码,自己检查运行测试][Link 1])这少了15倍！这是一个巨大的差异！

![167a8036fab36474_w_800_h_450_f_jpeg_s_87687][]

怎么会产生如此之大的差异呢? 原始类型比对象类型更加轻量级。在内存中原始类型的变量仅仅存储是一个数值而已，它们没有面向对象那一整套的内存分配过程。当你看到这种差异时，你应该感到庆幸，因为在Kotlin底层实现会尽可能使用原始类型，而且这种底层的优化我们甚至毫无察觉。但是你也应该知道有些情况底层编译器是不会转化成原始类型来做优化处理的:

*  可空类型不能是原始类型。编译器是很智能的，尽管是可空类型，可是当它检测到你没有对可空类型变量设置null值时，然后它还是会使用原始类型处理的。如果编译不能确定最终检测结果，那么它将默认使用非原始类型。请记住，这是代码性能关键部分因可空性引入的额外成本。
 *  原始类型不能用于泛型类型参数。

第二个问题显得尤为重要，因为我们在大部分场景下很少会对代码中数值做处理，但是我们经常会对集合中的元素做操作。可是问题来了，泛型类型参数不能使用原始类型，但是每个泛型集合都只能使用非原始类型了。例如:

*  Kotlin中的`List<Int>`等价于Java中的`List<Integer>`(**注意下: 这个地方有点问题，纠正下原文作者的一个小错误，实际上是Kotlin中的`MutableList<Int>`等价于Java中的`List<Integer>`,但是作者这里主要想表明在Kotlin中作为泛型类型参数`Int`类型情况下等同于Java中的包装器类型`Integer`而不是原始类型`int`**)
 *  Kotlin中的`Set<Double>`等价于Java中的`Set<Double>`(**注意下: 这个地方有点问题，纠正下原文作者的一个小错误，实际上是Kotlin中的`MutableSet<Double>`等价于Java中的`Set<Double>`,但是作者这里主要想表明在Kotlin中作为泛型类型参数`Double`类型情况下等同于Java中的包装器类型`Double`而不是原始类型`double`**)

当我们需要操作数据集合，这将是一笔很大的性能开销。但是也是有解决方案的， 因为Java集合允许使用原始类型。

// Java
    int[] a = {
         1,2,3,4 };

如果在Java中可以使用原始类型的数组，那么在Kotlin也是可以使用原始类型的数组的。为此，我们需要使用一种特殊的数组类型来表示具有不同原始类型的数组：  
`IntArray`、`LongArray`、`ShortArray`、`DoubleArray`、`FloatArray`或者`CharArray`. 让我们使用`IntArray`，看看与`List <Int>`相比对代码的性能影响：

open class InlineFilterBenchmark {
        
    
        lateinit var list: List<Int>
        lateinit var array: IntArray
    
        @Setup
        fun init() {
        
            list = List(1_000_000) {
         it }
            array = IntArray(1_000_000) {
         it }
        }
    
        @Benchmark
        fun averageOnIntList(): Double {
        
            return list.average()
        }
    
        @Benchmark
        fun averageOnIntArray(): Double {
        
            return array.average()
        }
    }

尽管差异不是特别大，但是也是差异也是非常明显的。例如，因为在底层实现上`IntArray`是使用原始类型的，所以`IntArray`数组的`average()`函数会比`List<Int>`集合运行效率高了约25%左右。([这里是源码,自己检查运行测试][Link 2])

具有原始类型的数组也会比集合更加轻量级。进行测量时，您会发现`IntArray`上面分配了400000016个字节，而`List<Int>`分配了2000006944个字节。大概是5倍的差距。

正如你所看到那样，使用具有原始类型的变量或者数组都是优化性能关键部分一种手段。它们需要分配的内存更少，并且处理的速度更快。尽管原始类型数组在大多数情况下作了优化，但是默认情况下可能更多是使用集合而不是数组。因为集合相比数据更加直观和更经常使用。但是你也必须记住原始类型的变量和原始类型数组带来的性能优化，并且在合适的场景中使用它们。

### 译者有话说 ###

这篇Effective Kotlin系列的文章比较简单，但是也很重要。它指出了我们经常会忽略的原始类型数组。相信很多人都习惯于使用集合，甚至有的人估计都没怎么用过Kotlin中的`IntArray、LongArray、FloatArray`等，平时不管是什么场景都使用集合一梭哈。这也很正常，因为集合基本上可以替代数组出现所有场景，而且集合使用起来更加直观和方便。但是之前的你可能不知道原来原始类型的数组可以在某些场景替代集合反而可以优化性能。所以原始类型的数组是有一定应用场景的，那么从读了这篇文章起，请一定要记住这个优化点。关于这篇文章我还想再补充几点哈:

*  1、解释下文章中的原始类型

**请注意:** 文章中的原始类型(原语类型或基本数据类型)实际上不是Kotlin中的`Int、Float、Double、Long`等这些类型，原始类型实际上它不对应一个类，就像我们常在Java中说的String不是原始类型，而是引用类型。实际这里原始类型就是指Java中的`int、double、float、long`等非引用类型。为什么说Kotlin中的`Int`不是原始类型，实际上它更是一种引用类型，一起来看`Int`的源码:

public class Int private constructor() : Number(), Comparable<Int> {
        
        companion object {
        
            public const val MIN_VALUE: Int = -2147483648
            public const val MAX_VALUE: Int = 2147483647
            @SinceKotlin("1.3")
            public const val SIZE_BYTES: Int = 4
            @SinceKotlin("1.3")
            public const val SIZE_BITS: Int = 32
        }

可以明显看出实际上`Int`是在Kotlin中定义的一个类，它属于引用类型，不是原始类型。所以我们平时在Kotlin中是不能直接声明原始类型的，而所谓原始类型是Kotlin编译器在底层做的一层内部表达。在Kotlin中声明`Int`类型，实际上底层编译器会根据具体使用情况，智能推测出是将`Int`表达为包装器`Integer`还是原始类型`int`。如果不信，请看下面这个解释的源码论证。

*  2、解释下文章中的这句话 **“尽管是可空类型，可是当它检测到你没有对可空类型变量设置null值时，然后它还是会使用原始类型处理的，如果设置null就当做非原始类型处理”** 。

把上面那句话说的通俗就是，声明一个可空类型`Int?`变量,如果没有对它做赋值null的操作，那么编译器在底层实现会把这个`Int?`类型使用原始类型`int`，如果有赋值null操作就会使用包装器类型`Integer`.一起来看个例子

//kotlin定义的源码
    fun main(args: Array<String>) {
        
        var number: Int?
        number = 2
        println(number)
    }
    //反编译后的Java代码
      public static final void main(@NotNull String[] args) {
        
          Intrinsics.checkParameterIsNotNull(args, "args");
          int number = 2;//可以明显看到number变量使用的是int原始类型
          System.out.println(number);
     }

如果把上述例子改为赋值为null

//kotlin定义的源码
    fun main(args: Array<String>) {
        
        var number: Int? = null
        number = 2
        println(number)
    }
    //反编译后的Java代码
      public static final void main(@NotNull String[] args) {
        
          Intrinsics.checkParameterIsNotNull(args, "args");
          Integer number = (Integer)null;//这里number变量是使用了Integer包装器类型
          number = 2;
          int var2 = number;
          System.out.println(var2);
       }

通过上述代码的对比，可以发现Kotlin编译器是非常智能的，这也就是解释了虽然在Kotlin定义的是`Int`，但是会根据不同的使用情况，最终转换成结果也不一样的，所以使用的时候一定要做到心里有数。

*  关于使用原始类型数组的建议

其实我们大多数情况下还是使用集合的，因为数组使用具有局限性。那么什么时候使用原始类型数组呢？  
元素的类型应该是`Int、Float、Double、Long`等这些类型，并且长度还是固定的，这种情况更多考虑是原始类型数组来替代集合的使用，因为它效率更高。其他非这种场景还是建议使用集合。

### Kotlin系列文章，欢迎查看: ###

> Effective Kotlin翻译系列

*  **[\[译\]Effective Kotlin系列之使用Sequence来优化集合的操作(四)][Effective Kotlin_Sequence]**
 *  **[\[译\]Effective Kotlin系列之探索高阶函数中inline修饰符(三)][Effective Kotlin_inline]**
 *  **[\[译\]Effective Kotlin系列之遇到多个构造器参数要考虑使用构建器(二)][Effective Kotlin]**
 *  **[\[译\]Effective Kotlin系列之考虑使用静态工厂方法替代构造器(一)][Effective Kotlin 1]**

> 原创系列：

*  **[Jetbrains开发者日见闻(三)之Kotlin1.3新特性(inline class篇)][Jetbrains_Kotlin1.3_inline class]**
 *  **[JetBrains开发者日见闻(二)之Kotlin1.3的新特性(Contract契约与协程篇)][JetBrains_Kotlin1.3_Contract]**
 *  **[JetBrains开发者日见闻(一)之Kotlin/Native 尝鲜篇][JetBrains_Kotlin_Native]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(实践篇)][Kotlin]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(下篇)][Kotlin 1]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(上篇)][Kotlin 2]**
 *  **[Kotlin的独门秘籍Reified实化类型参数(下篇)][Kotlin_Reified]**
 *  **[有关Kotlin属性代理你需要知道的一切][Kotlin 3]**
 *  **[浅谈Kotlin中的Sequences源码解析][Kotlin_Sequences]**
 *  **[浅谈Kotlin中集合和函数式API完全解析-上篇][Kotlin_API_-]**
 *  **[浅谈Kotlin语法篇之lambda编译成字节码过程完全解析][Kotlin_lambda]**
 *  **[浅谈Kotlin语法篇之Lambda表达式完全解析][Kotlin_Lambda]**
 *  **[浅谈Kotlin语法篇之扩展函数][Kotlin 4]**
 *  **[浅谈Kotlin语法篇之顶层函数、中缀调用、解构声明][Kotlin 5]**
 *  **[浅谈Kotlin语法篇之如何让函数更好地调用][Kotlin 6]**
 *  **[浅谈Kotlin语法篇之变量和常量][Kotlin 7]**
 *  **[浅谈Kotlin语法篇之基础语法][Kotlin 8]**

> 翻译系列：

*  **[\[译\]Kotlin中内联类的自动装箱和高性能探索(二)][Kotlin 9]**
 *  **[\[译\]Kotlin中内联类(inline class)完全解析(一)][Kotlin_inline class]**
 *  **[\[译\]Kotlin的独门秘籍Reified实化类型参数(上篇)][Kotlin_Reified 1]**
 *  **[\[译\]Kotlin泛型中何时该用类型形参约束?][Kotlin 10]**
 *  **[\[译\] 一个简单方式教你记住Kotlin的形参和实参][_Kotlin]**
 *  **[\[译\]Kotlin中是应该定义函数还是定义属性?][Kotlin 11]**
 *  **[\[译\]如何在你的Kotlin代码中移除所有的!!(非空断言)][Kotlin 12]**
 *  **[\[译\]掌握Kotlin中的标准库函数: run、with、let、also和apply][Kotlin_ run_with_let_also_apply]**
 *  **[\[译\]有关Kotlin类型别名(typealias)你需要知道的一切][Kotlin_typealias]**
 *  **[\[译\]Kotlin中是应该使用序列(Sequences)还是集合(Lists)?][Kotlin_Sequences_Lists]**
 *  **[\[译\]Kotlin中的龟(List)兔(Sequence)赛跑][Kotlin_List_Sequence]**

> 实战系列:

*  **[用Kotlin撸一个图片压缩插件ImageSlimming-导学篇(一)][Kotlin_ImageSlimming-]**
 *  **[用Kotlin撸一个图片压缩插件-插件基础篇(二)][Kotlin_-]**
 *  **[用Kotlin撸一个图片压缩插件-实战篇(三)][Kotlin_- 1]**
 *  **[浅谈Kotlin实战篇之自定义View图片圆角简单应用][Kotlin_View]**

![1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536][]

**欢迎关注Kotlin开发者联盟，这里有最新Kotlin技术文章，每周会不定期翻译一篇Kotlin国外技术文章。如果你也喜欢Kotlin，欢迎加入我们~~~**

[https_blog.kotlin-academy.com_effective-kotlin-use-sequence-for-bigger-collections-with-more-than-one-processing-step-649a15bb4bf]: https://blog.kotlin-academy.com/effective-kotlin-use-sequence-for-bigger-collections-with-more-than-one-processing-step-649a15bb4bf
[Marcin Moskala]: https://blog.kotlin-academy.com/@marcinmoskala?source=post_header_lockup
[Link 1]: https://github.com/MarcinMoskala/effective-kotlin-tests/blob/master/src/main/java/org/kotlinacademy/PrimitivesJavaBenchmark.java
[167a8036fab36474_w_800_h_450_f_jpeg_s_87687]: https://user-gold-cdn.xitu.io/2018/12/13/167a8036fab36474?w=800&h=450&f=jpeg&s=87687
[Link 2]: https://github.com/MarcinMoskala/effective-kotlin-tests/blob/master/src/main/kotlin/org/kotlinacademy/PrimitiveArraysBenchmark.kt
[Effective Kotlin_Sequence]: https://juejin.im/post/5c113881f265da61715e3361
[Effective Kotlin_inline]: https://juejin.im/post/5c0e6b31f265da612637fd7d
[Effective Kotlin]: https://juejin.im/post/5b8698bce51d4538a423dd70
[Effective Kotlin 1]: https://juejin.im/post/5b78f805e51d4538c2108951
[Jetbrains_Kotlin1.3_inline class]: https://juejin.im/post/5c0558fa51882545e24edead
[JetBrains_Kotlin1.3_Contract]: https://juejin.im/post/5c0150f8e51d4540611e15e0
[JetBrains_Kotlin_Native]: https://juejin.im/post/5c03fadff265da6165015211
[Kotlin]: https://juejin.im/post/5bfca603f265da61441fbcf9
[Kotlin 1]: https://juejin.im/post/5beb1031f265da61441f9a9f
[Kotlin 2]: https://juejin.im/post/5be442afe51d451def13d76d
[Kotlin_Reified]: https://juejin.im/post/5bd45ae16fb9a05d2a1db51b
[Kotlin 3]: https://juejin.im/post/5ba64572e51d4527ed0024dd
[Kotlin_Sequences]: https://juejin.im/post/5b8958bdf265da43351d6d29
[Kotlin_API_-]: https://juejin.im/post/5ac0dd32f265da237d03271e
[Kotlin_lambda]: https://juejin.im/post/5adfdb8d6fb9a07ab773dc40
[Kotlin_Lambda]: https://juejin.im/post/5ac0dca8f265da237e09ddc1
[Kotlin 4]: https://juejin.im/post/5acb7ad16fb9a028e33bc0ea
[Kotlin 5]: https://juejin.im/post/5ac0dc18f265da2397070124
[Kotlin 6]: https://juejin.im/post/5ac0dabaf265da237a4d2941
[Kotlin 7]: https://juejin.im/post/5ac0d9d9f265da237d032713
[Kotlin 8]: https://juejin.im/post/5aba47ca5188255c56687783
[Kotlin 9]: https://juejin.im/post/5c0a6a00e51d45524146dd1d
[Kotlin_inline class]: https://juejin.im/post/5c0928766fb9a049d131eff3
[Kotlin_Reified 1]: https://juejin.im/post/5bd1d590518825288b398f46
[Kotlin 10]: https://juejin.im/post/5bceb5915188255c6b654cec
[_Kotlin]: https://juejin.im/post/5bc5f41f6fb9a05d1a1305e1
[Kotlin 11]: https://juejin.im/post/5afc23446fb9a07ab979abdf
[Kotlin 12]: https://juejin.im/post/5afd9090f265da0ba46a0429
[Kotlin_ run_with_let_also_apply]: https://juejin.im/post/5b0048ed518825428a2619ed
[Kotlin_typealias]: https://juejin.im/post/5b052f806fb9a07ac0229ce3
[Kotlin_Sequences_Lists]: https://juejin.im/post/5b13fdace51d450696590828
[Kotlin_List_Sequence]: https://juejin.im/post/5b28f4946fb9a00e3a5a9b8c
[Kotlin_ImageSlimming-]: https://juejin.im/post/5b3453fe6fb9a00e883f37fa
[Kotlin_-]: https://juejin.im/post/5b34fdb26fb9a00e356844b8
[Kotlin_- 1]: https://juejin.im/post/5b34fe66e51d4558ba1a8445
[Kotlin_View]: https://juejin.im/post/5ae1755d6fb9a07ab9792da4
[1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536]: https://user-gold-cdn.xitu.io/2018/5/14/1635c3fb0ba21ec1?w=430&h=430&f=jpeg&s=39536