不会真的学不会kotlin吧？（四）高阶函数

最新推荐文章于 2022-07-05 22:20:49 发布
最新推荐文章于 2022-07-05 22:20:49 发布
阅读量7.7k 收藏 1
点赞数
分类专栏： 不会真的学不会kotlin把？
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35928566/article/details/107853507
版权

本文是根据慕课网kotlin相关课程本人笔记和个人理解所作
代码部分参考慕课网新kotlin入门课程

文章目录

本章简介

这一章主要是kotlin的高阶函数，主要对let，also的使用和内联函数的定义了解

结构导图

在这里插入图片描述

高阶函数

参数包含函数或者返回函数类型

kotlin

fun main() {
    cost {
        val fibonacciNext = fibonacci()
        for (i in 0..10) {
            println(fibonacciNext())
        }
    }

    // region +折叠
    val intArray = IntArray(5){ it + 1 }
    intArray.forEach {
        println(it)
    }

    intArray.forEach(::println)

    intArray.forEach {
        println("Hello $it")
    }
    //endregion
}

//region +折叠
fun needsFunction(block: () -> Unit) {
    block()
}

fun returnsFunction(): () -> Long {
    return { System.currentTimeMillis() }
}
//endregion

fun cost(block: () -> Unit) {
    val start = System.currentTimeMillis()
    block()
    println("${System.currentTimeMillis() - start}ms")
}

fun fibonacci(): () -> Long {
    var first = 0L
    var second = 1L
    return {
        val next = first + second
        val current = first
        first = second
        second = next
        current
    }
}

内联函数

inline

kotlin

fun main() {
    //region local return
    val ints = intArrayOf(1, 2, 3, 4)
    ints.forEach {
        if(it == 3) return@forEach
        println("Hello $it")
    }

    for (element in ints) {
        if(element == 3) continue
        println("Hello $element")
    }
    //endregion

    //region non-local return
    nonLocalReturn {
        //return
    }

    Runnable {
        println("xxx")
        println("yyy")
    }
    //endregion

    //region cost
    cost {
        println("Hello")
    }
    //endregion

    //region inline property
    money = 5.0
    //endregion
}

inline fun Runnable(noinline block: () -> Unit): Runnable {
    return object : Runnable {
        override fun run() {
            block()
        }
    }
}

public inline fun IntArray.forEach(crossinline action: (Int) -> Unit): Unit {
    for (element in this) action(element)
}

inline fun nonLocalReturn(block: () -> Unit){
    block()
}

inline fun hello(){
    println("Hello")
}

 inline fun cost(block: () -> Unit) {
    val start = System.currentTimeMillis()
    block()
    println(System.currentTimeMillis() - start)
}

var pocket: Double = 0.0
var money: Double
    inline get() = pocket
    inline set(value) {
         pocket = value
    }

常见高阶函数

let run alse apply use
函数名介绍推荐指数
letval r=X.let{x->R}3
runval r=X.run{this:X->R}1
alsoval x=X.also{x->Unit}3
applyval x=X.apply{this:X->Unit}1
useval r=Closeable.use{c->R}3

kotlin

fun main() {
    val person = Person("benny", 20)

    person.let(::println)
    person.run(::println)

    val person2 = person.also {
        it.name = "hhh"
    }

    val person3 = person.apply {
        name = "xxx"
    }

    File("build.gradle").inputStream().reader().buffered()
        .use {
            println(it.readLines())
        }



}

集合变换及序列

变化及聚合
函数名说明
filter保留满足条件的元素
map集合中的所有元素一一映射到其他元素构成新集合
flatMap集合中的所有元素一一映射到新集合并合 并这些集合得到新集合
函数名说明
sum所有元素求和
reduce将元素依次按规则聚合，结果与元素类型一致
fold给定初始化值,将元素按规则聚合,结果 与初始化值类型一致

kotlin

fun main() {
    val list = listOf(1, 2, 3, 4)

    //region sequence
    list.asSequence()
            .filter {
                println("filter: $it")
                it % 2 == 0
            }.map {
                println("map: $it")
                it * 2 + 1
            }.forEach {
                println("forEach: $it")
            }
    //rxjava
    //endregion

    list.asSequence()
            .flatMap {
                (0 until it).asSequence()
            }
            .joinToString().let(::println)
    //rxjava


    region
    for (i in 0..10) {
        println(i)
    }

    for (e in list) {
        println(e)
    }

    var i = 0
    while (i++ < 10) {
        println(i)
    }

    do {
        println("Hello")
    } while (false)
    //endregion

    //region for each
    list.forEach {
        if (it == 2) {
            return@forEach
        }
        println(it)
    }

    list.forEach {
        if (it == 2) return@forEach
        println(it)
    }

    //region
    val newList = list.flatMap {
        ArrayList<String>(it)
    }

    list.filter { it % 2 == 0 }
    list.asSequence()
            .filter { it % 2 == 0 }

    list.asSequence()
            .map { it * 2 + 1 }

    list.asSequence()
            .flatMap {
                (0 until it).asSequence()
            }
            .joinToString().let(::println)

    list.fold(StringBuilder()) { acc, i ->
        acc.append(i)
    }

    list.asSequence()
            .filter {
                it % 2 == 0
            }.map {
                it * 2 + 1
            }.flatMap {
                (0 until it).asSequence()
            }.forEach(::println)
    endregion
}

SAM转换

SAM转换对比
JavaKotlin
Java接口支持支持
Kotlin接口支持不支持
Java方法支持支持
Kotlin函数(方法)支持不支持
抽象类不支持不支持

kotlin

fun main() {
    val executor: ExecutorService = Executors.newSingleThreadExecutor()

    executor.submit(object : Runnable {
        override fun run() {
            println("run in executor.")
        }
    })

    executor.submit(Runnable {
        println("run in executor.")
    })


    executor.submit { println("run in executor.") }

    println("run in main thread.")

    submitRunnable {
        println("Hello")
    }

    submit {  }
}

fun Runnable(block: () -> Unit): Runnable {
    return object : Runnable {
        override fun run() {
            block()
        }
    }
}

fun submitRunnable(runnable: Runnable){
    runnable.run()
}

fun submit(invokable: Invokable) {
    invokable.invoke()
}

typealias FunctionX = ()->Unit

fun submit(lambda: FunctionX){

}

interface Invokable {
    fun invoke()
}
正确的添加删除SAM

kotlin

fun main() {
    val eventManager = EventManager()

    val onEvent = object : EventManager.OnEventListener {
        override fun onEvent(event: Int) {
            println("onEvent $event")
        }
    }

    val onEvent2 = EventManager.OnEventListener{
        println("onEvent $it")
    }

    // DO NOT use this.
//    val onEvent3 = { event: Int ->
//        println("onEvent $event")
//    }

    eventManager.addOnEventListener(onEvent)

    eventManager.removeOnEventListener(onEvent)

}

Demo

kotlin

fun main() {
    File("build.gradle").readText() // 1. read file
        .toCharArray() // 2.
        .filter{ !it.isWhitespace() } // 3. filter white space
        .groupBy { it }
        .map {
            it.key to it.value.size
        }.let {
            println(it)
        }
}

kotlin

interface Node {
    fun render(): String
}

class StringNode(val content: String): Node {
    override fun render(): String {
        return content
    }
}

class BlockNode(val name: String): Node {

    val children = ArrayList<Node>()
    val properties = HashMap<String, Any>()

    override fun render(): String {
        return """<$name ${properties.map { "${it.key}='${it.value}'" }.joinToString(" ")}>${children.joinToString(""){ it.render() }}</$name>"""
    }

    operator fun String.invoke(block: BlockNode.()-> Unit): BlockNode {
        val node = BlockNode(this)
        node.block()
        this@BlockNode.children += node
        return node
    }

    operator fun String.invoke(value: Any) {
        this@BlockNode.properties[this] = value
    }

    operator fun String.unaryPlus(){
        this@BlockNode.children += StringNode(this)
    }

}

fun html(block: BlockNode.() -> Unit): BlockNode {
    val html = BlockNode("html")
    html.block()
    return html
}

fun BlockNode.head(block: BlockNode.()-> Unit): BlockNode {
    val head = BlockNode("head")
    head.block()
    this.children += head
    return head
}

fun BlockNode.body(block: BlockNode.()-> Unit): BlockNode {
    val head = BlockNode("body")
    head.block()
    this.children += head
    return head
}

fun main() {
    val htmlContent = html {
        head {
            "meta" { "charset"("UTF-8") }
        }
        body {
            "div" {
                "style"(
                    """
                    width: 200px; 
                    height: 200px; 
                    line-height: 200px; 
                    background-color: #C9394A;
                    text-align: center
                    """.trimIndent()
                )
                "span" {
                    "style"(
                        """
                        color: white;
                        font-family: Microsoft YaHei
                        """.trimIndent()
                    )
                    +"Hello HTML DSL!!"
                }
            }
        }
    }.render()

    File("Kotlin.html").writeText(htmlContent)
}

interface Node {
    fun render(): String
}

class StringNode(val content: String): Node {
    override fun render(): String {
        return content
    }
}

class BlockNode(val name: String): Node {

    val children = ArrayList<Node>()
    val properties = HashMap<String, Any>()

    override fun render(): String {
        return """<$name ${properties.map { "${it.key}='${it.value}'" }.joinToString(" ")}>${children.joinToString(""){ it.render() }}</$name>"""
    }

    operator fun String.invoke(block: BlockNode.()-> Unit): BlockNode {
        val node = BlockNode(this)
        node.block()
        this@BlockNode.children += node
        return node
    }

    operator fun String.invoke(value: Any) {
        this@BlockNode.properties[this] = value
    }

    operator fun String.unaryPlus(){
        this@BlockNode.children += StringNode(this)
    }

}

fun html(block: BlockNode.() -> Unit): BlockNode {
    val html = BlockNode("html")
    html.block()
    return html
}

fun BlockNode.head(block: BlockNode.()-> Unit): BlockNode {
    val head = BlockNode("head")
    head.block()
    this.children += head
    return head
}

fun BlockNode.body(block: BlockNode.()-> Unit): BlockNode {
    val head = BlockNode("body")
    head.block()
    this.children += head
    return head
}

fun main() {
    val htmlContent = html {
        head {
            "meta" { "charset"("UTF-8") }
        }
        body {
            "div" {
                "style"(
                    """
                    width: 200px; 
                    height: 200px; 
                    line-height: 200px; 
                    background-color: #C9394A;
                    text-align: center
                    """.trimIndent()
                )
                "span" {
                    "style"(
                        """
                        color: white;
                        font-family: Microsoft YaHei
                        """.trimIndent()
                    )
                    +"Hello HTML DSL!!"
                }
            }
        }
    }.render()

    File("Kotlin.html").writeText(htmlContent)
}

kotlin

import java.util.*
fun main(args : Array<String>){
    println("Hello World!")
	val day = 1.days().ago()
    val day1 = 3.days.ago
	println(day)
	println(day1)
}

fun Int.days(): Pair<Int, Int> {
    return Pair(this, Calendar.getInstance().get(Calendar.DAY_OF_YEAR))
}

fun Pair<Int, Int>.ago(): Int {
    return this.second - this.first
}


val Int.days: Pair<Int, Int>
    get() {
        return Pair(this, Calendar.getInstance().get(Calendar.DAY_OF_YEAR))
    }


val Pair<Int, Int>.ago: Int
    get(){
        return this.second - this.first
    }
木寸~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kotlin 使用高阶函数实现回调方式
08-19
主要介绍了Kotlin 使用高阶函数实现回调方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Kotlin中 四个提升逼格的关键字你都会了吗？
whale_kyle的博客
06-28 387
使用kotlin的时候对这几个关键字的使用不是很明确,找了很多文章和书籍来加深一下印象,感谢mikyou 开篇看结论 let let扩展函数的实际上是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内，let函数的是一个不错的选择；let函数另一个作用就是可以避免写一些判断null的操作。 let函数的一般结构 object.let{ it.todo()//在函数...
kotlin 之函数进阶
345丶
04-07 1203
文章目录高阶函数内联函数几个有用的函数集合变换与序列集合的聚合操作SAM 转换案例 高阶函数 ​ 参数类型包含了函数，或者返回类型为函数 fun needsFunction(block: () -> Unit) { //调用函数 block() } fun returnsFunction(): () -> Long { //返回一个函数 return { Syst...
Kotlin基础（四）：函数
分享计算机基础，android，C/C++，音视频等内容
04-25 574
前言 本文主要讲解高阶函数、内联函数、几个有用的高阶函数、集合变换与序列、SAM转换、案例：统计字符个数、案例：HTML DSL、实践：体验 Gradle Kotlin DSL Kotlin文章列表 Kotlin文章列表: 点击此处跳转查看 目录 （一）高阶函数 （1）高阶函数的定义 参数类型包含函数类型或返回值类型为函数类型的函数为高阶函数 fun needsFunction(block: () -> Unit) { block() } fun returnsFunction():
【Kotlin】基本介绍和使用
WzhVae的博客
05-08 664
java与kotlin运行流程 基本数据类型定义 可变变量和不可变变量 字符串 元组 空指针 函数
Android Java/kotlin 显示系统实时时间
afufufufu的博客
05-07 2712
Android 显示系统实时时间 获取系统当前时间 System.currentTimeMillis()； 需要开启一个线程， 我们通过Handler来实现 实时更新时间 效果图 Activity.xml代码 <TextView android:id="@+id/real_time" android:layout_width="wrap_content" android:layout_height="wrap_content"
Kotlin中的高阶函数深入讲解
08-26
主要给大家介绍了关于Kotlin中高阶函数的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
拥抱kotlin之如何习惯使用kotlin高阶函数
01-04
二、kotlin高阶函数使用场景分析 1.先看看平时使用比较多的内置高阶函数 用kotlin写view的onClickListener tV.setOnClickListener { //doSomeThing } 里面的lamba表达式就是一个函数 不太形象？再看看集合...
有趣的 Kotlin 0x02：Indent trimming
AndroidKt
06-13 507
最近在 http://portal.kotlin-academy.com/#/ 上看到很多关于 Kotlin 的有趣的题目。个人觉得很适合 Kotlin 爱好者，感兴趣的小伙伴可自行查阅。 【有趣的 Kotlin 】系列记录自己对每一题的理解。 0x02：Indent trimming fun main(args: Array<String>) { val world = "multiline world" println(""" Hello \$world """.
Kotlin基础语法教程（一）
hehuoU的博客
05-27 1031
目录Kotlin基础语法教程（一）Kotlin概述基础语法Hello World变量和数据类型常量和变量基本数据类型非空类型与可空类型函数声明字符串模板流程控制if语句/表达式when语句/表达式循环语句带标签的break和continueKotlin运算符算术运算符、逻辑运算符和关系运算符位运算符其他运算符局部函数和匿名函数数组基本数据类型数组对象数组Kotlin概述Kotlin是由开发过Int...
linux13位时间戳,Kotlin 处理Linux时间戳
weixin_35668334的博客
05-02 554
思路1. 获取时间可以采用的方式有直接获取系统时间System.currentTimeMillis()或者使用Calendar类获取时间2. 处理时间在使用Calendar时，可以直接由Calendar的set方法对于时间进行设置由于Calendar的时间格式并不是我们希望得到的Linux时间戳格式，所以我们需要使用时间格式模板，通过生成与解析方法进行转换，得到最终的Linux时间戳的时间格式注意...
Kotlin基础
yzpbright的博客
03-02 214
为什么学习Kotlin？ Google规定的官方Android语言 Kotlin时JetBrains开发的，google把Kotlin作为官方语言。 学习路线 第一种：Android官网： https://developer.android.google.cn/kotlin/add-kotlin 第二种：https://www.jetbrains.com/ 首页的Learning Tools 选择 Kotlin for Education 第一次次课目录 Kotlin基础语法 – simple01 Ko
java计算时间差及比较时间
专注Android开发
10-22 673
Date d1 = df.parse("2012-11-05 12:00:00");  //后的时间             Date d2 = df.parse("2012-11-04 11:10:00"); //前的时间             Long diff = d1.ge
《Kotlin 极简教程 》第4章 基本数据类型与类型系统
禅与计算机程序设计艺术
06-11 8699
第4章 基本数据类型与类型系统 《Kotlin极简教程》正式上架： 点击这里 &gt; 去京东商城购买阅读 点击这里 &gt; 去天猫商城购买阅读 非常感谢您亲爱的读者，大家请多支持！！！有任何问题，欢迎随时与我交流~ 到目前为止，我们已经了解了Kotlin的基本符号以及基础语法。我们可以看出，使用Kotlin写的代码更简洁、可读性更好、更富有...
彻底弄懂Lambda和高阶函数
zxm317122667的专栏
04-20 947
Lambda是什么简单来讲，Lambda是一种函数的表示方式(言外之意也就是说一个Lambda表达式等于一个函数)。更确切的说：Lambda是一个未声明的函数，会以表达式的形式传递。为什...
Kotlin入门(18)利用单例对象获取时间
aqi00的博客
09-20 5664
前面介绍了，使用扩展函数可以很方便地扩充数组Array的处理功能，例如交换两个数组元素、求数组的最大元素等等。那么除了数组之外，日期和时间的相关操作，也是很常见的，比如获取当前日期，获取当前时间、获取指定格式的日期时间等等。因此，基本上每个Java书写的Android工程，都需要一个类似DateUtil.java的工具类，用于获得不同格式的时间字符串，下面代码便是一个实现了基础时间拼接的日期工具类...
AndroidKotLin系列--Android Studio 第一步使用KotLin
奇迹的天堂
05-25 938
Android KotLin系列 在Android Studio 中初步使用KotLin 开发，并使得TextView显示出数据。 1、安装插件 file  >>   settings   >>   Plugins   >>  搜索Kotlin  主要是安装  Kotlin language support 其他可以选择安装 2、新建项目
Kotlin进阶系列-函数类型及函数字面值
zuoluohust的博客
07-05 986
本文详细介绍了Kotlin的函数类型及函数字面值的示例及语法。
kotlin isBlank和isEmpty的区别
Bentley_li的博客
11-30 3585
在kotlin的使用中，经常会遇到字符串判空的问题 ，而且kotlin提供了很多实现不同功能的方法： 这些方法基本都能根据字面意思去理解用法 。但其中频繁出现的empty和blank，却不太容易知道该怎么用，下面，就来解释一下，这两大类的区别。 1、str.isEmpty()表示：str == null || str.length == 0 2、str.isBlank()表示：str == null || str.length == 0 || str.trim()....
kotlin 高阶函数
最新发布
09-01
Kotlin 高阶函数是指可以接受函数作为参数或者返回一个函数的函数。在 Kotlin 中，函数是一等公民，可以像其他类型一样被传递和操作。 下面是一个简单的例子，展示了如何定义和使用高阶函数： ```kotlin fun ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值