Kotlin学习2-函数(表达式，lambda,高阶函数)

fun sum(a: Int, b: Int): Int {
    return a+b
}

fun sum2(a: Int, b: Int): Int = a + b
fun max(a: Int, b: Int): Int = if(a > b) a else b
fun isOdd(x: Int) = x % 2 != 0

//函数参数可以指定默认参数
fun multiply(a:Int,mut:Int=2):Int{
    var result = 1 
    for(i in 0..mut){
        result *= a
    }
    return result
}

1. 无参数情况 ：
val/var 变量名 = { 操作的代码 }
2. 有参数情况
val/var 变量名 : (参数的类型，参数类型，...) -> 返回值类型 = {参数1，参数2，... -> 操作参数的代码 }
示例：val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
3,自动推导返回值类型（即表达式的返回值类型会根据操作的代码自推导出来）
val/var 变量名 = { 参数1 ： 类型，参数2 : 类型, ... -> 操作参数的代码 }
示例：val sumLambda2 = {a : Int , b : Int -> a + b}

val sumLambda1: (Int, Int) -> Int = {x,y -> x+y}
val sumLambda2 = {a : Int , b : Int -> a + b}

fun initContentTextView(tvContent:TextView?){
        tvContent?.run {//对象初始化处理
            this.text = "kotlin"
            this.textSize = 13f
            this.setCompoundDrawables(null,null,getDrawable(R.drawable.abc_ab_share_pack_mtrl_alpha),null)
        }
    }

fun getIdentify(index:Int):String{
        val person_play = run {//将最后处理结果返回str
            when(index){
                0 -> "manager"
                1 -> "guest"
                2 -> "worker"
                else -> "none"
            }
        }
        return person_play
    }

fun getSampleNickName(nn:String):String{
        var sampleName = nn.run {
            if(this.length>10)
              substring(0,this.length-6)
            else
                nn
        }
        return sampleName
    }

val adam = Person("Adam").apply { 
    age = 20
    city = "London"
}

fun testLet(st:String?){
        st?.let {  // execute this block if not nul
            it.plus("-let1")
            if(it.startsWith("android"))
                it.drop(8)
        }
    }

val listWithNulls: List<String?> = listOf("element1","element2", null)
    for (item in listWithNulls) {
        item?.let { // 元素不为空时执行
            println(it)
        }    
     }  

fun testAlso() {
        val numberList = mutableListOf<Double>()
        numberList.also {
            println( "init the list")
        }.also {
            it.add( 2.71)
            it.add(3.14)
            it.add(1.0)
        }.also {
           println(  "Sorting the list")
        }.sort()
    }

 fun testWith(){
        var p = Person("Tom",26)
        //写法一,对象receiver和一个lambda函数块
        val result = with(p, {
            println("my name is $name, I am $age years old")
            1000
        })
        //由于with函数最后一个参数是一个函数，可以把函数提到圆括号的外部修改后
        val result2 = with(p) {
            println("my name is $name, I am $age years old")
            1000
        }

        val numbers = mutableListOf("one" , "two","three")
        with(numbers) {
            val firstItem = first()
            val lastItem = last()
            println("First item: $firstItem, last item:$lastItem")
        }
    }

 var globalLock = ReentrantLock()
    inline fun <T> lockInnerHandle(body: () -> T): T {//统一实现函数线程安全锁
        globalLock.lock()
        try {
            return body()
        }
        finally {
            globalLock.unlock()
        }
    }