Kotlin常用函数使用

Kotlin常用函数使用

接触Kotlin一段时间了，发现kotlin用起来是真香。在这记录下几个常用函数，在使用中的总结。

let函数使用

使用方法

data class Data(val text:String,val num:Int)

....省略代码
var data = Data("zhangsan",18)
data.let{
	//在方法内用it指代object去使用
	println(it.text)
}
//表示data不为null时，才会去执行
data?.let{
	println(it.text)
}

场景一：结合?处理处理判空

Java写法:

if (!TextUtils.isEmpty(bacData.getColor())) {
	...省略代码
	mBac.setBackgroundColor(Color.parseColor(bacData.getColor()));
}

Kotlin写法

bacData.color?.let{
	...省略代码
	mBac.setBackgroundColor(Color.parseColor(it))
}

场景二:明确变量的使用范围，让代码简洁易读

java写法

tabLayouParams.setLayoutParams(params);
tabLayouParams.setDark2();
tabLayouParams.setTag(i);
tabLayouParams.setText(page.getTitle());

kotlin写法

tabLayouParams.let{
	it.layoutparams = params
	it.setDark2()
	it.tag = i
	it.text = page.title
}

再看个有趣的地方,方便跟后面讲其他函数时作为区分。

var object1:Object
object1 = object.let{
}
object1 = object.let{
	it
}
var num = object.let{
	100
}

我们知道it指代的是object本身，但上面第一个写法编译器会报错，而第二,三个不会报错。
(不大明白的同学，可以试着在代码敲下,上面Object是指代任一类型)。为啥会这样呢，我们可以试着看下let的源码。

@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

分析：从源码上看let的结构是一个 lambda函数块block 作为参数的方法,T类型则为我们所使用的对象，对象T在block函数里作参数，也是我们上面讲的it。返回值R表示block函数，我们在block方法里最后一行表达的就是返回值

also函数的使用

使用方法

data class Data(val text:String,val num:Int)

....省略代码
var data = Data("zhangsan",18)
data.also{
	println(it.text)
}

also函数看上去跟let函数用法一模一样。引用上面的例子我们再做下区别

data class Data(val text:String,val num:Int)

....省略代码
var data = Data("zhangsan",18)
var data1: Data
data1 = data.also{
	println(it.text)
}

data1 = data.also{
	it
}

data1 = data.let{
	println(it.text)
}

data1 = data.let{
	it
}

我们可以试着去敲下上面的代码，我们可以在编译器上发现第一个data1 = data.let方法会报错之外，also函数不会提示错误，上面我们说过let函数根据函数块最后一行作为返回值。

在这里可以发现also函数跟let函数的区别了。我们可以看下also的底层源码

@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}

我们可以看出also函数的结构实际上和let大部分已知，不同的是，let是以闭包的形式返回，返回函数体内最后一行的值。而also函数返回的是this,就是传入对象T本身。

适用场景：跟let使用场景类似。

with函数使用

使用方法

data class Data(val text:String,val num:Int)

....省略代码
var data = Data("zhangsan",18)
with(data){
	println(text)
	println(num)
}

适用场景:当使用同个类不用方法的时候，省去类名，直接调用类的函数或者属性。
如当获取接口数据时，直接操作数据类的属性。

kotlin写法

with(data){
	mTvTitle.text(title)
	mTvSku.text("已选规格$spec")
	mTvPrice.text("¥$price")
	...
}

java写法

mTvTitle.setText(data.getTitle());
mTvSku.setText("已选规格:" + data.getSpec());
mTvPrice.setText("¥" + data.getPrice());
...

我们接着with函数的底层实现是如何的

@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

根据源码可以看出with函数里有两个参数，分别为T类型的对象receiver和一个lambda函数块。

with函数我们可以这样写

with(data,{
	mTvTitle.text(title)
	mTvSku.text("已选规格$spec")
	mTvPrice.text("¥$price")
	...
})

由于with函数最后一个参数是一个函数，可以把函数提到括号的外部，所以with函数的调用形式改为一开始那样的写法。

with跟let的相似的地方是函数块最后一行作为返回值

run函数使用

使用方法

data class Data(val text:String,val num:Int)

....省略代码
var data = Data("zhangsan",18)
data.run{
	println(text)
	println(num)
}

run函数看上去是不是像let的写法，函数块像with的写法，我们可以这样认为，run函数是let跟with的结合体。

适用场景：适用场景跟let和with相似，即可像let一样做判空处理，函数块里面可以跟with函数一样直接访问公共属性跟方法。

我们根据上面with函数的例子做下对比：

with(data){
	mTvTitle.text(title)
	mTvSku.text("已选规格$spec")
	mTvPrice.text("¥$price")
	...
}

data?.run{
	mTvTitle.text(title)
	mTvSku.text("已选规格$spec")
	mTvPrice.text("¥$price")
	...
}

看上去是不是舒服多了，即做了判空处理，也做到直接访问属性跟方法。我们再看下run函数的底层源码

@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

我们可以看到run函数只接收一个lambda函数作为参数，以闭包形式返回，返回值为最后一行的值。

apply函数

使用方法

data class Data(val text:String,val num:Int)

....省略代码
var data = Data("zhangsan",18)
data.apply{
	println(text)
	println(num)
}

看到使用方法是不是有点疑惑，不就是跟run函数一模一样嘛，不急我们再用上面的例子写个对比就会知道了

data class Data(val text:String,val num:Int)

....省略代码
var data = Data("zhangsan",18)
var data1: Data

data1 = data.run{
	println(text)
	println(num)
}

data1 = data.run{
	println(text)
	println(num)
	this
}

data1 = data.apply{
	println(text)
	println(num)
}

data1 = data.apply{
	println(text)
	println(num)
	text
}

写完这个之后，我们在编译器会看到，第一个data1 = data.run这里会提示错误，而apply函数不管最后一行写什么编译器也是通过的，我们知道run函数返回的是根据函数块最后一行作为返回值。

看到这里我们就是发现跟run函数的区别了，我们可以看看apply的底层源码

@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

我们可以看到apply函数返回的是this，返回T类型，就是我们使用的对象本身。

适用场景：我们在做数据业务处理的时候，会遇到多层级对象的判空处理，引入例子看看

java写法

if (result == null || result.getData()==null) {
	return;
}
Data data = result.getData();
if(data.getAddress() != null){
	...省略代码
}
...省略代码

再用apply写了之后

result?.apply{
	//result 对象存在时的处理
}?.data?.apply{
	//data 对象存在时的处理
}?.address?.apply{	
	//addres 对象存在时的处理
}

以上就是这些在项目使用中几个常用函数的总结，实际中他们作用都是类似的，大部分地方都是可以通用的。

参考文章：
高阶函数与 lambda 表达式