共计 5818 个字符,预计需要花费 15 分钟才能阅读完成。
这是 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 中的代码。
Function declaration | Kotlin usage | Java usage |
---|---|---|
Companion object | Foo. F () | Foo. Companion. F (); |
Companion object with @JvmStatic | Foo. F () | Foo. F (); |
Object | Foo. F () | Foo. INSTANCE. F (); |
Object with @JvmStatic | Foo. F () | Foo. F (); |
Top level function | f () | UtilKt. F (); |
Top level function with @JvmName | f () | Util. F (); |
同样的规定也实用于变量,@JvmField
注解用于变量上,加上 const
关键字,编译时能够将常量值内联到调用处。
Variable declaration | Kotlin usage | Java usage |
---|---|---|
Companion object | X. X | X. Companion. GetX (); |
Companion object with @JvmStatic | X. X | X. GetX (); |
Companion object with @JvmField | X. X | X. X; |
Companion object with const | X. X | X. X; |
Object | X. X | X. INSTANCE. GetX (); |
Object with @JvmStatic | X. X | X. GetX (); |
Object with @JvmField | X. X | X. X |
Object with const | X. X | X. X; |
Top level variable | X. X | ConstKt. GetX (); |
Top level variable with @JvmField | X. X | ConstKt. X; |
Top level variable with const | x | ConstKt. X; |
Top level variable with @JvmName | x | Const. GetX (); |
Top level variable with @JvmName and @JvmField | x | Const. X; |
Top level variable with @JvmName and const | x | Const. X; |
为什么 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 indent4
import com.example.square.indent as indent2
"hello world".indent4()
另外一个案例,想在同一个文件中应用来自不同包中两个具备雷同名称的类(例如 java.util.Date
和 java.sql.Date
),并且您不心愿通过齐全限定包名来调用它们。咱们也能够在 import
语句中应用 as
关键字对其重命名。
import java.util.Date as UtilDate
import java.sql.Date as SqlDate
当初咱们就能够在这个类中,应用通过 as
关键字申明的别名来援用这些类。