函数

今天我们来学习了。applay、let、with、run、lazy、user、repeat、lambda等函数

applay

.调用指定的函数[块]，并将此值作为其接收器返回此值。

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

          fun myApplay(){
                 //apply
            //    apply函数
                val task = Runnable { println("运行中") }
                Thread(task).apply { setDaemon(true) }.start()
            
                val task2 = Run
    
    nable { println("running") }
            val thread = Thread(task2)
            thread.setDaemon(true)
            thread.start()
            //let函数
        }

let函数

使用此值作为参数调用指定的函数[block]并返回其结果。
    @kotlin.internal.InlineOnly
    public inline fun <T, R> T.let(block: (T) -> R): R {
        contract {
            callsInPlace(block, InvocationKind.EXACTLY_ONCE)
        }
        return block(this)
    }
//先打印 it是打印"mylet"
//后打印 999

fun myLet():Int{
    "myLet".let{
        println(it)
        return 999
    }
}

with 函数

with是一个单纯的函数，并不是扩展方法

@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()

run

和with函数类似调用指定的函数[块]，并以该值作为其接收方，返回其结果。

@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
 fun myRun(){
        ArrayList<String>().run {
            add("aaaa")
            add("bbbb")
            add("cccc")
            println(this.joinToString())
    
        }.let { println(it) }
    }

lazy 函数

他是一种懒惰的这是函数表达式

public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
例子：
fun myLazy(){
    fun requstJson():String="{name   age   }"
    val lazyString = lazy { requstJson() }

    val stringResult = lazyString.value
}

use函数

在这个资源上执行给定的[block]函数，然后正确地关闭它，不管是否抛出异常@aram阻塞一个函数来处理这个[可关闭的]资源。@返回在此资源上调用的[block]函数的结果。

   @InlineOnly
@RequireKotlin("1.2", versionKind = RequireKotlinVersionKind.COMPILER_VERSION, message = "Requires newer compiler version to be inlined correctly.")
public inline fun <T : Closeable?, R> T.use(block: (T) -> R): R {
    var exception: Throwable? = null
    try {
        return block(this)
    } catch (e: Throwable) {
        exception = e
        throw e
    } finally {
        when {
            apiVersionIsAtLeast(1, 1, 0) -> this.closeFinally(exception)
            this == null -> {}
            exception == null -> close()
            else ->
                try {
                    close()
                } catch (closeException: Throwable) {
                    // cause.addSuppressed(closeException) // ignored here
                }
        }
    }
}
例子：
 @RequiresApi(Build.VERSION_CODES.O)
    fun myUse(){
        val input = Files.newInputStream(Paths.get("f:\\myInformation.txt"))
        val byte = input.use {
            input.read()
        }
    }

repeat函数

执行指定次数的给定函数[操作]。.当前迭代的从零开始的索引作为参数传递给[action]@sample样本。混杂。控制流,重复

@kotlin.internal.InlineOnly
public inline fun repeat(times: Int, action: (Int) -> Unit) {
    contract { callsInPlace(action) }

    for (index in 0 until times) {
        action(index)
    }
}
例子:
  fun myRepeat(){
        //repeat(times: Int, action: (Int) -> Unit)
        repeat(8, {println("执行")})
    }

lambda表达式

//语法为 {参数1，参数2…参数n ->执行的语句}

{x:Int,y:Int->x+y}