为数不多的人知道的-Kotlin-技巧以及-原理解析(二)，android系统工程师面试题

为了方便有学习需要的朋友，我把资料都整理成了视频教程（实际上比预期多花了不少精力），由于篇幅有限，都放在了我的GitHub上，点击即可免费获取！Androidndroid架构视频+BAT面试专题PDF+学习笔记当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。早早确定自己的职业方向

程序员里德Sa

754人浏览 · 2024-03-22 11:27:28

程序员里德Sa · 2024-03-22 11:27:28 发布

Sequence 和 Iterator 不同之处

为什么 Kolin 会返回 Sequence，而不返回 Iterator？其实这个核心原因由于 Sequence 和 Iterator 实现不同导致内存和性能有很大的差异。

接下来我们围绕这两个方面来分析它们的性能，Sequences(序列) 和 Iterator(迭代器) 都是一个比较大的概念，本文的目的不是去分析它们，所以在这里不会去详细分析 Sequence 和 Iterator，只会围绕着内存和性能两个方面去分析它们的区别，让我们有一个直观的印象。更多信息可以查看国外一位大神写的文章 Prefer Sequence for big collections with more than one processing step。

Sequence 和 Iterator 从代码结构上来看，它们非常的相似如下所示：

interface Iterable {
operator fun iterator(): Iterator
}

interface Sequence {
operator fun iterator(): Iterator
}
复制代码

除了代码结构之外，Sequences(序列) 和 Iterator(迭代器) 它们的实现完全不一样。

Sequences(序列)

Sequences 是属于懒加载操作类型，在 Sequences 处理过程中，每一个中间操作不会进行任何计算，它们只会返回一个新的 Sequence，经过一系列中间操作之后，会在末端操作 toList 或 count 等等方法中进行最终的求职运算，如下图所示。

[图片上传失败…(image-643844-1594646872316)]

在 Sequences 处理过程中，会对单个元素进行一系列操作，然后在对下一个元素进行一系列操作，直到所有元素处理完毕。

val data = (1…3).asSequence()
.filter { print("F $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots.map { print("M$ it, "); it * 2 }
.forEach { print("E$it, ") }
println(data)

// 输出 F1, M1, E2, F2, F3, M3, E6
复制代码

[图片上传失败…(image-28a57e-1594646872316)]

如上所示：在 Sequences 处理过程中，对 1 进行一系列操作输出 F1, M1, E2, 然后对 2 进行一系列操作，依次类推，直到所有元素处理完毕，输出结果为 F1, M1, E2, F2, F3, M3, E6。

在 Sequences 处理过程中，每一个中间操作（ map、filter 等等）不进行任何计算，只有在末端操作（ toList、count、forEach 等等方法）进行求值运算，如何区分是中间操作还是末端操作，看方法的返回类型，中间操作返回的是 Sequence，末端操作返回的是一个具体的类型（ List、int、Unit 等等）源码如下所示。

// 中间操作 map ，返回的是 Sequence
public fun <T, R> Sequence.map(transform: (T) -> R): Sequence {
return TransformingSequence(this, transform)
}

// 末端操作 toList 返回的是一个具体的类型（List）
public fun Sequence.toList(): List {
return this.toMutableList().optimizeReadOnlyList()
}

// 末端操作 forEachIndexed 返回的是一个具体的类型（Unit）
public inline fun Sequence.forEachIndexed(action: (index: Int, T) -> Unit): Unit {
var index = 0
for (item in this) action(checkIndexOverflow(index++), item)
}
复制代码

如果是中间操作 map、filter 等等，它们返回的是一个 Sequence，不会进行任何计算
如果是末端操作 toList、count、forEachIndexed 等等，返回的是一个具体的类型（ List、int、Unit 等等），会做求值运算

Iterator(迭代器)

在 Iterator 处理过程中，每一次的操作都是对整个数据进行操作，需要开辟新的内存来存储中间结果，将结果传递给下一个操作，代码如下所示：

val data = (1…3).asIterable()
.filter { print("F $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots.map { print("M$ it, "); it * 2 }
.forEach { print("E$it, ") }
println(data)

// 输出 F1, F2, F3, M1, M3, E2, E6
复制代码

[图片上传失败…(image-dae99a-1594646872315)]

如上所示：在 Iterator 处理过程中，调用 filter 方法对整个数据进行操作输出 F1, F2, F3，将结果存储到 List 中, 然后将结果传递给下一个操作（ map ）输出 M1, M3 将新的结果在存储的 List 中, 直到所有操作处理完毕。

// 每次操作都会开辟一块新的空间，存储计算的结果
public inline fun Iterable.filter(predicate: (T) -> Boolean): List {
return filterTo(ArrayList(), predicate)
}

// 每次操作都会开辟一块新的空间，存储计算的结果
public inline fun <T, R> Iterable.map(transform: (T) -> R): List {
return mapTo(ArrayList(collectionSizeOrDefault(10)), transform)
}
复制代码

对于每次操作都会开辟一块新的空间，存储计算的结果，这是对内存极大的浪费，我们往往只关心最后的结果，而不是中间的过程。

了解完 Sequences 和 Iterator 不同之处，接下里我们从性能和内存两个方面来分析 Sequences 和 Iterator。

Sequences 和 Iterator 性能对比

分别使用 Sequences 和 Iterator 调用它们各自的 filter、map 方法，处理相同的数据的情况下，比较它们的执行时间。

使用 Sequences ：

val time = measureTimeMillis {
(1…10000000 * 10).asSequence()
.filter { it % 2 == 1 }
.map { it * 2 }
.count()
}

println(time) // 1197
复制代码

使用 Iterator ：

val time2 = measureTimeMillis {
(1…10000000 * 10).asIterable()
.filter { it % 2 == 1 }
.map { it * 2 }
.count()
}

println(time2) // 23641
复制代码

Sequences 和 Iterator 处理时间如下所示：

Sequences	Iterator
1197	23641

这个结果是很让人吃惊的，Sequences 比 Iterator 快 19 倍，如果数据量越大，它们的时间差距会越来越大，当我们在读取文件的时候，可能会进行一系列的数据操作 drop、filter 等等，所以 Kotlin 库函数 useLines 等等方法会返回 Sequences，因为它们更加的高效。

Sequences 和 Iterator 内存对比

这里使用了 Prefer Sequence for big collections with more than one processing step 文章的一个例子。

有 1.53 GB 犯罪分子的数据存储在文件中，从文件中找出有多少犯罪分子携带大麻，分别使用 Sequences 和 Iterator，我们先来看一下如果使用 Iterator 处理会怎么样（这里调用 readLines函返回 List<String>）

File(“ChicagoCrimes.csv”).readLines()
.drop(1) // Drop descriptions of the columns
.mapNotNull { it.split(“,”).getOrNull(6) }
// Find description
.filter { “CANNABIS” in it }
.count()
.let(::println)
复制代码

运行完之后，你将会得到一个意想不到的结果 OutOfMemoryError

Exception in thread “main” java.lang.OutOfMemoryError: Java heap space
复制代码

调用 readLines 函返回一个集合，有 3 个中间操作，每一个中间操作都需要一块空间存储 1.53 GB 的数据，它们需要占用超过 4.59 GB 的空间，每次操作都开辟了一块新的空间，这是对内存巨大浪费。如果我们使用序列 Sequences 会怎么样呢?（调用 useLines 方法返回的是一个 Sequences）。

File(“ChicagoCrimes.csv”).useLines { lines ->
// The type of lines is Sequence
lines
.drop(1) // Drop descriptions of the columns
.mapNotNull { it.split(“,”).getOrNull(6) }
// Find description
.filter { “CANNABIS” in it }
.count()
.let { println(it) } // 318185
复制代码

没有出现 OutOfMemoryError 异常，共耗时 8.3 s，由此可见对于文件操作使用序列不仅能提高性能，还能减少内存的使用，从性能和内存这两面也解释了为什么 Kotlin 库的扩展方法 useLines等等，读取文件的时候使用 Sequences 而不使用 Iterator。

便捷的 joinToString 方法的使用

joinToString 方法提供了一组丰富的可选择项（分隔符，前缀，后缀，数量限制等等）可用于将可迭代对象转换为字符串。

val data = listOf(“Java”, “Kotlin”, “C++”, “Python”)
.joinToString(
separator = " | ",
prefix = “{”,
postfix = “}”
) {
it.toUpperCase()
}

println(data) // {JAVA | KOTLIN | C++ | PYTHON}
复制代码

这是很常见的用法，将集合转换成字符串，高效利用便捷的joinToString 方法，开发的时候事半功倍，既然可以添加前缀，后缀，那么可以移除它们吗? 可以的，Kotlin 库函数提供了一些方法，帮助我们实现，如下代码所示。

var data = “hi dhl”

// 移除前缀
println(data.removePrefix(“")) // hi dhl
// 移除后缀
println(data.removeSuffix(”**“)) // hi dhl
// 移除前缀和后缀
println(data.removeSurrounding("”)) // hi dhl

// 返回第一次出现分隔符后的字符串
println(data.substringAfter(“")) // hi dhl
// 如果没有找到，返回原始字符串
println(data.substringAfter(”–“)) // hi dhl
// 如果没有找到，返回默认字符串 “no match”
println(data.substringAfter(”–",“no match”)) // no match

data = “{JAVA | KOTLIN | C++ | PYTHON}”

// 移除前缀和后缀
println(data.removeSurrounding(“{”, “}”)) // JAVA | KOTLIN | C++ | PYTHON
复制代码

有了这些 Kotlin 库函数，我们就不需要在做 startsWith() 和 endsWith() 的检查了，如果让我们自己来实现上面的功能，我们需要花多少行代码去实现呢，一起来看一下 Kotlin 源码是如何实现的，上面的操作符最终都会调用以下代码，进行字符串的检查和截取。

public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
复制代码

参考源码的实现，如果以后遇到类似的需求，但是 Kotlin 库函数有无法满足我们，我们可以以源码为基础进行扩展。

全文到这里就结束了，Kotlin 的强大不止于此，后面还会分享更多的技巧，在 Kotlin 的道路上还有很多实用的技巧等着我们一起来探索。

正在建立一个最全、最新的 AndroidX Jetpack 相关组件的实战项目以及相关组件原理分析文章，目前已经包含了 App Startup、Paging3、Hilt 等等，正在逐渐增加其他 Jetpack 新成员，仓库持续更新，可以前去查看：AndroidX-Jetpack-Practice, 如果这个仓库对你有帮助，请仓库右上角帮我点个赞。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。