Kotlin之标准函数和静态方法

1、标准函数

标准函数是指Standard.kt文件中定义的函数，任何Kotlin代码都可以自由的调用所有标准函数，标准函数有很多我们这里主要学习下几个常用的标准函数。

1.1、let函数

let函数提供了函数式API编程接口，并将原始对象作为参数传递到Lambda表达式中，标准的写法如下：

obj.let {
            obj1->需要执行的逻辑
        }

obj1就是obj对象这里写成obj1只是为了防止命名重复的问题，使用的场景如下：

fun doStudy(study: Study?) {
        study?.readBook()
        study?.doHomeWork()
    }

上面代码相当于每次调用Study对象的方法，都需要对study进行判空，我们可以使用let函数配合?.即可解决这个问题。

fun doStudy(study: Study?) {
        study?.let {
            it.readBook()
            it.doHomeWork()
        }
    }

1.2、with函数

with函数接收两个参数：

第一个参数：任意类型的对象
第二个参数：一个Lambda表达式
with函数会在Lambda表达式中提供第一个参数对象的上下文，并将Lambda表达式最后一行代码作为返回值返回。示例代码如下：

val result=with(obj){
  //这里是obj对象的上下文
“value”//with函数的返回值
}

with函数的作用：它可以在连续调用同一个对象的多个方法时使代码变得简洁。具体示例如下：

val list= listOf<String>("Apple","Banana","Orange","Pear","Grape")
val builder=StringBuilder()
builder.append("Start eating fruit \n")
for(fruit in list){
    builder.append("$fruit \n")
}
builder.append("Ate all fruit")
val result=builder.toString()
println(result)

仔细观察上面代码，我们多次使用builder对象调用append()进行字符串的拼接，这个时候我们就可以使用with函数来简化这个过程。

val list= listOf<String>("Apple","Banana","Orange","Pear","Grape")
val result=with(StringBuilder()){
    append("Start eating fruit \n")
    for(fruit in list){
        append("$fruit \n")
    }
    append("Ate all fruit")
toString()
}
println(result)

这段代码乍一看有点晕，我们向with()函数中传了2个参数，StringBuilder对象和Lambda表达式，传入的StringBuilder对象会作为Lambda表达式的上下文，即我们在Lambda表达式中不再像刚才那样调用builder.append()和builder.toString()，而可以直接调用append()和toString()，并且Lambda表达式的最后一行代码作为with函数的返回值返回。

1.3、run函数

run函数的使用场景和with函数的使用场景一样，只不过用法上有点差别。

1、run函数必须由对象调用。
2、run函数只接受一个参数即Lambda表达式，并将调用对象作为Lambda表达式的上下文。
3、Lambda表达式最后一行代码作为run函数的返回值返回。
具体示例如下：

val list=listOf("Apple","Banana","Orange","Pear","Grape")
val builder=StringBuilder()
val result=builder.run {
    append("Start eating fruit \n")
    for(fruit in list){
        append("$fruit \n")
    }
    append("Ate all fruits")
    toString()
}

和with函数基本一致，只不过是将调用with函数传入StringBuilder对象改成了StringBuilder对象调用run函数。其他没有什么区别。

1.4、apply函数

apply函数和run函数也是极其相似的，都是在某个对象上使用并且只接受一个Lambda表达式参数，调用对象作为Lambda表达式的上下文，不同的是apply函数无法指定返回值，而是返回调用对象本身。示例如下：

val list=listOf("Apple","Banana","Orange","Pear","Grape")
val builder=StringBuilder()
val result=builder.apply{
    append("Start eating fruit \n")
    for(fruit in list){
        append("$fruit \n")
    }
    append("Ate all fruits")
}
println(result.toString())

由于apply函数无法指定返回值，只返回调用对象本身，所以这里的result是StringBuilder对象。

1.5、repeat函数

repeat函数接收2个参数，第一个参数是Int类型的，第二个参数Lambda表达式。第一个参数的意思表示的是指Lambda表达式中内容执行的次数。

  val list=ArrayList<String>()
        repeat(2) {
            list.add("1")
            list.add("2")
        }
//集合中的数据就是1,2,1,2

可以看到1,2添加了2遍。

2、定义静态方法

2.1、语法形式上模仿静态方法

在Java中定义静态方法很简单,只需使用static关键字即可。

public static void doAction(){}

在Kotlin中实现静态方法反而没那么简单，实现方式如下：

1、使用单例类实现。

object SIngleInstance {

    fun doAction(){}
}

调用也简单

SIngleInstance.doAction()

看上去是不是和Java中调用静态方法一样，其实Kotlin内部已经创建了唯一的SIngleInstance对象，然后使用对象调用doAction()方法，不过使用单例类的方法就会使类中的所有方法的调用全部变成了类似于静态方法调用的方式了。那么能不能只指定一个或部分方法变成静态方法的调用，这时候就需要companion object了。

2、使用关键字companion object实现

class Util {

    fun doAction1(){

    }

    companion object {
        fun doAction2(){
            println("do action2")
        }
    }
}

普通类Util中有2个方法doAction1()和doAction2()，他们还是有很大区别的，doAction1()的调用必须使用Util类的对象来调用，而doAction2()可以直接使用Util .doAction2()调用。
不过doAction2()其实也不是静态方法，companion object这个关键字实际上会在Util类的内部创建一个伴生类，而doAction2()这个方法就是定义在这个伴生类里面的实例方法，只不过Kotlin保证Util类只会存在一个伴生类对象，因此调用Util.doAction2()实际上调用Util类中伴生类对象的doAction2()。
由此可以看出Kotlin确实没有定义静态方法的关键字，但是提供了一些语法特性来支持静态方法调用的写法。

2.2、确确实实的静态方法

如果想定义实实在在的静态方法，Kotlin提供了两种实现方式：注解和顶层方法
上面我们使用单例类和关键字companion object在语法形式上模仿了静态方法的调用，**我们虽然可以在Kotlin中通过Util.doAction()，但是在Java中是无法这样调用的，因为它并不是真正的静态方法。

1、注解方法实现静态方法
注解方式实现静态方法只能用在单例类中或companion object关键中，下面我们在companion object关键中加上注解@JvmStatic：

companion object {
        @JvmStatic
        fun doAction2(){
            println("do action2")
        }
    }

这样无论在Kotlin中或者Java中我们都能使用Util.doAction2()了，因为此时doAction2()是真正的静态方法了。

2、顶层方法实现静态方法
顶层方法是指那些没有定义在任何类中的方法，Kotlin编译器会将所有顶层方法编译成静态方法。比如我们在新建的Kotlin FileHelper.kt中定义一个doSomething()方法

fun doSomething() {
    println("do Something")
}

1、在Kotlin中调用很简单，不用管包名路径，也不用创建实例对象，在任意位置都能调用该方法。
2、但是在Java中调用，就不能按Kotlin中这样写否则会报错，在Java中没有顶层方法的概念，所有方法都必须在类中。我们刚才创建的Helper.kt文件，Kotlin编译器就会创建一个HelperKt的Java类，所以在在Java中调用方式为：

HelperKt.doSomething();