关于android:Stack-Overflow-上最热门的-10-个-Kotlin-问题

这是 Stack Overflow 上最热门的几个 Kotlin 问题，每个问题如果更深刻的剖析，都能够独自写一篇文章，前面我会针对这些问题，在进一步的剖析。

通过这篇文章你将学习到以下内容：

• Array<Int> 和 IntArray 的区别，以及如何抉择
• Iterable 和 Sequence 的区别，以及如何抉择
• 罕用的 8 种 For 循环遍历的办法
• 在 Kotlin 中如何应用 SAM 转换
• 如何申明一个动态成员，Java 和 Koltin 进行互操作
• 为什么 kotlin 中的智能转换不能用于可变属性，如何能力解决这个问题
• 当重写 Java 函数时，如何决定参数的可空性
• 如何在一个文件中应用多个具备雷同名称的扩大函数和类

译文

Array 和 IntArray 的区别

Array

Array<T> 能够为任何 T 类型存储固定数量的元素。它和 Int 类型参数一起应用, 例如 Array<Int>，编译成 Java 代码，会生成 Integer[] 实例。咱们能够通过 arrayOf 办法创立数组。

val arrayOfInts: Array<Int> = arrayOf(1, 2, 3, 4, 5)

IntArray

IntArray 能够让咱们应用根底数据类型的数组，编译成 Java 代码，会生成 int[] (其它的根底类型的数组还有 ByteArray , CharArray 等等), 咱们能够通过 intArrayOf 工厂办法创立数组。

val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5)

什么时候应用 Array<Int> 或者 IntArray

默认应用 IntArray，因为它的性能更好，不须要对每个元素进行装箱。IntArray 进行初始化的时候，默认将每个索引的值初始化为 0，代码如下所示。

val intArray = IntArray(10)val arrayOfInts = Array<Int>(5) { i -> i * 2 }

而 Array<Int> 的性能比拟差，会对每个元素进行装箱，如果你须要创立蕴含 null 值的数组，Kotlin 也提供了 arrayOfNulls 办法，帮忙咱们进行创立。

val notActualPeople: Array<Person?> = arrayOfNulls<Person>(13)

Iterable 和 Sequence 的区别

Iterable

Iterable 对应 Java 的 java.lang.Iterable, Iterable 会立刻解决输出的元素，并返回一个蕴含后果的新汇合。咱们来举一个简略的例子 返回年龄 > 21 前 5 集体的汇合。

val people: List<Person> = getPeople()val allowedEntrance = people        .filter { it.age >= 21 }        .map { it.name }        .take(5)

• 首先通过 filter 函数查看每个人的年龄，将后果放入到一个新的后果集中
• 通过 map 函数对上一步失去的后果进行名字映射，而后生成一个新的列表 list<String>
• 通过 take 函数返回前 5 个元素，失去最终的后果集

Sequence

Sequence 是 Kotlin 中一个新的概念，用来示意一个提早计算的汇合。Sequence 只存储操作过程，并不解决任何元素，直到遇到终端操作符才开始解决元素，咱们也能够通过 asSequence 扩大函数，将现有的汇合转换为 Sequence ，代码如下所示。

val people: List<Person> = getPeople()val allowedEntrance = people.asSequence()    .filter { it.age >= 21 }    .map { it.name }    .take(5)    .toList()

在这个例子中， toList() 示意终端操作符，filter 、 map 、 take 都是两头操作符，返回 Sequence 实例，当 Sequence 遇到两头操作符时，只是存储操作过程，并不参加计算，直到遇到 toList()。

Sequence 的益处它不会生成两头后果集，间接对原始列表中的每一个人反复这个步骤，直到找到 5 集体，返回最终的后果集。

应该如何抉择

如果数据量比拟小，能够应用 Iterable。尽管会创立两头后果集，在数据不大的状况下，对性能的影响不会很重大。

如果解决的数据量比拟大，Sequence 是最好的抉择，因为不会创立两头后果集，内存开销更小。

罕用的 8 种 For 循环遍历办法

咱们常常会应用以下办法进行遍历。

for (i in 0..args.size - 1) {    println(args[i])}

然而 Array 有一个可读性更强的扩大属性 lastIndex。

for (i in 0..args.lastIndex) {    println(args[i])}

然而实际上咱们不须要晓得最初一个索引，有一个更加简略的写法。

for (i in 0 until args.size) {    println(args[i])}

当然你也能够应用下标扩大属性 indices 失去它的范畴。

for (i in args.indices) {    println(args[i])}

还有一个更加间接的写法，通过上面的形式间接迭代汇合。

for (arg in args) {    println(arg)}

您也能够应用 forEach 函数，传递一个 lambda 表达式来解决每个元素。

args.forEach { arg ->    println(arg)}

它们生成的 Java 代码都十分的类似，在这些例子中，都减少一个索引变量，并在循环中通过索引获取元素。然而如果咱们迭代的是 List，最初两个例子底层应用 Iterator，而其余的例子仍是通过索引获取元素。另外还有两个遍历的办法：

• withIndex 函数，它返回一个 Iterable 对象，该对象能够被解构为以后索引和元素。

for ((index, arg) in args.withIndex()) {    println("$index: $arg")}

• forEachIndexed 函数，它为每个索引和参数提供了一个 lambda 表达式。

args.forEachIndexed { index, arg ->    println("$index: $arg")}

如何应用 SAM 转换

能够通过 lambda 表达式实现 SAM 转换，从而使代码更简洁，可读性更强，咱们来看一个例子。

在 Java 中定义一个 OnClickListener 接口，并申明一个 onClick 的办法。

public interface OnClickListener {    void onClick(Button button);}

咱们给 Button 增加 OnClickListener 监听器，每次点击的时候都会被调用。

public class Button {    public void setListener(OnClickListener listener) { ... }}

在 Kotlin 中常见的写法，创立匿名类，实现 OnClickListener 接口。

button.setListener(object: OnClickListener {    override fun onClick(button: Button) {        println("Clicked!")    }})

如果咱们应用 SAM 转换，将使代码更简洁，可读性更强。

button.setListener {    fun onClick(button: Button) {        println("Clicked!")    }}

如何申明一个动态成员，Java 和 Koltin 进行互操作

一个一般的类能够有动态成员和非动态成员，在 Kotlin 中咱们常把动态成员放到 companion object 中。

class Foo {    companion object {        fun x() { ... }    }    fun y() { ... }}

咱们也能够用 object 来申明一个单例，替换 companion object。

object Foo {    fun x() { ... }}

如果你不想总是通过类名去调用 Foo.x(), 而只是想应用 x()，能够申明为顶级函数。

fun x() { ... }

另外想在 Java 中调用 Kotlin 中静态方法，须要增加 @JvmStatic 和 @JvmName 注解。用一张表格汇总一下，如何在 Java 中调用 Kotlin 中的代码。

同样的规定也实用于变量，@JvmField 注解用于变量上，加上 const 关键字，编译时能够将常量值内联到调用处。

为什么 kotlin 中的智能转换不能用于可变属性

咱们先来看一段有问题的代码。

class Dog(var toy: Toy? = null) {    fun play() {        if (toy != null) {            toy.chew()        }    }}

下面的代码在编译时无奈通过，异样信息如下所示。

Kotlin: Smart cast to 'Toy' is impossible, because 'toy' is a mutable property that could have been changed by this time

呈现这个问题的起因在于，执行完 toy != null 之后和 toy.chew() 办法被调用之间，这个 Dog 的实例可能被另外一个线程批改，这可能会呈现 NullPointerException 异样。

如何能力解决这个问题呢

只须要将变量设置为不可变的，即用 val 申明，那么下面的问题就不存在，默认状况将所有的变量都用 val 申明，除非有必要的时候，才将它们设置为 var。

如果肯定要申明为 var ，那么能够应用部分不可变的副原本解决这个问题。批改一下下面的代码，如下所示。

class Dog(var toy: Toy? = null) {    fun play() {        val _toy = toy        if (_toy != null) {            _toy.chew()        }    }}

然而还有一个更简洁的写法。

class Dog(var toy: Toy? = null) {    fun play() {        toy?.length    }}

当重写 Java 函数时，如何决定参数的可空性

在 Java 中定义一个 OnClickListener 接口，并申明一个 onClick 的办法。

public interface OnClickListener {    void onClick(Button button);}

在 Kotlin 中实现这个接口，并通过 IDEA 主动生成 onClick 办法，将会失去上面的办法签名，onClick 办法参数默认为可空类型。

class KtListener: OnClickListener {    override fun onClick(button: Button?): Unit {        val name = button?.name ?: "Unknown button"        println("Clicked $name")    }}

因为 Java 平台没有可空类型，而 Kotlin 中有，在这个例子中 Button 是否为空由咱们来决定。默认状况下，对所有参数应用可空类型更平安，编译器会强制咱们解决这些参数。

对于已知的永远不会空的参数，能够应用非空类型，空和非空都能够失常编译，然而如果将办法参数申明为非空，那么 Kotlin 编译器会主动注入一个空的查看，可能会抛出 IllegalArgumentException 异样，潜在的危险很大。当然应用非空参数，代码将会更加简洁。

class KtListener: OnClickListener {    override fun onClick(button: Button): Unit {        val name = button.name        println("Clicked $name")    }}

如何在一个文件中应用多个具备雷同名称的扩大函数和类

假如在不同的包中对 String 类实现了两个雷同名字的扩大函数，如果是一个一般函数，你能够应用齐全限定包名来调用它，然而扩大函数不行。所以咱们能够在 import 语句中应用 as 关键字对其重命名，代码如下所示。

import com.example.code.indent as indent4import com.example.square.indent as indent2"hello world".indent4()

另外一个案例，想在同一个文件中应用来自不同包中两个具备雷同名称的类（例如 java.util.Date 和 java.sql.Date ），并且您不心愿通过齐全限定包名来调用它们。咱们也能够在 import 语句中应用 as 关键字对其重命名。

import java.util.Date as UtilDateimport java.sql.Date as SqlDate

当初咱们就能够在这个类中，应用通过 as 关键字申明的别名来援用这些类。