笔记:kotlin 学习第五天

  1. List集合

    /**
     * @ 文件名:   `01.List集合`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:14
     * @ 描述:     定义三种方式的集合(listOf、mutableList、Java中的list集合)
     */
    
    fun main(args: Array<String>) {
        //定义简单集合
        val listOf = listOf("林青霞", "张曼玉", "王祖贤", "李冰冰", "林志玲")
        println(listOf)
    
        //定义可变的集合
        val mutableListOf = mutableListOf("林青霞", "张曼玉", "王祖贤", "李冰冰", "林志玲")
        mutableListOf.add("张国荣")
        mutableListOf.add("林志颖")
        println(mutableListOf)
    
        //定义Java集合
        val arrayList = ArrayList<String>()
        arrayList.add("李冰冰")
        arrayList.add("范冰冰")
        arrayList.add("张馨予")
        arrayList.add("张馨予")
        println(arrayList)
    }
    
  1. List集合的遍历

    /**
     * @ 文件名:   `02.List集合的遍历`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:15
     * @ 描述:    for foreach
     */
    fun main(args: Array<String>) {
    //对List三种定义方式分别遍历
        //定义简单集合
        val listOf = listOf("林青霞", "张曼玉", "王祖贤", "李冰冰", "林志玲")
        for (s in listOf) {
            println(s)
        }
    
        //定义可变的集合
        val mutableListOf = mutableListOf("林青霞", "张曼玉", "王祖贤", "李冰冰", "林志玲")
        mutableListOf.add("张国荣")
        mutableListOf.add("林志颖")
        mutableListOf.forEach {
            println(it)
        }
    
        //定义Java集合
        val arrayList = ArrayList<String>()
        arrayList.add("李冰冰")
        arrayList.add("范冰冰")
        arrayList.add("张馨予")
        arrayList.add("张馨予")
        arrayList.forEachIndexed { index, s ->
            println("index: $index + s: $s")
        }
    }
    
  1. Set集合

    /**
     * @ 文件名:   `03.Set集合`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:16
     * @ 描述:    定义三种方式的集合(setOf、mutable、Java中的set集合)
     */
    fun main(args: Array<String>) {
        //不可变
        val set = setOf("林青霞", "张曼玉", "王祖贤", "李冰冰", "林志玲","王祖贤")
        println(set)
    
        val mutableListOf = mutableListOf("王祖贤","林青霞", "张曼玉", "王祖贤", "李冰冰", "林志玲")
        println(mutableListOf)
    
    
        val hashSet = HashSet<String>()
        hashSet.add("林志颖")
        hashSet.add("张国荣")
        hashSet.add("张国荣")
        println(hashSet)
    
        val hashSetOf = hashSetOf<String>()
        hashSetOf.add("刘德华")
        hashSetOf.add("刘德华")
        hashSetOf.add("洪金宝")
        println(hashSetOf)
    }
    
  1. Set集合的遍历

    /**
     * @ 文件名:   `04.Set集合的遍历`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:18
     * @ 描述:    遍历set集合
     */
    fun main(args: Array<String>) {
        val set = setOf("林青霞", "张曼玉", "林志玲", "王祖贤", "李冰冰", "林志玲")
        for (s in set) {
            println(s)
        }
        val mutableListOf = mutableListOf("林青霞", "张曼玉", "王祖贤", "张曼玉", "李冰冰", "林志玲")
        mutableListOf.forEach {
            println(it)
        }
    
        val hashSetOf = hashSetOf<String>()
        hashSetOf.add("刘德华")
        hashSetOf.add("洪金宝")
        hashSetOf.add("洪金宝")
        hashSetOf.forEachIndexed { index, s ->
            println("index: $index  + s: $s")
        }
    }
    
  1. Map集合

    /**
     * @ 文件名:   `05.map集合`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:18
     * @ 描述:     定义三种方式的集合(mapOf、mutableMap、Java中的map集合)
     */
    fun main(args: Array<String>) {
        val mapOf = mapOf(Pair("林青霞", 50), Pair("张曼玉", 40), Pair("林志玲", 30), Pair("林志颖", 18))
        println(mapOf)
    
        val mutableMapOf = mutableMapOf(Pair("林青霞", 50), Pair("张曼玉", 40), Pair("林志玲", 30), Pair("林志颖", 18))
        mutableMapOf.put("范冰冰", 24)
        mutableMapOf["李冰冰"] = 28
        println(mutableMapOf)
    
    
        val hashMapOf = hashMapOf<String, Int>()
        //val hashMap = HashMap<String, Int>()
        hashMapOf.put("洪金宝", 44)
        hashMapOf["成龙"] = 55
        println(hashMapOf)
    }
    
  1. Map集合的遍历

    /**
     * @ 文件名:   `06.Map集合的遍历`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:19
     * @ 描述:
     */
    fun main(args: Array<String>) {
        val mapOf = mapOf(Pair("林青霞", 50), Pair("张曼玉", 40), Pair("林志玲", 30), Pair("林志颖", 18))
        for (key in mapOf.keys) {
            println(key)
        }
    
        mapOf.values.forEach {
            println(it)
        }
    
        val mutableMapOf = mutableMapOf(Pair("林青霞", 50), Pair("张曼玉", 40), Pair("林志玲", 30), Pair("林志颖", 18))
        mutableMapOf.put("范冰冰", 24)
        mutableMapOf["李冰冰"] = 28
        mutableMapOf.forEach { t, u ->
            println("key: $t + value: +$u")
        }
    
        val hashMapOf = hashMapOf<String, Int>()
        //val hashMap = HashMap<String, Int>()
        hashMapOf.put("洪金宝", 44)
        hashMapOf["成龙"] = 55
        hashMapOf.forEach {
            println("key: ${it.key} + value: +${it.value}")
        }
    }
    
  1. 闭包

    /**
     * @ 文件名:   `07.闭包`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:19
     * @ 描述:    lambada表达式 函数不保存状态,闭包可以让函数携带状态
     */
    fun main(args: Array<String>) {
    
        val test = test()
        test()//120
        test()//121
        test()//122
    
    }
    
    fun test(): () -> Unit {
        var a = 120
        return {
            println("测试+$a")
            a++
        }
    }
    
  1. 高阶函数

    /**
     * @ 文件名:   `08.高阶函数`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:20
     * @ 描述:    定义一个工具函数calc 求两个数的和  求两个数的差
     * 函数类型的参数: block(a:Int,b:Int)->Int
     */
    fun main(args: Array<String>) {
        val calc = calc(10, 20, ::add)
        println(calc)
        val calc1 = calc(10, 20, ::sub)
        println(calc1)
    }
    
    /**
     * a:传递的第一个数据
     * b:传递的第二个数据
     * block:传递的工具  ::add  ::sub
     * 返回值:使用工具求出的值
     */
    fun calc(a: Int, b: Int, block: (a: Int, b: Int) -> Int): Int {
        return block.invoke(a, b)
    }
    
    fun add(a: Int, b: Int): Int {
        return a + b
    }
    
    fun sub(a: Int, b: Int): Int {
        return a - b
    }
    
  1. Lambda表达式

    /**
     * @ 文件名:   `09.Lambda表达式`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:22
     * @ 描述:   匿名函数 -> {}
     */
    fun main(args: Array<String>) {
        val calc = calc(19, 23, { a, b ->
            a + b
        })
    
        println(calc)
    }
    
    fun calc(a: Int, b: Int, block: (a: Int, b: Int) -> Int): Int {
        return block(a, b)
    }
    
  1. Lambda表达式去掉()

    /**
     * @ 文件名:   `10.Lambda表达式去掉()`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:23
     * @ 描述:    去掉参数()
     */
    
    fun main(args: Array<String>) {
        val calc = calc(24, 34) { m, n ->
            m + n
        }
        println(calc)
    }
    
    fun calc(a: Int, b: Int, block: (a: Int, b: Int) -> Int): Int {
        return block.invoke(a, b)
    }
    
  1. Lambda表达式单独存在

    /**
     * @ 文件名:   `11.Lambda表达式单独存在`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:23
     * @ 描述:    {}.invoke()  {}()
     */
    fun main(args: Array<String>) {
        /*{
             println("lambda表达式单独存在")//相当于method.invoke()
         }.invoke()*/
    
        {
            println("另一种调用方式")//相当于method()
        }()
    }
    
  1. 有参的lambda表达式

    /**
     * @ 文件名:   `12.有参的lambda表达式`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:36
     * @ 描述:    {}.invoke(a,b)
     */
    
    fun main(args: Array<String>) {
        val invoke = { a: Int, b: Int ->
            a + b
        }.invoke(28, 23)
    
        println(invoke)
    }
    
  1. 保存lambda表达式

    /**
     * @ 文件名:   `13.保存lambda表达式`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:37
     * @ 描述:    lambda表达式null处理
     */
    fun main(args: Array<String>) {
    
        var block: (() -> Unit)? = null
    
        /*block = {
            println("测试")
        }*/
    
        block?.invoke()
    }
    
  1. Lambda表达式使用it

    /**
     * @ 文件名:   `14.Lambda表达式使用it`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:38
     * @ 描述:    lambda表达式使用的时候如果参数只有一个,可以省略参数名,默认是使用it代替
     */
    fun main(args: Array<String>) {
    
    
        val block: ((i: Int) -> Unit) = {
            println(it)
        }
    
        block.invoke(123)
    }
    
  1. Lambda表达式的返回值

    /**
     * @ 文件名:   `15.Lambda表达式的返回值`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:42
     * @ 描述:    lambda表达式返回不用return  默认最后一行。
     */
    fun main(args: Array<String>) {
    
        val block: (() -> Int) = {
            println("test")
            11//最后一行就是return
        }
        println(block())
    }
    
  1. 常见的lambda表达式

    /**
     * @ 文件名:   `16.常见的lambda表达式`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:43
     * @ 描述:    扩展函数  indexOfFirst()
     */
    fun main(args: Array<String>) {
    
        val str = "张三"
    
        /**
         * foreach是一个扩展函数
         * foreach参数是一个函数
         */
        str.forEach {
            println(it)
        }
    
        val arrayOf = arrayOf("林青霞", "林志玲")
        val ofLast = arrayOf.indexOfLast {
            it.endsWith("玲")
        }
        println(ofLast)
    }
    
  1. 非诚勿扰

    /**
     * @ 文件名:   `17.非诚勿扰`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:45
     * @ 描述:
     */
    data class Girl(var name: String, var age: Int, var height: Int, var place: String)
    
    val girls = listOf(Girl("依儿", 18, 168, "山东"),
            Girl("笑笑", 19, 175, "河南"),
            Girl("小百合", 17, 155, "福建"),
            Girl("michel", 22, 148, "广东"),
            Girl("猫咪", 28, 159, "广西"),
            Girl("玲儿", 23, 169, "广东"),
            Girl("环环", 25, 172, "安徽"),
            Girl("胖嘟嘟", 32, 180, "河北"),
            Girl("乔乔", 35, 180, "广东"),
            Girl("小可爱", 27, 150, "江西"),
            Girl("一生有你", 22, 163, "山东"),
            Girl("敏儿", 28, 155, "黑龙江"),
            Girl("月儿", 25, 178, "吉林"),
            Girl("花儿", 21, 183, "山东"),
            Girl("S小糖", 49, 190, "新疆"),
            Girl("悦悦", 19, 160, "广西"),
            Girl("小可爱", 29, 158, "广东"),
            Girl("紫琪", 49, 149, "新疆"),
            Girl("糖心", 26, 165, "甘肃"),
            Girl("棒棒糖", 23, 172, "浙江"),
            Girl("猪猪侠", 18, 173, "山东"),
            Girl("喵喵", 27, 164, "河南"),
            Girl("安琦", 19, 159, "河北"),
            Girl("叶子", 20, 160, "广东"))
    
    fun main(args: Array<String>) {
        /**
         * filter参数是函数类型
         * filter的predicate函数的参数 是Girl类型
         * predicate 返回值 boolean
         * filter函数返回值 List集合
         */
        /*---------------------------- 俺是河南里,俺只找河南的妹子 ----------------------------*/
        val filter = girls.filter {
            it.place == "河南"
        }
        //println(filter)
    
        /*---------------------------- 我只喜欢30岁以下的女生 ----------------------------*/
        val filterAge = girls.filter {
            it.age < 30
        }
        //println(filterAge)
        /*---------------------------- 我喜欢广东的 ,身高162以上, 25岁以下的妹子 ----------------------------*/
        val map = girls.filter {
            it.place == "广东" && it.age < 25 && it.height > 162
        }
        //println(map)
    
        /*---------------------------- 我喜欢广东的, 身高160以上, 35岁以上的妹子 ----------------------------*/
        val filter1 = girls.filter {
            it.place == "广东" && it.height > 160 && it.age > 35
        }
        println(filter1)
    }
    
  1. 过滤

    /**
     * @ 文件名:   `18.过滤`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:46
     * @ 描述:    filter
     */
    fun main(args: Array<String>) {
    val list = listOf("张三", "李四", "王五", "赵六", "张四", "李五", "李六")
    val list2 = listOf("周芷若", "张无忌", "张五", "李善长", "林青霞", "李寻欢")
    
        //需求
        //找到第一个姓张的
        val filter = list.find {
            it.startsWith("张")
        }
        //println(filter)
    
        //把第一个集合中所有姓张的找出来
        val filter1 = list.filter {
            it.startsWith("张")
        }
        //println(filter1)
    
        //把两个集合中所有姓张的找到并存放在同一个集合中
        val mutableListOf = mutableListOf<String>()
        list.filterTo(mutableListOf) {
            it.startsWith("张")
        }
        list2.filterTo(mutableListOf){
            it.startsWith("张")
        }
        //println(mutableListOf)
    
        //把第一个集合中角标为偶数的元素找出来
        val indexed = list.filterIndexed { index, s ->
            index % 2 == 0
        }
        println(indexed)
    }
    
  1. 排序

    /**
     * @ 文件名:   `19.排序`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:47
     * @ 描述:    对普通数据类型和引用数据类型进行排序
     */
    fun main(args: Array<String>) {
        val list = arrayListOf(1, 3, 2, 54, 23, 12, 57, 342, 12)
        println(list.sorted())
        println(list.sortedDescending())
    
        val persons = listOf(Person("依儿", 18),
                Person("笑笑", 19),
                Person("小百合", 17),
                Person("michel", 22),
                Person("猫咪", 28),
                Person("玲儿", 23),
                Person("环环", 25),
                Person("胖嘟嘟", 32),
                Person("乔乔", 35),
                Person("小可爱", 27),
                Person("一生有你", 22),
                Person("敏儿", 28),
                Person("月儿", 25),
                Person("花儿", 21),
                Person("S小糖", 49),
                Person("悦悦", 19),
                Person("小可爱", 29),
                Person("紫琪", 49),
                Person("糖心", 26),
                Person("棒棒糖", 23),
                Person("猪猪侠", 18),
                Person("喵喵", 27),
                Person("安琦", 19),
                Person("叶子", 20))
    
        val byDescending = persons.sortedBy {
            it.age
        }
        println(byDescending)
    
    }
    
    data class Person(var name: String, var age: Int)
    
  1. 分组

    /**
     * @ 文件名:   `20.分组`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:48
     * @ 描述:   groupBy()
     */
    fun main(args: Array<String>) {
        val list = listOf("张三", "李四", "王五", "赵六", "张四", "李五", "李六")
        //姓张的一组 姓李的一组 其他一组
        val groupBy = list.groupBy {
            val substring = it.substring(0, 1)
            when (substring) {
                "张" -> {
                    "张"
                }
                "李" -> {
                    "李"
                }
                else -> {
                    "其他"
                }
            }
        }
        println(groupBy)
    }
    
  1. 最值

    /**
     * @ 文件名:   `21.最值`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:49
     * @ 描述:    普通数据类型和引用数据类型求最大最小值 .max()  .min()
     */
    
    fun main(args: Array<String>) {
        val listOf = arrayListOf(2, 13, 234, 23, 1, 45456, 2, 3, 462, 12, 2, 344, 2)
    
        val max = listOf.max()
        println(max)
    
        val min = listOf.min()
        println(min)
    
        val persons = listOf(Person("依儿", 18),
                Person("笑笑", 19),
                Person("小百合", 17),
                Person("michel", 22),
                Person("猫咪", 28),
                Person("玲儿", 23),
                Person("环环", 25),
                Person("胖嘟嘟", 32),
                Person("乔乔", 35),
                Person("小可爱", 27),
                Person("一生有你", 22),
                Person("敏儿", 28),
                Person("月儿", 25),
                Person("花儿", 21),
                Person("S小糖", 49),
                Person("悦悦", 19),
                Person("小可爱", 29),
                Person("紫琪", 49),
                Person("糖心", 26),
                Person("棒棒糖", 23),
                Person("猪猪侠", 18),
                Person("喵喵", 27),
                Person("安琦", 19),
                Person("叶子", 20))
    
        val maxBy = persons.maxBy {
            it.age
        }
        println(maxBy)
    
        val minBy = persons.minBy {
            it.age
        }
        println(minBy)
    }
    
  1. 去除重复

    /**
     * @ 文件名:   `22.去除重复`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:50
     * @ 描述:    toSet()     distinct()
     */
    fun main(args: Array<String>) {
        val list = listOf("张三","李四","王五","赵六","张四","李五","张三","李六")
        //把重复的张三去掉
        val toSet = list.toSet()
        println(toSet)
        val distinct = list.distinct()
        println(distinct)
    
        //去掉重复姓
        val distinctBy = list.distinctBy {
            it.substring(0,1)
        }
        println(distinctBy)
    }
    
  1. 集合拆分

    /**
     * @ 文件名:   `23.集合拆分`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:51
     * @ 描述:    partition()
     */
    fun main(args: Array<String>) {
        val list = listOf("张三","李四","王五","赵六","张四","李五","张三","李六")
        //姓张的一部分,另外的一部分
        val partition = list.partition {
            it.startsWith("张")
        }
    
        println(partition)
    }
    
  1. 集合重新组合

    /**
     * @ 文件名:   `24.集合重新组合`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:52
     * @ 描述:    map()
     */
    fun main(args: Array<String>) {
        val list1 = listOf(Person("林青霞",50),Person("张曼玉",30),Person("林志玲",40),Person("柳岩",70))
        //将Person里面每一个姓氏获取到一个单独的集合中
        val map = list1.map {
            it.name.substring(0,1)
        }.distinct()
        println(map)
    }
    
  1. 集合相加

    /**
     * @ 文件名:   `25.集合相加`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:53
     * @ 描述:    sumBy()
     */
    fun main(args: Array<String>) {
        val list = listOf(Person("林青霞",50),Person("张曼玉",30),Person("柳岩",70))
        //求出所有人的年龄之和
        val sumBy = list.sumBy {
            it.age
        }
    
        println(sumBy)
    }
    
  1. 函数回调

    /**
     * @ 文件名:   `26.函数回调`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:54
     * @ 描述:
     */
    
    open class Mother {
        fun cooking() {
            println("妈妈开始做菜")
        }
    
        fun makeDessert() {
            println("做甜点")
        }
    
        fun getSoy(soy: Soy) {
            println("取回了${soy.name}酱油")
        }
    }
    
    class SuperMarket {
        fun buySoy(block: (Soy) -> Unit?) {
            Thread {
                Thread.sleep(5000)
                val soy = Soy("海天")
                block?.invoke(soy)
            }.start()
        }
    }
    
    class Soy(var name: String)
    
    fun main(args: Array<String>) {
        val mother = Mother()
    
        val superMarket = SuperMarket()
    
        superMarket.buySoy {
            mother.getSoy(it)
            mother.cooking()
        }
    
        mother.makeDessert()
    }
    
  1. 四大函数

    /**
     * @ 文件名:   `27.四大函数`
     * @ 创建者:   ty
     * @ 时间:    2018/7/24 14:53
     * @ 描述:    with apply let run
     */
    fun main(args: Array<String>) {
        val listOf: ArrayList<String> = arrayListOf("林青霞", "林志玲", "林志颖", "李冰冰")
    
    //    listOf?.add("张曼玉")
    //    listOf?.add("王祖贤")
    //    listOf?.add("范冰冰")
    
        /**
         * 任意类型都有apply函数扩展
         * apply参数是一个函数  T.() -> Unit 带接收者的函数字面值
         * lambda表达式里this代表调用的对象
         * 在lambda表达式里可以访问对象的方法
         * apply函数返回值就是调用者本身
         */
        listOf?.apply {
            add("张曼玉")
            add("王祖贤")
            add("范冰冰")
        }
    
        /**
         * 任意对象都有let扩展函数
         * let函数参数也是一个函数
         * 函数参数它的参数是调用者本身
         * let函数返回值是函数参数的返回值 就是lambda表达式的返回值
         */
        listOf?.let {
            it.add("张曼玉")
            it.add("王祖贤")
            it.add("范冰冰")
            10
        }
    
        /**
         * with是独立的函数  可以在任意地方调用
         * with函数需要接收两个参数
         * 第一个参数可以接收任意类型
         * 第二个参数是函数参数,并且这个函数参数是带接收者的函数字面值 接收者就是第一个参数
         * with函数返回值是第二个函数参数的返回值
         * 相当于apply和let的结合
         */
        with(listOf) {
            this.add("张曼玉")
            this.add("王祖贤")
            this.add("范冰冰")
            "a"
        }
    
        /**
         * 任意类型都有run扩展函数
         * run函数参数是待接收者的函数 接收者是调用者本身
         * run函数返回值就是函数参数的返回值
         */
        listOf.run {
            this.add("张曼玉")
            this.add("王祖贤")
            this.add("范冰冰")
            "b"
        }
    }
    

推荐阅读更多精彩内容