Kotlin学习（4）Lambda

Lanbda基础

/*
*Lambda允许把代码块当作参数传递给函数
*/
fun a(plus:(Int,Int)->Unit){
     plus(1,2) //声明函数的地方，调用代码块，在这里传参
}

//在调用函数的地方，写代码块的实现
fun main(args: Array<String>) {
    a({a1,a2->
        println(a1+a2)   //在这里操作参数
    })
}

/*
*如果这个代码块是最后一个参数，可以把大括号写在圆括号外面
*/
 a(){a1,a2->
       println(a1+a2)   //在这里操作参数
 }

/*
*如果这个代码块是唯一的参数，可以省略括号
*/
a{a1,a2->
       println(a1+a2)   //在这里操作参数
 }

/*
*如果代码块的参数只有一个a1，那么这个参数也可以省略，默认为it
*/
a{
       println(it)   //在这里操作参数
 }

 

Lambda对集合的操作

val list= arrayListOf(1,2,4,5,6,7,8)

//foreach遍历，这里省略了参数
>>>   list.forEach{
>>>     println("${it}  ")
>>>   }
1  2  4  5  6  7  8

//filter  只保留符合条件的数据
>>>println( list.filter { it>3 } )
[4,5,6,7,8]

//map   得到操作后的数据
>>>println( list.map { it>*it } )
[1, 4, 16, 25, 36, 49, 64]

//all 判断集合内数据是否全都符合
>>>println( list.all { it>3 } )
false

//any 判断集合是否至少存在一个符合条件的值
>>>println( list.any { it>5 } )
true

//find 找到符合条件的第一个数据
>>>println( list.find { it>5 } )
6

//count 找到符合条件的数据数量
>>>println( list.find { it>7 } )
1

//可以链式调用,如 找到it+1 之后，是偶数的数据
>>>println( list.map { it+1 }.filter{ it%2==0 } )
[2, 6, 8]

//上面的链式调用，其实把map的结果保存一次之后，再进行filter，在保存filter结果，其实保存了两次，可以把初始集合转换成序列，提高效率
list.asSequence()
     .map { it+1 }
     .filter{ it%2==0 }

 

带接收者的Lambda：with和apply

/*
*正常打印A到Z的函数,会重复写result很多次
*/
fun alphabet():String{
    val result=StringBuilder()
    for(i in 'A'..'Z'){
         result.append(i)
    }
    result.append("\n end!")
    return result.toString()
}

/*
*使用with来重构,with可以接收str对象，Lambda里面的代码块可以省略str，最后一行作为返回值
*/
fun alphabet():String{
    val str=StringBuilder()
    return with(str){
         for(i in 'A'..'Z'){
            this.append(i)   //可以用this显式调用，也可以省略
         }
         append("\n end!")
         toString()
    }
}

/*
*使用apply来重构，它把调用apply的对象作为接收对象进行操作
*/
fun alphabet():String{
   return StringBuilder().apply{
         for(i in 'A'..'Z'){
             append(i)
         }
         append("\n end!")
    }.toString()
}