当然 T.also 还可以做其他事情，比如利用 T.also 在使用之前可以进行自我操作特点，可以实现一行代码交换两个变量，在后面会有详细介绍
T.apply 函数
通过上面三个方面，大致了解函数的行为，接下来看一下 T.apply 函数，T.apply 函数是一个扩展函数，返回值是它本身，并且接受的参数是 this。
// 普通方法
fun createInstance(args: Bundle) : MyFragment {
val fragment = MyFragment()
fragment.arguments = args
return fragment
}
// 改进方法
fun createInstance(args: Bundle)
= MyFragment().apply { arguments = args }
// 普通方法
fun createIntent(intentData: String, intentAction: String): Intent {
val intent = Intent()
intent.action = intentAction
intent.data=Uri.parse(intentData)
return intent
}
// 改进方法，链式调用
fun createIntent(intentData: String, intentAction: String) =
Intent().apply { action = intentAction }
.apply { data = Uri.parse(intentData) }
汇总
以表格的形式汇总，更方便去理解
| 函数 | 是否是扩展函数 | 函数参数(this、it) | 返回值(调用本身、最后一行) |
| — | — | — | — |
| with | 不是 | this | 最后一行 |
| T.run | 是 | this | 最后一行 |
| T.let | 是 | it | 最后一行 |
| T.also | 是 | it | 调用本身 |
| T.apply | 是 | this | 调用本身 |
使用 T.also 函数交换两个变量
接下来演示的是使用 T.also 函数，实现一行代码交换两个变量？我们先来回顾一下 Java 的做法。
int a = 1;
int b = 2;
// Java - 中间变量
int temp = a;
a = b;
b = temp;
System.out.println("a = “+a +” b = "+b); // a = 2 b = 1
// Java - 加减运算
a = a + b;
b = a - b;
a = a - b;
System.out.println("a = " + a + " b = " + b); // a = 2 b = 1
// Java - 位运算
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a = " + a + " b = " + b); // a = 2 b = 1
// Kotlin
a = b.also { b = a }
println(“a = ${a} b = ${b}”) // a = 2 b = 1
来一起分析 T.also 是如何做到的，其实这里用到了 T.also 函数的两个特点。
-
调用 T.also 函数返回的是调用者本身。
-
在使用之前可以进行自我操作。
也就是说 b.also { b = a } 会先将 a 的值 (1) 赋值给 b，此时 b 的值为 1，然后将 b 原始的值（2）赋值给 a，此时 a 的值为 2，实现交换两个变量的目的。
使用 in 和 when 关键字结合正则表达式，验证用户的输入，这是一个很酷的技巧。
// 使用扩展函数重写 contains 操作符
operator fun Regex.contains(text: CharSequence) : Boolean {
return this.containsMatchIn(text)
}
// 结合着 in 和 when 一起使用
when (input) {
in Regex(“[0–9]”) -> println(“contains a number”)
in Regex(“[a-zA-Z]”) -> println(“contains a letter”)
}
in 关键字其实是 contains 操作符的简写，它不是一个接口，也不是一个类型，仅仅是一个操作符，也就是说任意一个类只要重写了 contains 操作符，都可以使用 in 关键字，如果我们想要在自定义类型中检查一个值是否在列表中，只需要重写 contains() 方法即可，Collections 集合也重写了 contains 操作符。
val input = “kotlin”
when (input) {
in listOf(“java”, “kotlin”) -> println(“found ${input}”)
in setOf(“python”, “c++”) -> println(“found ${input}”)
else -> println(" not found ${input}")
}
我汇总了一下目前 Kotlin 单例总共有三种写法：
-
使用 Object 实现单例。
-
使用 by lazy 实现单例。
-
可接受参数的单例（来自大神 Christophe Beyls）。
使用 Object 实现单例
代码：
object WorkSingleton
Kotlin 当中 Object 关键字就是一个单例，比 Java 的一坨代码看起来舒服了很多，来看一下编译后的 Java 文件。
public final class WorkSingleton {
public static final WorkSingleton INSTANCE;
static {
WorkSingleton var0 = new WorkSingleton();
INSTANCE = var0;
}
}
通过 static 代码块实现的单例，优点：饿汉式且是线程安全的，缺点：类加载时就初始化，浪费内存。
使用 by lazy 实现单例
利用伴生对象 和 by lazy 也可以实现单例，代码如下所示。
class WorkSingleton private constructor() {
companion object {
// 方式一
val INSTANCE1 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) { WorkSingleton() }
// 方式二 默认就是 LazyThreadSafetyMode.SYNCHRONIZED，可以省略不写，如下所示
val INSTANCE2 by lazy { WorkSingleton() }
}
}
lazy 的延迟模式有三种：
-
上面代码所示 mode = LazyThreadSafetyMode.SYNCHRONIZED，lazy 默认的模式，可以省掉，这个模式的意思是：如果有多个线程访问，只有一条线程可以去初始化 lazy 对象。
-
当 mode = LazyThreadSafetyMode.PUBLICATION 表达的意思是：对于还没有被初始化的 lazy 对象，可以被不同的线程调用，如果 lazy 对象初始化完成，其他的线程使用的是初始化完成的值。
-
mode = LazyThreadSafetyMode.NONE 表达的意思是：只能在单线程下使用，不能在多线程下使用，不会有锁的限制，也就是说它不会有任何线程安全的保证以及相关的开销。
通过上面三种模式，这就可以理解为什么 by lazy 声明的变量只能用 val，因为初始化完成之后它的值是不会变的。
可接受参数的单例
但是有的时候，希望在单例实例化的时候传递参数，例如：
Singleton.getInstance(context).doSome()
上面这两种形式都不能满足，来看看大神 Christophe Beyls 在这篇文章给出的方法 Kotlin singletons with argument 代码如下。
class WorkSingleton private constructor(context: Context) {
init {
// Init using context argument
}
companion object : SingletonHolder<WorkSingleton, Context>(::WorkSingleton)
}
open class SingletonHolder<out T : Any, in A>(creator: (A) -> T) {
private var creator: ((A) -> T)? = creator
@Volatile
private var instance: T? = null
fun getInstance(arg: A): T {
val i = instance
if (i != null) {
return i
}
return synchronized(this) {
val i2 = instance
if (i2 != null) {
i2
} else {
val created = creator!!(arg)
instance = created
creator = null
created
}
}
}
}
有没有感觉这和 Java 中双重校验锁的机制很像，在 SingletonHolder 类中如果已经初始化了直接返回，如果没有初始化进入 synchronized 代码块创建对象，利用了 Kotlin 伴生对象提供的非常强大功能，它能够像其他任何对象一样从基类继承，从而实现了与静态继承相当的功能。 所以我们将 SingletonHolder 作为单例类伴随对象的基类，在单例类上重用并公开 getInstance（）函数。
参数传递给 SingletonHolder 构造函数的 creator，creator 是一个 lambda 表达式，将 WorkSingleton 传递给 SingletonHolder 类构造函数。
并且不限制传入参数的类型，凡是需要传递参数的单例模式，只需将单例类的伴随对象继承于 SingletonHolder，然后传入当前的单例类和参数类型即可，例如：
class FileSingleton private constructor(path: String) {
companion object : SingletonHolder<FileSingleton, String>(::FileSingleton)
}
到这里就结束了，Kotlin 的强大不止于此，后面还会分享更多的技巧，在 Kotlin 的道路上还有很多实用的技巧等着我们一起来探索。
例如利用 Kotlin 的 inline、reified、DSL 等等语法, 结合着 DataBinding、LiveData 等等可以设计出更加简洁并利于维护的代码。
一、Python所有方向的学习路线
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
二、学习软件
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
三、入门学习视频
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python爬虫全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：python）
blog.csdnimg.cn/afc935d834c5452090670f48eda180e0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5aqb56eD56eD,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center)
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python爬虫全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：python）
[外链图片转存中…(img-es5x0NYO-1711130456081)]
517
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
