学习kotlin系列之十（集合和表达式）

1、集合

1）list集合

创建方式：
（1）listOf<>()
（2）mutableListOf<>()

fun main(args: Array<String>) {
//list集合
    //第一种创建方式
    val list = listOf<String>("林青霞","梁朝伟")
    list.filter {
        if (it.equals("林青霞")){
            println(it)
        }
        return
    }
    val list1= mutableListOf<String>()
    list1.add("林青霞")
    list1.forEach {
        println(it)
    }
    val list3= arrayListOf<String>()
}

2）map集合

fun main(args: Array<String>) {
//第一种不能增加
    val map= mapOf<String,String>("中国" to "China")
    map.forEach { t, u ->//key和value
        println(t)
    }
    //遍历所有的key或者value
    val keySet=map.keys

    //第二种
    val maps= mutableListOf<String>()
    //第三种类似于java
    val mapss=HashMap<String,String>()

}

3）闭包

kotlin的闭包就是lambda表达式

fun main(args: Array<String>) {
    val result= test()
    result()
    result()
    result()
}

/**
 * 函数式编程 函数可以作为方法的返回值 方法可以作为函数的参数
 */
fun test():()->Unit{
    var a=10
        return {
            println(a)
            a++
        }
}

4）高阶函数

核心思想：给它什么工具它就会根据当前这个工具求出对应的值。
说明：kotlin里面的函数可以传递函数参数 如果函数里面传递函数参数的话就称为高阶函数

fun cacl(a:Int,b:Int,block:(Int,Int)->Int):Int{

    val result=block(a,b)
    return result
}
fun add(a:Int,b:Int):Int{
    return a+b
}
fun sub(a:Int,b:Int):Int{
    return a-b
}

5）lanbuda表达式

核心思想：函数的参数定义出来后 可以自动推断出类型 返回值不需要写，
推断出当前的返回值类型。

fun main(args: Array<String>) {
    println(cacl(34, 45, {m,n->m+n}))
    println(cacl(64, 45) { m, n->m-n})
}


fun cacl(a:Int,b:Int,block:(Int,Int)->Int):Int{

    val result=block(a,b)
    return result
}
fun add(a:Int,b:Int):Int{
    return a+b
}
fun sub(a:Int,b:Int):Int{
    return a-b
}

6）lanbuda表达式去括号

如果最后一个参数是lambda表达式时 可以把（）前移

fun main(args: Array<String>) {
    println(cacl(34, 45) { m, n->m+n})
    println(cacl(64, 45) { m, n->m-n})
}

/**
 * 只能我用这个工具 不能让其他人使用
 * 函数的参数定义出来后 可以自动推断出类型 返回值不需要写 推断出当前的返回值类型
 * 匿名函数lambda表达式
 * 调用的时候最后一个参数传递的是匿名函数lambda表达式
 * 如果最后一个参数是lambda表达式时   可以把（）前移
 */
fun cacl(a:Int,b:Int,block:(Int,Int)->Int):Int{

    val result=block(a,b)
    return result
}
fun add(a:Int,b:Int):Int{
    return a+b
}
fun sub(a:Int,b:Int):Int{
    return a-b
}

7）lambda表达式单独存在

fun main(args: Array<String>) {
    /**
     * 第一种
     */
    //第一种写法
//    { println("你好")}()
    //第二种写法
//    { println("大头儿子") }.invoke()


    /**
     * 第二种
     */
//    val result = { a: Int, b: Int -> a + b }(10, 30)
    val result = { p: People, b: Int ->
        if (p.age>b){
            println("比14大")
        }
    }.invoke(People(),30)
    println(result)
}
class People{
    val age:Int=54
    val name:String="哈哈哈"
}