90%的开发者都不知道的 Kotlin技巧以及原理解析（一）

fun main() {

val numbersMap = mapOf(“one” to 1, “two” to 2, “three” to 3)

// plus (+)

println(numbersMap + Pair(“four”, 4)) // {one=1, two=2, three=3, four=4}

println(numbersMap + Pair(“one”, 10)) // {one=10, two=2, three=3}

println(numbersMap + Pair(“five”, 5) + Pair(“one”, 11)) // {one=11, two=2, three=3, five=5}

// minus (-)

println(numbersMap - “one”) // {two=2, three=3}

println(numbersMap - listOf(“two”, “four”)) // {one=1, three=3}

}

其实这里用到了运算符重载，Kotlin 在 Maps.kt 文件里面，定义了一系列用关键字 operator 声明的 Map 的扩展函数。

用 operator 关键字声明 plus 函数，可以直接使用 + 号来做运算，使用 operator 修饰符声明 minus 函数，可以直接使用 - 号来做运算，其实我们也可以在自定义类里面实现 plus (+) 和 minus (-) 做运算。

data class Salary(var base: Int = 100){

override fun toString(): String = base.toString()

}

operator fun Salary.plus(other: Salary): Salary = Salary(base + other.base)

operator fun Salary.minus(other: Salary): Salary = Salary(base - other.base)

val s1 = Salary(10)

val s2 = Salary(20)

println(s1 + s2) // 30

println(s1 - s2) // -10

Map 集合的默认值

---

在 Map 集合中，可以使用 withDefault 设置一个默认值，当键不在 Map 集合中，通过 getValue 返回默认值。

val map = mapOf(

“java” to 1,

“kotlin” to 2,

“python” to 3

).withDefault { “?” }

println(map.getValue(“java”)) // 1

println(map.getValue(“kotlin”)) // 2

println(map.getValue(“c++”)) // ?

源码实现也非常简单，当返回值为 null 时，返回设置的默认值。

internal inline fun <K, V> Map<K, V>.getOrElseNullable(key: K, defaultValue: () -> V): V {

val value = get(key)

if (value == null && !containsKey(key)) {

return defaultValue()

} else {

@Suppress(“UNCHECKED_CAST”)

return value as V

}

}

但是这种写法和 plus 操作符在一起用，有一个 bug ，看一下下面这个例子。

val newMap = map + mapOf(“python” to 3)

println(newMap.getValue(“c++”)) // 调用 getValue 时抛出异常，异常信息：Key c++ is missing in the map.

这段代码的意思就是，通过 plus(+) 操作符合并两个 map，返回一个新的 map, 但是忽略了默认值，所以看到上面的错误信息，我们在开发的时候需要注意这点。

使用 require 或者 check 函数作为条件检查

---

// 传统的做法

val age = -1;

if (age <= 0) {

throw IllegalArgumentException(“age must not be negative”)

}

// 使用 require 去检查

require(age > 0) { “age must be negative” }

// 使用 checkNotNull 检查

val name: String? = null

checkNotNull(name){

“name must not be null”

}

那么我们如何在项目中使用呢，具体的用法可以查看我 GitHub 上的项目 DataBindingDialog.kt 当中的用法。

如何区分和使用 run, with, let, also, apply

---

感谢大神 Elye 的这篇文章提供的思路 Mastering Kotlin standard functions。

run, with, let, also, apply 都是作用域函数，这些作用域函数如何使用，以及如何区分呢，我们将从以下三个方面来区分它们。

• 是否是扩展函数。

• 作用域函数的参数（this、it）。

• 作用域函数的返回值（调用本身、其他类型即最后一行）。

是否是扩展函数

首先我们来看一下 with 和 T.run，这两个函数非常的相似，他们的区别在于 with 是个普通函数，T.run 是个扩展函数，来看一下下面的例子。

val name: String? = null

with(name){

val subName = name!!.substring(1,2)

}

// 使用之前可以检查它的可空性

name?.run { val subName = name.substring(1,2) }?:throw IllegalArgumentException(“name must not be null”)

在这个例子当中，name?.run 会更好一些，因为在使用之前可以检查它的可空性。

作用域函数的参数（this、it）

我们在来看一下 T.run 和 T.let，它们都是扩展函数，但是他们的参数不一样 T.run 的参数是 this, T.let 的参数是 it。

val name: String? = “hi-dhl.com”

// 参数是 this，可以省略不写

name?.run {

println(“The length is ${this.length} this 是可以省略的 ${length}”)

}

// 参数 it

name?.let {

println(“The length is ${it.length}”)

}

// 自定义参数名字

name?.let { str ->

println(“The length is ${str.length}”)

}

在上面的例子中看似 T.run 会更好，因为 this 可以省略，调用更加的简洁，但是 T.let 允许我们自定义参数名字，使可读性更强，如果倾向可读性可以选择 T.let。

作用域函数的返回值（调用本身、其他类型）

接下里我们来看一下 T.let 和 T.also 它们接受的参数都是 it, 但是它们的返回值是不同的 T.let 返回最后一行，T.also 返回调用本身。

var name = “hi-dhl”

// 返回调用本身

name = name.also {

val result = 1 * 1

“juejin”

}

println(“name = ${name}”) // name = hi-dhl

// 返回的最后一行

name = name.let {

val result = 1 * 1

“hi-dhl.com”

}

println(“name = ${name}”) // name = hi-dhl.com

从上面的例子来看 T.also 似乎没有什么意义，细想一下其实是非常有意义的，在使用之前可以进行自我操作，结合其他的函数，功能会更强大。

fun makeDir(path: String) = path.let{ File(it) }.also{ it.mkdirs() }

当然 T.also 还可以做其他事情，比如利用 T.also 在使用之前可以进行自我操作特点，可以实现一行代码交换两个变量，在后面会有详细介绍

T.apply 函数

通过上面三个方面，大致了解函数的行为，接下来看一下 T.apply 函数，T.apply 函数是一个扩展函数，返回值是它本身，并且接受的参数是 this。

// 普通方法

fun createInstance(args: Bundle) : MyFragment {

val fragment = MyFragment()

fragment.arguments = args

return fragment

}

// 改进方法

fun createInstance(args: Bundle)

= MyFragment().apply { arguments = args }

// 普通方法

fun createIntent(intentData: String, intentAction: String): Intent {

val intent = Intent()

intent.action = intentAction

intent.data=Uri.parse(intentData)

return intent

}

// 改进方法，链式调用

fun createIntent(intentData: String, intentAction: String) =

Intent().apply { action = intentAction }

.apply { data = Uri.parse(intentData) }

汇总

以表格的形式汇总，更方便去理解

| 函数 | 是否是扩展函数 | 函数参数(this、it) | 返回值(调用本身、最后一行) |

| — | — | — | — |

| with | 不是 | this | 最后一行 |

| T.run | 是 | this | 最后一行 |

| T.let | 是 | it | 最后一行 |

| T.also | 是 | it | 调用本身 |

| T.apply | 是 | this | 调用本身 |

使用 T.also 函数交换两个变量

接下来演示的是使用 T.also 函数，实现一行代码交换两个变量？我们先来回顾一下 Java 的做法。

int a = 1;

int b = 2;

// Java - 中间变量

int temp = a;

a = b;

b = temp;

System.out.println("a = “+a +” b = "+b); // a = 2 b = 1

// Java - 加减运算

a = a + b;

b = a - b;

a = a - b;

System.out.println("a = " + a + " b = " + b); // a = 2 b = 1

// Java - 位运算

a = a ^ b;

b = a ^ b;

a = a ^ b;

System.out.println("a = " + a + " b = " + b); // a = 2 b = 1

// Kotlin

a = b.also { b = a }

println(“a = ${a} b = ${b}”) // a = 2 b = 1

来一起分析 T.also 是如何做到的，其实这里用到了 T.also 函数的两个特点。

• 调用 T.also 函数返回的是调用者本身。

• 在使用之前可以进行自我操作。

也就是说 b.also { b = a } 会先将 a 的值 (1) 赋值给 b，此时 b 的值为 1，然后将 b 原始的值（2）赋值给 a，此时 a 的值为 2，实现交换两个变量的目的。

in 和 when 关键字

---

使用 in 和 when 关键字结合正则表达式，验证用户的输入，这是一个很酷的技巧。

// 使用扩展函数重写 contains 操作符

operator fun Regex.contains(text: CharSequence) : Boolean {

return this.containsMatchIn(text)

}

// 结合着 in 和 when 一起使用

when (input) {

in Regex(“[0–9]”) -> println(“contains a number”)

in Regex(“[a-zA-Z]”) -> println(“contains a letter”)

}

in 关键字其实是 contains 操作符的简写，它不是一个接口，也不是一个类型，仅仅是一个操作符，也就是说任意一个类只要重写了 contains 操作符，都可以使用 in 关键字，如果我们想要在自定义类型中检查一个值是否在列表中，只需要重写 contains() 方法即可，Collections 集合也重写了 contains 操作符。

val input = “kotlin”

when (input) {

in listOf(“java”, “kotlin”) -> println(“found ${input}”)

in setOf(“python”, “c++”) -> println(“found ${input}”)

else -> println(" not found ${input}")

}

Kotlin 的单例三种写法

---

我汇总了一下目前 Kotlin 单例总共有三种写法：

• 使用 Object 实现单例。

• 使用 by lazy 实现单例。

• 可接受参数的单例（来自大神 Christophe Beyls）。

使用 Object 实现单例

代码：

object WorkSingleton

Kotlin 当中 Object 关键字就是一个单例，比 Java 的一坨代码看起来舒服了很多，来看一下编译后的 Java 文件。

public final class WorkSingleton {

public static final WorkSingleton INSTANCE;

static {

WorkSingleton var0 = new WorkSingleton();

INSTANCE = var0;

}

}

通过 static 代码块实现的单例，优点：饿汉式且是线程安全的，缺点：类加载时就初始化，浪费内存。

使用 by lazy 实现单例

利用伴生对象 和 by lazy 也可以实现单例，代码如下所示。

class WorkSingleton private constructor() {

companion object {

// 方式一

val INSTANCE1 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) { WorkSingleton() }

// 方式二 默认就是 LazyThreadSafetyMode.SYNCHRONIZED，可以省略不写，如下所示

val INSTANCE2 by lazy { WorkSingleton() }

}

}

lazy 的延迟模式有三种：

• 上面代码所示 mode = LazyThreadSafetyMode.SYNCHRONIZED，lazy 默认的模式，可以省掉，这个模式的意思是：如果有多个线程访问，只有一条线程可以去初始化 lazy 对象。

• 当 mode = LazyThreadSafetyMode.PUBLICATION 表达的意思是：对于还没有被初始化的 lazy 对象，可以被不同的线程调用，如果 lazy 对象初始化完成，其他的线程使用的是初始化完成的值。

• mode = LazyThreadSafetyMode.NONE 表达的意思是：只能在单线程下使用，不能在多线程下使用，不会有锁的限制，也就是说它不会有任何线程安全的保证以及相关的开销。

通过上面三种模式，这就可以理解为什么 by lazy 声明的变量只能用 val，因为初始化完成之后它的值是不会变的。

可接受参数的单例

但是有的时候，希望在单例实例化的时候传递参数，例如：

Singleton.getInstance(context).doSome()

上面这两种形式都不能满足，来看看大神 Christophe Beyls 在这篇文章给出的方法 Kotlin singletons with argument 代码如下。

class WorkSingleton private constructor(context: Context) {

init {

// Init using context argument

}

companion object : SingletonHolder<WorkSingleton, Context>(::WorkSingleton)

}

open class SingletonHolder<out T : Any, in A>(creator: (A) -> T) {

private var creator: ((A) -> T)? = creator

@Volatile

private var instance: T? = null

fun getInstance(arg: A): T {

val i = instance

if (i != null) {

return i

}

return synchronized(this) {

val i2 = instance

if (i2 != null) {

i2

} else {

val created = creator!!(arg)

instance = created

creator = null

created

}

}