全网最全面的由浅到深的Kotlin基础教程（七）

news2025/1/16 20:18:00

前言

本篇文章接着上一篇文章全网最全面的由浅到深的Kotlin基础教程（六）继续进阶学习kotlin，建议看完上一篇文章，再来看本篇文章。本篇主要分析一些常用的kotlin函数源码，以及用kotlin简单实现Rxjava的几个操作符。坚持将kotlin系列的前6篇看完的，那么恭喜你再将这最后一篇看完，你就成为一名合格的kotlin开发者了。

1. kotlin标准函数源码解析

1.1 apply

源码及分析注释如下：

/*
public 访问修饰符
inline fun 内联函数
<T> 泛型定义
T.apply 泛型T的扩展函数
(block: T.() -> Unit) 输入参数为一个名为block的lambda表达式，
		其中T.() 是一个泛型扩展函数，这种写法使得lambda表达式持有T的this对象，
		当做固定写法来理解即可。
: T apply函数的返回类型仍然为T
*/
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    //契约函数，暂时不用关注，可以不写的
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    //执行lambda表达式的逻辑
    block()
    //最终仍然返回T对象本身
    return this
}

1.2 also

与apply函数的意义一样，只是also函数的lambda表达式持有it，而apply函数的的lambda表达式持有this，源码及分析注释如下：

/*
public 访问修饰符
inline fun 内联函数
<T> 泛型定义
T.also 为泛型T定义扩展函数also
block: (T) -> Unit also函数中传入的参数是lambda表达式，该lambda表达式有一个T泛型的参数，返回值为空
: T also函数的最终返回值仍然为T泛型
*/
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    //执行lambda表达式，将T泛型的this对象传入block函数，因此block通过it持有T泛型的this对象
    block(this)
    //不管你上面的lambda表达式干了啥，最终仍然返回T泛型对象本身
    return this
}

1.3 run

源码及分析注释如下：

/*
public 访问修饰符
inline fun 内联函数
<T, R> 定义两个泛型
T.run 为T泛型定义扩展函数run
block: T.() -> R run函数有一个参数是lambda表达式，该lambda表达式通过T泛型扩展函数，拥有T泛型的this对象，返回类型为R
: R run函数的返回类型是R泛型
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    //执行lambda表达式
    //因为lambda表达式拥有T泛型的this对象
    //因为lambda表达式返回的是R，因此返回值由lambda表达式的最后一行决定
    //return this.block()  //this可以省略
    return block()
}

1.4 let

与run函数的意义一样，只是let函数的lambda表达式持有it，而run函数的的lambda表达式持有this，源码及分析注释如下：

/*
public 访问修饰符
inline fun 内联函数
<T, R> 定义两个泛型
T.let 为T泛型定义扩展函数let
block: (T) -> R lambda表达式参数，输入T泛型（lambda表达式如果只有一个参数，则参数名默认为it），输出为R泛型
: R 最终返回的类型是R泛型
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    //执行lambda表达式
    //因为lambda表达式传入的是this，因此lambda表达式通过it持有T泛型的对象
    //因为lambda表达式输入的T，返回的是R，因此返回值由lambda表达式的最后一行决定
    return block(this)
}

1.5 with

与run函数的意义一样，只是调用方式不一样而已，run是泛型扩展函数，而with是普通的函数，源码及分析注释如下：

/*
public 访问修饰符
inline fun 内联函数
<T, R> 定义两个泛型
with(receiver: T, block: T.() -> R) 这是一个普通的函数，并非扩展函数，包括两个参数，第一个T泛型的参数，第二个是lambda表达式，lambda表达式通过T泛型扩展函数，拥有T泛型的this对象，返回类型为R
: R 最终返回类型是R
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    //block的最后一行是返回值
    return receiver.block()
}

1.6 takeIf

源码及分析注释如下：

/*
public 访问修饰符
inline fun 内联函数
<T> 泛型定义
T.takeIf 为泛型T定义扩展函数takeIf
predicate: (T) -> Boolean takeIf函数中传入的参数是lambda表达式，该lambda表达式有一个T泛型的参数，返回值为Boolean
: T? takeIf函数最终返回的可空的T泛型类型
*/
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    //如果lambda表达式返回true，则takeIf返回T泛型this对象本身，否则返回null
    return if (predicate(this)) this else null
}

1.7 takeUnless

与takeIf的意义相反，源码及分析注释如下：

/*
public 访问修饰符
inline fun 内联函数
<T> 泛型定义
T.takeUnless 为泛型T定义扩展函数takeUnless
predicate: (T) -> Boolean takeUnless函数中传入的参数是lambda表达式，该lambda表达式有一个T泛型的参数，返回值为Boolean
: T? takeIf函数最终返回的可空的T泛型类型
*/
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    //如果lambda表达式返回false，则takeUnless返回T泛型this对象本身，否则返回null
    return if (!predicate(this)) this else null
}

2. kotlin转换函数源码解析

2.1 map

  • 功能介绍：
    源码及分析注释如下：把lambda表达式的返回结果（最后一行），添加到新的集合destination中，并返回。
  • 示例代码：
fun main() {
    var list = listOf("A", "B", "C")
    list.map {
        "[$it]"
    }.map {
        "[$it, len=${it.length}]"
    }.map {
        print("$it ")
    }

}

运行结果如下：
在这里插入图片描述

  • 源码分析：
//Iterable类的扩展函数map
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
    //将创建的List数组和lambda表达式传入mapTo函数
    //return this.mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform) //this可以省略
    return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C {
    //遍历调用map的List对象
    for (item in this)
        //将原有的list值传递给lambda表达式transform处理，并存入新的集合destination
        destination.add(transform(item))
    return destination //返回新的集合
}

2.2 flatmap

  • 功能介绍：
    lambda表达式的返回结果是一个集合，把lambda表达式的返回集合，通过addAll函数铺开，并添加到新的集合destination中，最后返回新的集合。
  • 示例代码：
fun main() {
    var list = listOf("A", "B", "C")
    list.flatMap {
        listOf("[$it ,", "$it]")
    }.map {
        print("$it ")
    }
}

运行结果如下：
在这里插入图片描述

  • 源码分析：
//Iterable类的扩展函数
public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> {
    return flatMapTo(ArrayList<R>(), transform)
}

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C {
    //遍历flatMap调用者的集合元素
    for (element in this) {
        //lambda表达式返回一个集合
        val list = transform(element)
        //将lambda表达式返回的集合添加到新的集合destination中
        destination.addAll(list)
    }
    //返回新的集合
    return destination
}

2.3 filter

  • 功能介绍：
    如果lambda表达式的返回值为true，则遍历当前元素，加入新的字符串构造器StringBuilder destination，否则，不加入新的字符串。最后返回新的字符串
  • 示例代码：
fun main() {
    var list = listOf("A", "B", "C")
    list.map {
        //过滤list中为A的元素
        it.filter { it ->
            println("$it filter")
            it == 'A'
        }
    }.map {
        print("$it  ")
    }
}

运行结果如下：
在这里插入图片描述

  • 源码分析：
//String类的扩展函数filter
public inline fun String.filter(predicate: (Char) -> Boolean): String {
    return filterTo(StringBuilder(), predicate).toString()
}

public inline fun <C : Appendable> CharSequence.filterTo(destination: C, predicate: (Char) -> Boolean): C {
    //遍历filter调用者的字符串的所有字符
    for (index in 0 until length) {
        val element = get(index)
        //如果这个字符传入lambda表达式predicate的返回结果为true，则添加到StringBuilder中
        if (predicate(element)) destination.append(element)
    }
    //返回新的字符串StringBuilder
    return destination 
}

2.4 zip

  • 功能介绍
    通过lambda表达式将第一个集合和另一个集合，以Pair的形式添加到新的集合中，并返回
  • 示例代码
fun main() {
    val name = listOf("sun", "mekeater")
    val age = listOf(18,19)
    
    var zip = name.zip(age)
    //将zip转为Map遍历
    zip.toMap().forEach{
        println("name=${it.key},age=${it.value}")
    }
}

运行结果如下：
在这里插入图片描述

  • 源码分析
//Iterable类的扩展函数zip
public infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>> {
    return zip(other) { t1, t2 -> t1 to t2 }
}
//中缀表达式，将A和B组合成一个Pair对象
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

public inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V> {
    //zip函数调用者对象遍历器
    val first = iterator()
    //zip函数中传入的另一个集合对象遍历器
    val second = other.iterator()
    //新建集合
    val list = ArrayList<V>(minOf(collectionSizeOrDefault(10), other.collectionSizeOrDefault(10)))
    //遍历两个集合
    while (first.hasNext() && second.hasNext()) {
        //将两个集合的元素传给lambda表达式transform
        //上面可以看到transform的实现，是将两个参数组合为一个Pair
        //将Pair对象添加到新的集合list中
        list.add(transform(first.next(), second.next()))
    }
    //返回新的集合
    return list
}

3. 函数式编程理解

kotlin是函数式编程语言，函数式编程语言的代码更简洁直观（如果你会的话，真的很容易读懂，但如果不会，那真的又一一点看不懂，相信认真看了我kotlin这7篇文章的，到这儿应该都能轻松的读懂下的kotlin代码），我们以一段示例代码来对比下，函数式编程和普通编程方式的区别。

如下一段kotlin函数式编程，用普通的java代码写，需要写一堆才能实现

fun main() {
    val name = listOf("sun", "mekeater")
    val age = listOf(18,19)
    //name.zip(age) 将name和age两个集合组成键值对集合
    //.toMap() 将上一步键值对集合转为Map集合
    //.map { "name:${it.key},age:${it.value}"} 遍历上一步Map集合中的元素，按照"name:${it.key},age:${it.value}"格式进行组合
    //.map { println(it) 遍历上一步Map集合中的元素,进行打印输出
    name.zip(age).toMap().map { "name:${it.key},age:${it.value}"}.map { println(it) }
}

对上面的kotlin函数式编程写的代码用java实现，示例代码如下：

public class Kt43_java {
    public static void main(String[] args) {
        List<String> names=new ArrayList<>();
        names.add("sun");
        names.add("mekeater");

        List<Integer> ages =new ArrayList<>();
        ages.add(18);
        ages.add(19);

        Map<String, Integer> map =new LinkedHashMap<>();
        for (int i = 0; i < names.size(); i++) {
            map.put(names.get(i), ages.get(i));
        }

        List<String> newList=new ArrayList<>();
        for (Map.Entry<String, Integer> stringIntegerEntry : map.entrySet()) {
            newList.add("name:"+stringIntegerEntry.getKey()+" age:"+stringIntegerEntry.getValue());
        }

        for (String s : newList) {
            System.out.println(s);
        }
    }

}

kotlin的一行代码，java要用一堆才能实现，kotlin代码的简洁程度不言而喻！

4. 手写RxJava

采用kotlin代码实现RxJava的create，map，observer三个操作符，通过这个示例，真的更能感受到kotlin代码的简洁程度令人发指，哈哈哈

fun main() {
    create {
        "mekeater"
    }.map {
        "[$this]"
    }.map {
        "==$this=="
    }.observer {
        println(this)
    }
}
class RxjavaCoreClass<T>(val item:T)

//lambda对输入进行处理
inline fun<I> RxjavaCoreClass<I>.observer(observerAction:I.()->Unit):Unit = observerAction(item)

//对于输入进行处理，转换为输出给到RxjavaCoreClass
inline fun<I,O> RxjavaCoreClass<I>.map(mapAction:I.()->O) = RxjavaCoreClass(mapAction(item))

//create操作符只是将用户最后一行的输入原样输出给RxjavaCoreClass，起到一个输入参数的作用
inline fun<O> create(action:()->O) = RxjavaCoreClass(action())

运行结果如下：
在这里插入图片描述

5. 结语

自此，我们kotlin入门教程系列就讲完了，一共7篇文章，如果您能从第一篇看到第七篇，相信你已经很好的掌握kotlin语言了，至少能够看懂kotlin代码，能够自己上手写kotlin代码了。

那么，感谢你来我的博客世界，听我讲kotlin的故事，这个故事该说再见了，希望在下个新故事，还能遇到你，886~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1682795.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Advanced Installer 使用教程-自定义操作（中）

Advanced Installer 使用教程-自定义操作（中）

1、自定义操作的三种分类形式&#xff1a;控制台程序、控制台修改成的窗口程序、对话框程序 2、控制台程序 1&#xff09; 2&#xff09;传参 a、修改main函数 b、在命令行输入AI中的属性变量&#xff0c;注意执行时间的选择 c、如果需要输入多个命令行参数以空格隔开 d、如…
阅读更多...
LLMPerf-为LLM提供可重现的性能指标

LLMPerf-为LLM提供可重现的性能指标

LLMPerf-为LLM推理提供可复现的性能指标 翻译自文章&#xff1a;Reproducible Performance Metrics for LLM inference 结合之前的LLMPerf测试大模型API性能的文章进行查看&#xff0c;效果更佳。 1. 摘要 我们见过许多关于LLM性能的声明&#xff1b;然而&#xff0c;这些声明往…
阅读更多...
Qt_电脑wifi相关操作

Qt_电脑wifi相关操作

项目描述： 在做项目时用到了获取wifi的操作。在网上查找了好久资料，这里做一些总结。 这里有显示当前电脑wifi连接状态，列出wifi列表，连接断开wifi等函数。欢迎大家留言添加文章内容。 使用范围： windows电脑（中文的环境） 使用技术：windows的cmd命令。和对字符串的解析…
阅读更多...
MPLS VPN

MPLS VPN

不是公司的产品&#xff0c;是运营商对外提供的一种服务 没咋懂&#xff0c;oh my god
阅读更多...
【Vue3】封装axios请求（cli和vite）

【Vue3】封装axios请求（cli和vite）

原文作者&#xff1a;我辈李想 版权声明&#xff1a;文章原创&#xff0c;转载时请务必加上原文超链接、作者信息和本声明。 Vue 【Vue3】env环境变量的配置和使用&#xff08;区分cli和vite&#xff09; 文章目录 Vue前言一、常见用法二、vue3cli封装接口1..env配置2..dev(开…
阅读更多...
51建模网AR虚拟试用，让网购不再只靠想象！

51建模网AR虚拟试用，让网购不再只靠想象！

在数字化的浪潮中&#xff0c;网购已成为现代人生活的一部分。然而&#xff0c;传统的网购模式常常因为无法直接试穿、试用商品&#xff0c;导致买家在收到商品后感到失望&#xff0c;特别是面对大件家居产品时&#xff0c;仅凭屏幕上的图片和尺寸描述&#xff0c;很难准确地把…
阅读更多...
民国漫画杂志《时代漫画》第17期.PDF

民国漫画杂志《时代漫画》第17期.PDF

时代漫画17.PDF: https://url03.ctfile.com/f/1779803-1248612629-85326d?p9586 (访问密码: 9586) 《时代漫画》的杂志在1934年诞生了&#xff0c;截止1937年6月战争来临被迫停刊共发行了39期。 ps:资源来源网络&#xff01;
阅读更多...
【蓝桥杯】

【蓝桥杯】

题目列表 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) #include<bits/stdc.h> using llunsigned long long; #define int ll const int N2e510; int k0; std::string s; int a,b,c,d; void solve() {char op;std::cin>>op;if(opA){std::string s;for(int i1;i&l…
阅读更多...
BERT系列算法解读

BERT系列算法解读

1.bert训练的方法 为了训练BERT模型&#xff0c;主要采用了两种方法&#xff1a;掩码语言模型&#xff08;Masked Language Model, MLM&#xff09;和下一个句子预测&#xff08;Next Sentence Prediction, NSP&#xff09;。 方法一&#xff1a;掩码语言模型&#xff08;Mask…
阅读更多...
Removing Smallest Multiples

Removing Smallest Multiples

题目描述: 给你一个集合 S &#xff0c;其中包含前 n 个正整数1, 2 。 您可以对 S 执行以下操作任意次数(可能为零)&#xff1a; #include<iostream> #include<cstring> #include<algorithm> #define int long long using namespace std; int t,n,sum; bo…
阅读更多...
2024 中青杯高校数学建模竞赛（A题）数学建模完整思路+完整代码全解全析

2024 中青杯高校数学建模竞赛（A题）数学建模完整思路+完整代码全解全析

你是否在寻找数学建模比赛的突破点&#xff1f;数学建模进阶思路&#xff01; 作为经验丰富的数学建模团队&#xff0c;我们将为你带来2024 长三角高校数学建模竞赛&#xff08;A题&#xff09;的全面解析。这个解决方案包不仅包括完整的代码实现&#xff0c;还有详尽的建模过…
阅读更多...
【真实项目中收获的提升】- 使用MybatisPlus框架 save一条字段中有主键id并且和以前重复会报错吗

【真实项目中收获的提升】- 使用MybatisPlus框架 save一条字段中有主键id并且和以前重复会报错吗

问题描述&#xff1a; save一条数据中有主键id并且和以前重复会报错吗&#xff1f; 实际场景&#xff1a; 复制一条数据&#xff0c;修改其中一个字段&#xff0c;想让主键自增直接插入进数据库。 解决方案&#xff1a; 会报错&#xff0c; 直接把插入对象的主键id置为空…
阅读更多...
java实现环形链表带哨兵

java实现环形链表带哨兵

双向环形链表带哨兵&#xff0c;这时哨兵既作为头&#xff0c;也作为尾。 package com.tfq.arithmetic.linkedlist;import java.util.Iterator;/*** author: fqtang* date: 2024/05/22/8:40* description: 环形链表*/ public class DoublyLinkedListSentinel implements Iterab…
阅读更多...
Delphi 程序例子（DPI变化自动感知及显示器相关功能演示）

Delphi 程序例子（DPI变化自动感知及显示器相关功能演示）

目录 一、前言 二、Delphi 演示程序&#xff08;D12版本&#xff0c;用D11也都可以&#xff09; 1. 演示程序功能&#xff1a; 2. 程序界面&#xff1a; 3. 程序源代码下载&#xff08;有偿&#xff09;&#xff1a; 一、前言 系列文章&#xff1a; 彻底搞懂 Windows 显示…
阅读更多...
数据结构---树，二叉树的简单概念介绍、堆和堆排序

数据结构---树，二叉树的简单概念介绍、堆和堆排序

树 树的概念和结构 结构 在我们将堆之前&#xff0c;我们先来了解一下我们的树。 我们的堆是属于树里面的一种&#xff0c; 树是一种非线性结构&#xff0c;是一种一对多的一种结构&#xff0c;也就是我们的一个节点可能有多个后继节点&#xff0c;当然也可以只有一个或者没…
阅读更多...
23设计模式—工厂方法

23设计模式—工厂方法

文章目录 0、模式类型1、Factory Method1.1、动机1.2、实现 2、模式定义3、结构4、总结 0、模式类型 "对象创建"模式 通过“对象创建”模式绕开new&#xff0c;来避免对象创建&#xff08;new&#xff09;过程中导致的紧耦合&#xff08;依赖具体类&#xff09;&am…
阅读更多...
多线程讲解（详解）

多线程讲解（详解）

目录 什么是多线程&#xff1f; 为什么要使用多线程&#xff1f; 线程的创建 使用Thread实现 从以上代码我们梳理一下多线程创建步骤&#xff1a; 注意&#xff1a; 小示例 首先&#xff0c;引入依赖 然后&#xff0c;按照我们刚刚说的构建多线程的步骤进行构建&#…
阅读更多...
Python实现天气数据采集

Python实现天气数据采集

Python实现天气数据采集 一、需求介绍二、完整代码一、需求介绍 本次天气数据采集的需求是获取每日的最高温、最低温、风力、风向、天气状况、AQI指数，如图所示，完整代码附后： 本次采集的目标网址是2345天气网： 上图的URL中，beijing是城市名称的缩写，54511即为城市代码…
阅读更多...
跨域计算芯片，一把被忽视的汽车降本尖刀

跨域计算芯片，一把被忽视的汽车降本尖刀

作者 |王博 编辑 |德新 2019年前后&#xff0c;「中央运算单元区域控制」的架构被提出。基于这一趋势&#xff0c;从板级的多芯片&#xff0c;到板级的单芯片&#xff0c;集成度越来越高&#xff0c;跨域计算芯片随之来到聚光灯下。 跨域计算芯片的特点是&#xff0c;与专为智…
阅读更多...
java8总结

java8总结

java8总结 java8新特性总结1. 行为参数化2. lambda表达式2.1 函数式接口2.2 函数描述符 3. Stream API3.1 付诸实践 java8新特性总结 行为参数化lambda表达式Stream Api 1. 行为参数化 定义&#xff1a;行为参数化&#xff0c;就是一个方法接受多个不同的行为作为参数&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023