Kotlin筆記七，集合和函數操作符

總數操作符

any
	如果至少有一個元素符合給出的判斷條件，則返回true。
all
	如果全部的元素符合給出的判斷條件，則返回true。
count
	返回符合給出判斷條件的元素總數。
fold
	在一個初始值的基礎上從第一項到最後一項通過一個函數累計所有的元素。
foldRight
	與fold一樣，但是順序是從最後一項到第一項。
reduce
	與fold一樣，但是沒有一個初始值。通過一個函數從第一項到最後一項進行累計。
reduceRight
	與reduce一樣，但是順序是從最後一項到第一項。
forEach
	遍歷所有元素，並執行給定的操作。
forEachIndexed
	與forEach，但是我們同時可以得到元素的index。
max
	返回最大的一項，如果沒有則返回null。
maxBy
	根據給定的函數返回最大的一項，如果沒有則返回null。
min
	返回最小的一項，如果沒有則返回null。
none
	如果沒有任何元素與給定的函數匹配，則返回true。
sumBy
	返回所有每一項通過函數轉換之後的數據的總和。

過濾操作符

drop
	返回包含去掉前n個元素的所有元素的列表。
dropWhile
	返回根據給定函數從第一項開始去掉指定元素的列表。
dropLastWhile
	返回根據給定函數從最後一項開始去掉指定元素的列表。
filter
	過濾所有符合給定函數條件的元素。
filterNot
	過濾所有不符合給定函數條件的元素。
filterNotNull
	過濾所有元素中不是null的元素。
slice
	過濾一個list中指定index的元素。
take
	返回從第一個開始的n個元素。
takeLast
	返回從最後一個開始的n個元素
takeWhile
	返回從第一個開始符合給定函數條件的元素。

映射操作符

flatMap
	遍歷所有的元素，爲每一個創建一個集合，最後把所有的集合放在一個集合中。
groupBy
	返回一個根據給定函數分組後的map。
map
	返回一個每一個元素根據給定的函數轉換所組成的List。
mapIndexed
	返回一個每一個元素根據給定的包含元素index的函數轉換所組成的List。
mapNotNull
	返回一個每一個非null元素根據給定的函數轉換所組成的List。

元素操作符

contains
	如果指定元素可以在集合中找到，則返回true。
elementAt
	返回給定index對應的元素，如果index數組越界則會拋出IndexOutOfBoundsException。
elementAtOrElse
	返回給定index對應的元素，如果index數組越界則會根據給定函數返回默認值。
elementAtOrNull
	返回給定index對應的元素，如果index數組越界則會返回null。
first
	返回符合給定函數條件的第一個元素。
firstOrNull
	返回符合給定函數條件的第一個元素，如果沒有符合則返回null。
indexOf
	返回指定元素的第一個index，如果不存在，則返回-1。
indexOfFirst
	返回第一個符合給定函數條件的元素的index，如果沒有符合則返回-1。
indexOfLast
	返回最後一個符合給定函數條件的元素的index，如果沒有符合則返回-1。
last
	返回符合給定函數條件的最後一個元素。
lastIndexOf
	返回指定元素的最後一個index，如果不存在，則返回-1。
lastOrNull
	返回符合給定函數條件的最後一個元素，如果沒有符合則返回null。
single
	返回符合給定函數的單個元素，如果沒有符合或者超過一個，則拋出異常。
singleOrNull
	返回符合給定函數的單個元素，如果沒有符合或者超過一個，則返回null。

生產操作符

partition
	把一個給定的集合分割成兩個，第一個集合是由原集合每一項元素匹配給定函數條件返回true的元素組成，
	第二個集合是由原集合每一項元素匹配給定函數條件返回false的元素組成。
plus
	返回一個包含原集合和給定集合中所有元素的集合，因爲函數的名字原因，我們可以使用+操作符。
zip
	返回由pair組成的List，每個pair由兩個集合中相同index的元素組成。這個返回的List的大小由最小的那個集合決定。
unzip
	從包含pair的List中生成包含List的Pair。

順序操作符

reverse
	返回一個與指定list相反順序的list
sort
	返回一個自然排序後的list。
sortBy
	返回一個根據指定函數排序後的list。
sortDescending
	返回一個降序排序後的List。
sortDescendingBy
	返回一個根據指定函數降序排序後的list。

測試代碼及結果

	var numList = listOf(1,2,3,4,5,6,7,8,9)

    //總數操作符
        //返回符合給出判斷條件的元素總數
        println("count--"+numList.count{it %2 == 0})
        //如果至少有一個元素符合給出的判斷條件，則返回true。
        println("any--"+numList.any{it %2 == 0})
        //如果全部的元素符合給出的判斷條件，則返回true。
        println("all--"+numList.all{it %2 == 0})
        //在一個初始值的基礎上從第一項到最後一項通過一個函數累計所有的元素。
        println("fold--"+numList.fold(4) { total, next -> total + next })
        //foldRight
        //與fold一樣，但是順序是從最後一項到第一項。
        println("foldRight--"+numList.foldRight(4) { total, next -> total + next })
        //reduce
        //與fold一樣，但是沒有一個初始值。通過一個函數從第一項到最後一項進行累計。
        println("reduce--"+numList.reduce{ total, next -> total + next })
        //reduceRight
        //與reduce一樣，但是順序是從最後一項到第一項。
        println("reduceRight--"+numList.reduceRight{ total, next -> total + next })

        numList.forEach { print(it.toString()+",") }
        println()

        numList.forEachIndexed { index, i -> print("$index ------ $i   ,") }
        println()

        //sumBy
        //返回所有每一項通過函數轉換之後的數據的總和。
        println("sumBy--"+numList.sumBy { it %3 })

        println("max--"+numList.max())
        println("maxBy--"+numList.maxBy { it })
        println("min--"+numList.min())
        println("minBy--"+numList.minBy { it })

        //如果沒有任何元素與給定的函數匹配，則返回true。
        println("none--"+numList.none { it >8})
        //過濾操作符
        //drop
        //返回包含去掉前n個元素的所有元素的列表。
        println("drop--"+numList.drop(8))
        //返回根據給定函數從第一項開始去掉指定元素的列表。
        println("dropWhile--"+numList.dropWhile { it <3 })
        //返回根據給定函數從最後一項開始去掉指定元素的列表。
        println("dropLastWhile--"+numList.dropLastWhile { it >5 })
        println("count--"+numList.count())

        /**
         *  count--4
            any--true
            all--false
            fold--49
            foldRight--49
            reduce--45
            reduceRight--45
            1,2,3,4,5,6,7,8,9,
            0 ------ 1   ,1 ------ 2   ,2 ------ 3   ,3 ------ 4   ,4 ------ 5   ,5 ------ 6   ,6 ------ 7   ,7 ------ 8   ,8 ------ 9   ,
            sumBy--9
            max--9
            maxBy--9
            min--1
            minBy--1
            none--false
            drop--[9]
            dropWhile--[3, 4, 5, 6, 7, 8, 9]
            dropLastWhile--[1, 2, 3, 4, 5]
            count--9
         */


        //過濾操作符
        //過濾所有符合給定函數條件的元素。
        println("filter--"+numList.filter {it >3  })

//        filterNot
//        過濾所有不符合給定函數條件的元素。
        println("filterNot--"+numList.filterNot {it >3  })
        var anyList = listOf(1,null,3,null,5,null,7,null)
        //過濾所有元素中不是null的元素。
        println("filterNotNull--"+anyList.filterNotNull())

//        過濾一個list中指定index的元素。
        println("slice--"+numList.slice(listOf(0,1,3)))
        //take
        //返回從第一個開始的n個元素。
        println("take--"+numList.take(3))
        //takeLast
        //返回從最後一個開始的n個元素
        println("takeLast--"+numList.takeLast(3))

        //takeWhile
//        返回從第一個開始符合給定函數條件的元素。
        println("takeWhile--"+numList.takeWhile { it<4 })

        /**
         *
            filter--[4, 5, 6, 7, 8, 9]
            filterNot--[1, 2, 3]
            filterNotNull--[1, 3, 5, 7]
            slice--[1, 2, 4]
            take--[1, 2, 3]
            takeLast--[7, 8, 9]
            takeWhile--[1, 2, 3]
         */



    //映射操作符
        //遍歷所有的元素，爲每一個創建一個集合，最後把所有的集合放在一個集合中。
        println("flatMap--"+numList.flatMap { listOf(1,2,3,it*5) })
        //返回一個根據給定函數分組後的map。
        println("groupBy--"+numList.groupBy { if(it % 2 == 0) "偶數" else "奇數" })
        //返回一個每一個元素根據給定的函數轉換所組成的List。
        println("map--"+numList.map { it*3 })

        //mapIndexed
        //返回一個每一個元素根據給定的包含元素index的函數轉換所組成的List。
        println("mapIndexed--"+numList.mapIndexed { index, i -> index * i })

        //返回一個每一個非null元素根據給定的函數轉換所組成的List。
        println("mapNotNull--"+numList.mapNotNull {it * 3})

        /**
         *  flatMap--[1, 2, 3, 5, 1, 2, 3, 10, 1, 2, 3, 15, 1, 2, 3, 20, 1, 2, 3, 25, 1, 2, 3, 30, 1, 2, 3, 35, 1, 2, 3, 40, 1, 2, 3, 45]
            groupBy--{奇數=[1, 3, 5, 7, 9], 偶數=[2, 4, 6, 8]}
            map--[3, 6, 9, 12, 15, 18, 21, 24, 27]
            mapIndexed--[0, 2, 6, 12, 20, 30, 42, 56, 72]
            mapNotNull--[3, 6, 9, 12, 15, 18, 21, 24, 27]
         */

    //元素操作符
        //如果指定元素可以在集合中找到，則返回true。
        println("contains--"+numList.contains(2))

        //返回給定index對應的元素，如果index數組越界則會拋出IndexOutOfBoundsException。
        println("elementAt--"+numList.elementAt(2))

        //返回給定index對應的元素，如果index數組越界則會根據給定函數返回默認值。
        println("elementAtOrElse--"+numList.elementAtOrElse(100,{999}))

        //返回給定index對應的元素，如果index數組越界則會返回null。
        println("elementAtOrNull--"+numList.elementAtOrNull(20))

        //返回符合給定函數條件的第一個元素
        println("first--"+numList.first{it < 5})

        //返回符合給定函數條件的第一個元素，如果沒有符合則返回null。
        println("firstOrNull--"+numList.firstOrNull{it < 0})

        //返回指定元素的第一個index，如果不存在，則返回-1。
        println("indexOf--"+numList.indexOf(3))

        //返回第一個符合給定函數條件的元素的index，如果沒有符合則返回-1。
        println("indexOfFirst--"+numList.indexOfFirst { it <5 })

        //返回最後一個符合給定函數條件的元素的index，如果沒有符合則返回-1。
        println("indexOfLast--"+numList.indexOfLast { it <5 })

        //返回符合給定函數條件的最後一個元素。
        println("last--"+numList.last{it < 5})

        //返回指定元素的最後一個index，如果不存在，則返回-1。
        println("lastIndexOf--"+numList.lastIndexOf(3))

        //返回符合給定函數條件的最後一個元素，如果沒有符合則返回null。
        println("lastOrNull--"+numList.lastOrNull { it <6 })

        //返回符合給定函數的單個元素，如果沒有符合或者超過一個，則拋出異常。
        println("single--"+numList.single{ it == 5 })

        //返回符合給定函數的單個元素，如果沒有符合或者超過一個，則返回null。
        println("singleOrNull--"+numList.singleOrNull{ it > 5 })

        /**
         *  contains--true
            elementAt--3
            elementAtOrElse--999
            elementAtOrNull--null
            first--1
            firstOrNull--null
            indexOf--2
            indexOfFirst--0
            indexOfLast--3
            last--4
            lastIndexOf--2
            lastOrNull--5
            single--5
            singleOrNull--null
         */

    //生產操作符
        //partition
        //把一個給定的集合分割成兩個，第一個集合是由原集合每一項元素匹配給定函數條件返回true的元素組成，
        第二個集合是由原集合每一項元素匹配給定函數條件返回false的元素組成。
        println("partition--"+numList.partition { it % 2 == 0 })

        //plus
        //返回一個包含原集合和給定集合中所有元素的集合，因爲函數的名字原因，我們可以使用+操作符。
        println("plus--"+numList.plus(listOf(10,11)))

        //zip
        //返回由pair組成的List，每個pair由兩個集合中相同index的元素組成。這個返回的List的大小由最小的那個集合決定。

        println("zip--"+numList.zip(listOf(100,101)))

        //unzip
        //從包含pair的List中生成包含List的Pair。
        println("unzip--"+listOf(Pair(3,4),Pair(7,8)).unzip())

        /**
         *  partition--([2, 4, 6, 8], [1, 3, 5, 7, 9])
            plus--[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
            zip--[(1, 100), (2, 101)]
            unzip--([3, 7], [4, 8])
         */

    //順序操作符

        //reverse
        //返回一個與指定list相反順序的list
        println("reversed--"+numList.reversed())

        //sort
        //返回一個自然排序後的list。
        println("sorted--"+numList.sorted())

        //sortBy
        //返回一個根據指定函數排序後的list。
        println("sortedBy--"+numList.sortedBy { it % 4})

        //sortDescending
        //返回一個降序排序後的List。
        println("sortedDescending--"+numList.sortedDescending())

        //sortDescendingBy
        //返回一個根據指定函數降序排序後的list。
        println("sortedByDescending--"+numList.sortedByDescending { it %3 })

        /**
         *  reversed--[9, 8, 7, 6, 5, 4, 3, 2, 1]
            sorted--[1, 2, 3, 4, 5, 6, 7, 8, 9]
            sortedBy--[4, 8, 1, 5, 9, 2, 6, 3, 7]
            sortedDescending--[9, 8, 7, 6, 5, 4, 3, 2, 1]
            sortedByDescending--[2, 5, 8, 1, 4, 7, 3, 6, 9]
         */