一. 集合中的函数式 API

虽然 Kotlin Collection 中的函数式 API 类似于 Java 8 Stream 中的 API。但是 Kotlin 的集合跟 Java 的集合并不一致。

Kolin 的集合分为可变集合(mutable collection)和不可变集合(immutable collection)。不可变集合是 List、Set、Map，它们是只读类型，不能对集合进行修改。可变集合是 MutableList、MutableSet、MutableMap，它们是支持读写的类型，能够对集合进行修改的操作。

Kotlin 集合中的函数式 API 跟大部分支持 Lambda 语言的函数式 API 都类似。下面仅以 filter、map、flatMap 三个函数为例，演示使用集合的高阶函数。

1.1 filter 的使用

过滤集合中大于10的数字，并把它打印出来。

    listOf(5, 12, 8, 33)   // 创建list集合
            .filter { it > 10 }
            .forEach(::println)

执行结果：

12
33

::println 是方法引用（Method Reference），它是简化的 Lambda 表达式。

上述代码等价于下面的代码：

    listOf(5, 12, 8, 33)
            .filter { it > 10 }
            .forEach{ println(it) }

1.2 map 的使用

将集合中的字符串都转换成大写，并打印出来。

    listOf("java","kotlin","scala","groovy")
            .map { it.toUpperCase() }
            .forEach(::println)

执行结果：

JAVA
KOTLIN
SCALA
GROOVY

1.3 flatMap 的使用

遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中。

    val newList = listOf(5, 12, 8, 33)
            .flatMap {
                listOf(it, it + 1)
            }

    println(newList)

执行结果：

[5, 6, 12, 13, 8, 9, 33, 34]

二. Sequence

序列(Sequence)是 Kotlin 标准库提供的另一种容器类型。序列与集合有相同的函数 API，却采用不同的实现方式。

其实，Kotlin 的 Sequence 更类似于 Java 8 的 Stream，二者都是延迟执行。Kotlin 的集合转换成 Sequence 只需使用asSequence()方法。

    listOf(5, 12, 8, 33)
            .asSequence()
            .filter { it > 10 }
            .forEach(::println)

亦或者使用sequenceOf()来直接创建新的 Sequence：

    sequenceOf(5, 12, 8, 33) // 创建sequence
            .filter { it>10 }
            .forEach (::println)

在 Kotlin 1.2.70 的 release note 上曾说明：

使用 Sequence 有助于避免不必要的临时分配开销，并且可以显着提高复杂处理 PipeLines 的性能。

下面编写一个例子来证实这个说法：

@BenchmarkMode(Mode.Throughput) // 基准测试的模式，采用整体吞吐量的模式
@Warmup(iterations = 3) // 预热次数
@Measurement(iterations = 10, time = 5, timeUnit = TimeUnit.SECONDS) // 测试参数，iterations = 10 表示进行10轮测试
@Threads(8) // 每个进程中的测试线程数
@Fork(2)  // 进行 fork 的次数，表示 JMH 会 fork 出两个进程来进行测试
@OutputTimeUnit(TimeUnit.MILLISECONDS) // 基准测试结果的时间类型
open class SequenceBenchmark {

    @Benchmark
    fun testSequence():Int {
        return sequenceOf(1,2,3,4,5,6,7,8,9,10)
                .map{ it * 2 }
                .filter { it % 3  == 0 }
                .map{ it+1 }
                .sum()
    }

    @Benchmark
    fun testList():Int {
        return listOf(1,2,3,4,5,6,7,8,9,10)
                .map{ it * 2 }
                .filter { it % 3  == 0 }
                .map{ it+1 }
                .sum()
    }
}

fun main() {
    val options = OptionsBuilder()
            .include(SequenceBenchmark::class.java.simpleName)
            .output("benchmark_sequence.log")
            .build()
    Runner(options).run()
}

通过基准测试得到如下的结果：

# Run complete. Total time: 00:05:23

REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
experiments, perform baseline and negative tests that provide experimental control, make sure
the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
Do not assume the numbers tell you what you want them to tell.

Benchmark                        Mode  Cnt      Score     Error   Units
SequenceBenchmark.testList      thrpt   20  15924.272 ± 305.825  ops/ms
SequenceBenchmark.testSequence  thrpt   20  23099.938 ± 515.524  ops/ms

上述例子使用 OpenJDK 提供的基准测试工具 JMH 进行测试，它可以在方法层面进行基准测试。上述例子的结果表明，在多次链式调用时 Sequence 比起 List 具有更高的效率。

这是因为集合在处理每个步骤时都会返回一个新集合，Sequence 不会在每个处理步骤中创建集合。对于数据量比较大时，应该选择 Sequence。

三. Sequence VS Stream

Sequence 和 Stream 都使用的是惰性求值。

在编程语言理论中，惰性求值（英语：Lazy Evaluation），又译为惰性计算、懒惰求值，也称为传需求调用（call-by-need），是一个计算机编程中的一个概念，目的是要最小化计算机要做的工作。它有两个相关而又有区别的含意，可以表示为“延迟求值”和“最小化求值”。除可以得到性能的提升外，惰性计算的最重要的好处是它可以构造一个无限的数据类型。

下面列举了 Sequence 和 Stream 的一些区别：

从易用性、性能角度来看，如果要从 Sequence 和 Stream 中作出选择的话，本人更加偏向 Sequence。