kotlin中List/Set/Map等集合（1）

List/Set/Map等集合学习笔记###

/**
 * DESC   : List/Set/Map等集合
 */
class KtBaseCollectionTest01 {
    companion object{
        const val TAG = "KtBaseCollectionTest01"
    }

    private val list = listOf<String>("MCM", "Coach", "MK", "LV")


    /**
     * TODO List
     * getOrElse or getOrNull
     */
    fun testList01() {
        //list普通取值方式，使用下标
        Log.d(TAG, "testList01==>element0="+list[0]
                +", element1="+list[1]
                +", element2="+list[2]
                +", element3="+list[3])

//        Log.d(TAG, "testList01==>element5="+list[5])//会越界，崩溃

        /**
         * Kt代码，是要防止出现越界异常的，采用getOrElse or getOrNull
         * @param index 下标
         * @param defaultValue : lambda函数
         * getOrElse(index: Int, defaultValue: (Int) -> T): T
         *
         * getOrElse 取不到值的时候，返回defaultValue
         * getOrNull 取不到值的时候，返回null
         */
        val result0 = list.getOrElse(0, defaultValue = {
            "无名品牌"
        })

        val result2 = list.getOrElse(2) {
            "无名品牌"
        }

        //取不到值，返回为null
        val result3 =  list.getOrNull(3)

        val result4 = list.getOrElse(4, defaultValue = {
            "无名品牌"
        })


        val result5 =  list.getOrNull(5)

        // getOrNull + 空合并 ?:
        val result6 = list.getOrNull(6) ?: "无名品牌"

        /**
         * testList01==>result0=MCM, result2=MK, result3=LV, result4=无名品牌, result5=null, result6=无名品牌
         */
        Log.d(TAG, "testList01==>result0="+result0
                +", result2="+result2
                +", result3="+result3
                +", result4="+result4
                +", result5="+result5
                +", result6="+result6)
    }

    /**
     * 可变集合mutableListOf
     * 可变和不可变list的互相转换
     */
    fun testList02() {
        //不可变集合list2,无法完成可变的操作，无法进行add和remove操作
        val list2 = listOf("mcm", "coach", "lv")
//        list2.add()
//        list2.remove()

        //可变集合，可以进行add和remove操作
        val list3 = mutableListOf("mcm", "coach", "lv")
        list3.add("MJ")
        list3.remove("mcm")
        Log.d(TAG, "testList02==>list3="+list3)//testList02==>list3=[coach, lv, MJ]

        val list4 = mutableListOf("mcm", "coach", "lv")
        list4.add("MK")
        list4.remove("coach")


        //可变集合list4变成不可变集合list5，无法再进行add和remove操作
        val list5 = list4.toList()
//        list5.add()
//        list5.remove()

        //不可变集合list2变成可变集合list6, 可以再进行add和remove操作
        val list6 = list2.toMutableList()
        list6.add("CK")
        list6.remove("coach")
    }

    /**
     * list的方法
     * 1.mutator函数 += -=操作符
     * 2.removeIf 遍历集合，逐个删除
     */
    @RequiresApi(Build.VERSION_CODES.N)
    fun testList03() {
        val list2 = mutableListOf("mcm", "coach", "lv", "mlb", "mlc")

        /**
         * mutator特性：
         * += 和 -= 背后就是运算符重载而已
         */
        list2 += "MK"
        list2 -= "mcm"
        //testList03==>list2=[coach, lv, mlb, mlc, MK]
        Log.d(TAG, "testList03==>list2="+list2)

        /**
         * removeIf
         * list2.removeIf {true} 如果为true,自动遍历整个集合，逐个删除包含"ml"的元素
         */
        list2.removeIf{
            //过滤掉所有包含“ml”的元素，逐个删除
            it.contains("ml")
        }

        //testList03==>after removeIf....list2=[coach, lv, MK]
        Log.d(TAG, "testList03==>after removeIf....list2="+list2)
    }

    /**
     * list集合的遍历方式
     * in/forEach/forEachIndexed
     */
    fun testList04() {
        val list2 = mutableListOf("mcm", "coach", "lv", "mlb")
        //输出集合list2=[mcm, coach, lv, mlb]
        Log.d(TAG, "testList04==>输出集合list2="+list2)

        //第一种遍历方式 in
        for (element in list2) {
            Log.d(TAG, "testList04==>第一种遍历....元素：${element}")
        }

        //第二种遍历方式 forEach
        list2.forEach {
            //内部持有it, it== 每一个元素
            Log.d(TAG, "testList04==>第二种遍历....元素：${it}")
        }

        /**
         * 第三种遍历方式 forEachIndexed （想通过遍历得到index的情形）
         * @param index 下标
         * @param s 元素值
         */
        list2.forEachIndexed { index, s ->
            /**
             * testList04==>第三种遍历...获取到的index=0, 元素为 mcm
             * testList04==>第三种遍历...获取到的index=1, 元素为 coach
             * testList04==>第三种遍历...获取到的index=2, 元素为 lv
             * testList04==>第三种遍历...获取到的index=3, 元素为 mlb
             */
            Log.d(TAG, "testList04==>第三种遍历...获取到的index=${index}, 元素为 ${s}")
        }
    }

    /**
     * 1.集合配合解构语法
     * 2.反编译看java给三个变量赋值的代码
     * 3.解构屏蔽接收值
     */
    fun testList05() {
        val list2 = mutableListOf("mcm", "coach", "lv")

        val(value1, value2, value3) = list2

        //testList05==>value1=mcm, value2=coach, value3=lv
        Log.d(TAG, "testList05==>value1=${value1}, value2=${value2}, value3=${value3}")

        //用 _ 可以不接收某个元素赋值，可以节约一点性能
        val(_, v2,v3) =list2
        //testList05==>v2=coach, v3=lv
        Log.d(TAG, "testList05==>v2=${v2}, v3=${v3}")
    }

    /**
     * testList05转变成java代码如下：发现使用 _ 之后，此处并未给v1赋值
     *
     * public final void testList05() {
        List list2 = CollectionsKt.mutableListOf(new String[]{"mcm", "coach", "lv"});
        boolean var7 = false;
        String value1 = (String)list2.get(0);
        var7 = false;
        String value2 = (String)list2.get(1);
        var7 = false;
        String value3 = (String)list2.get(2);
        Log.d("KtBaseCollectionTest01", "testList05==>value1=" + value1 + ", value2=" + value2 + ", value3=" + value3);
        boolean var9 = false;
        String v2 = (String)list2.get(1);
        var9 = false;
        String v3 = (String)list2.get(2);
        Log.d("KtBaseCollectionTest01", "testList05==>v2=" + v2 + ", v3=" + v3);
        }
     */
}