Kotlin Collection VS Kotlin Sequence VS Java Stream

fengzhizi715 2020/10/18 8:03:39

一. 集合中的函数式 API 虽然 Kotlin Collection 中的函数式 API 类似于 Java 8 Stream 中的 API。但是 Kotlin 的集合跟 Java 的集合并不一致。 Kolin 的集合分为可变集合(mutable collection)和不可变集合(immutable collection)。不可变集合是 List、Set、Map,它们是只…

一. 集合中的函数式 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
autoboxing 会发生自动装箱 对于原始类型可以避免自动装箱
parallelism 不支持 支持
跨平台 支持 Kotlin/JVM、Kotlin/JS、Kotlin/Native 等多平台 只能在 Kotlin/JVM 平台使用,并且 jvm 版本需要>=8
易用性 更简洁、支持更多的功能 使用 Collectors 进行终端操作会使 Stream 更加冗长。
性能 大多数终端操作符是 inline 函数 对于值可能不存在的情况,Sequence 支持可为空的类型,而 Stream 会创建 Optional包装器。因此会多一步的对象创建。

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

随时随地学软件编程-关注百度小程序和微信小程序
关于找一找教程网

本站文章仅代表作者观点,不代表本站立场,所有文章非营利性免费分享。
本站提供了软件编程、网站开发技术、服务器运维、人工智能等等IT技术文章,希望广大程序员努力学习,让我们用科技改变世界。
[Kotlin Collection VS Kotlin Sequence VS Java Stream]http://www.zyiz.net/tech/detail-148110.html

上一篇:Java9第四篇-Reactive Stream API响应式编程

下一篇:为什么要学习HarmonyOS以及如何快速上手?

赞(0)

共有 条评论 网友评论

验证码: 看不清楚?
    关注微信小程序
    程序员编程王-随时随地学编程

    扫描二维码或查找【程序员编程王】

    可以随时随地学编程啦!

    技术文章导航 更多>
    扫一扫关注最新编程教程