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]
         */