2.kotlin筆記_操作符

1.生產操作符

zip，把兩個List組合成一個由Pair組成的List，每個Pair由兩個原List中index相對應的元素組成，這個List的長度由原來的兩個List中長度較短的那個List的長度決定:

    //zip
    fun test7() {
        val list1 = listOf("a", "b", "c","d")//自動推斷類型，無需指定
        val list2 = listOf(1, 2, 3)
        val zip = list1.zip(list2)

        for (item in zip) {
            print(item)
        }
        println()
        for (item in zip) {
            print(item.first)
            print(item.second)
            println()
        }
    }

執行結果：
(a, 1)(b, 2)(c, 3)
a1
b2
c3

unzip，把一個由Pair組成的List分解成一個由List組成的pair:

    fun test8(){
        val listOf = listOf(Pair("a", "b"), Pair(1, 2))
        println(listOf)
        println(listOf.unzip().first)
        println(listOf.unzip().second)
    }

執行結果：
[(a, b), (1, 2)]
[a, 1]
[b, 2]

plus，把兩個List拼在一起:

    //plus
    fun test9(){
        val list1 = listOf("a", "b", "c","d")
        val list2 = listOf(1, 2, 3)
        val list = list1 + list2
        print(list) //[a, b, c, d, 1, 2, 3]
    }

partition，把一個List按條件分成一個裝着List的Pair，the first list of the Pair是按條件計算結果爲true的元素集合，and the other one 是按條件計算結果爲false的元素集合:

    //partition
    fun test10() {
        val list = listOf<Int>(1, 2, 3, 4, 5, 6)
        val partition = list.partition { it % 2 == 0 }
        print(partition.first) //([2, 4, 6], [1, 3, 5])
    }

2.順序操作符

    fun test11(){
        val list = listOf<Int>(11, -2, 1)
        println(list.reversed())//倒序排序
        println(list.sorted())//自然排序
        println(list.sortedDescending())//自然降序排序
        println(list.sortedBy { -it })//根據指定函數自然排序
        println(list.sortedByDescending { -it })//根據指定函數自然降序排序
    }

執行結果：
[1, -2, 11]
[-2, 1, 11]
[11, 1, -2]
[11, 1, -2]
[-2, 1, 11]

3. 元素操作符

    fun test12() {
        val list = listOf<Int>(11, -2, 1)
        assertTrue(list.contains(11))
        assertEquals(-2, list.elementAt(1))//返回第1個元素，如果長度小於1，會拋IndexOutOfBoundsException
        assertEquals(11, list.elementAtOrElse(3, { 8 + it }))//如果沒有第3個元素，則返回8+3
        assertNull(list.elementAtOrNull(10))//如果角標越界，返回null

        assertEquals(1, list.first { it - 1 == 0 })//返回符合條件的第一個元素
        assertEquals(-2, list.last { it % 2 == 0 })//返回符合條件的最後一個元素

        assertNull(list.firstOrNull { it % 3 == 0 })//返回符合條件的第一個元素，如果沒有則返回Null
        assertNull(list.lastOrNull { it % 3 == 0 })//返回符合條件的最後一個元素，如果沒有則返回null

        val list1 = listOf(11, -2, 1, -2)
        assertEquals(1, list1.indexOf(-2))//返回這個元素的位置，如果未找到返回-1
        assertEquals(3, list1.lastIndexOf(-2))//返回這個元素的倒數第一的位置，如果未找到返回-1

        assertEquals(1, list.indexOfFirst { it % 2 == 0 })//返回符合條件的第一個元素的位置，如果沒找到返回-1
        assertEquals(1, list.indexOfLast { it % 2 == 0 })//返回符合條件的最後一個元素的位置，如果沒找到返回-1

        println(list.single { it % 2 == 0 })//返回符合條件的單個元素，如果沒有或超過一個會拋出IllegalArgumentException  執行結果：-2
        assertNull(list.singleOrNull { it % 3 == 0 })//返回符合條件的單個元素，如果沒有或超過一個返回null
    }

4.過濾操作符

    fun test13() {
        val list = listOf(11, -3, 1)
        val list1 = listOf(-1, 2, 3, -4, -5, 6)
        assertEquals(listOf(1), list.drop(2))//刪掉List裏前2個元素
        println(list1.dropWhile { it < 3 })//刪掉從第一項起滿足條件的元素，直到遇到不滿足條件爲止，到了3這裏就不滿足了，所以結果爲[3, -4, -5, 6]
        println(list1.dropLastWhile { it < 0 })//刪掉從最後一項起滿足條件的元素，直到遇到不滿足條件的元素爲止，第一項6就不滿足，所以結果爲[-1, 2, 3, -4, -5, 6]

        assertEquals(listOf(-3), list.filter { it < 0 })//返回List裏符合條件的元素集合
        assertEquals(listOf(11, 1), list.filterNot { it < 0 })//返回List裏不符合條件的元素集合
        val list2 = listOf(11, -3, 1, null)
        assertEquals(listOf(11, -3, 1), list2.filterNotNull())//返回集合中不爲null的元素
        val list3 = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        println(list3.slice(listOf(1, 3, 5)))//返回集合中指定下標的元素集合 [2, 4, 6]
        println(list3.slice(listOf(1, 5))) // [2, 6]
        println(list3.slice(1..5 step 2)) //返回index1到5步長2的元素，[2, 4, 6]
        assertEquals(listOf(1, 2), list3.take(2))//返回前n個元素的集合
        assertEquals(listOf(9,10), list3.takeLast(2))//返回最後n個元素的集合
        assertEquals(listOf(1, 2), list3.takeWhile { it < 3 })//從第一個開始返回所有符合條件的元素的集合
    }

5. 映射操作符

    fun test14() {
        val list = listOf(1, 2, 3, 4, 5, 6)
        println(list.flatMap { listOf(it.toString() + "a") })//遍歷一個集合，並把這個集合變成一個新的集合返回 [1a, 2a, 3a, 4a, 5a, 6a]
        assertEquals(mapOf("a" to listOf(1, 3, 5), "b" to listOf(2, 4, 6)), list.groupBy { if (it % 2 == 0) "b" else "a" })//根據指定條件把list分成兩組組成map，以"a","b"爲組名(key)
        val groupBy = list.groupBy {
            //根據條件把list分成多組list組成map {a=[1, 2], b=[3, 4], c=[5, 6]}
            when {
                it < 3 -> "a"
                it < 5 -> "b"
                else -> "c"
            }
        }
        println(groupBy)

        println(list.mapIndexed { index, it -> index * it })//帶index和對應值遍歷List，可對每個值操作後返回一個新的List [0, 2, 6, 12, 20, 30]
    }

6. 總數操作符

    fun test15(){
        val list = listOf(1, 2, 3, 4, 5, 6)
        assertTrue(list.any { it % 2 == 0 })//至少有一個匹配條件的元素，就返回true，否則false
        assertTrue(list.all { it < 10 })//全部元素都滿足條件纔會返回true
        assertEquals(3, list.count { it % 2 == 0 })//返回滿足條件的元素的個數
        assertEquals(31, list.fold(10) { total, next -> total + next })//先加10,再從List的第一個元素一直累加到最後一個
        assertEquals(31, list.foldRight(10) { total, next -> total + next })//效果同上，從右邊開始累加
        list.forEach { print(it) }//遍歷所有元素 123456
        println()
        list.forEachIndexed { index, value
            -> println("index $index ： $value") }//帶下標遍歷所有元素

        assertEquals(6, list.max())//最大值
        assertEquals(1, list.maxBy { -it })//根據條件去處後返回最大值
        //min minBy效果相反
        assertTrue(list.none { it % 7 == 0 })//如果找不到符合條件的元素就返回true
        assertEquals(21, list.reduce { total, next -> total + next })//效果同fold，但是沒初始值
        assertEquals(21, list.reduceRight { total, next -> total + next })//效果同上，從右邊開始
        assertEquals(3, list.sumBy { it % 2 })//遍歷所有元素進行運算後結果累加
    }

源碼