list操作方法解析：
.any
如果至少有一个元素符合给出的判断条件，则返回true
val list = listOf(1,2,3,4,5,6)
list.any(it % 2 == 0) // true
list.any(it > 10) //false
.all
如果全部的元素符合给出的判断条件，则返回true
list.all{it < 10} // true
list.all{it % 2 == 0} //false
.count
返回符合给出判断条件的元素总数
list.count{it % 2 == 0}//3
在一个初始值的基础上从第一项到最后一项通过一个函数累计所有的元素
list.fold(4){total,next -> total + next} // 25
与fold一样，但是顺序是从最后一项到第一项
list.foldRight(4){total,next->total+next}//25
遍历所有元素，并执行给定的操作
list.forEach{ println(it) }
与forEach，但是同时可以得到元素的index
list.forEachIndexed{ index,value -> println("position $index contains a $value")}
.max
返回最大的一项，如果没有则返回null
list.max() // 6
.maxBy
根据给定的函数返回最大的一项，如果没有则返回null
// The element whose negative is greater
list.maxBy{-it} // 1
.min .minBy 同max maxBy(反)
.none
如果没有任何元素与给定的函数匹配，则返回true
// No elements are divisible by 7
list.none{it % 7 == 0} //true
.reduce
与fold一样，但是没有一个初始值。通过一个函数从第一项到最后一项进行累计
list.reduce{total,next -> total+next} //21
.reduceRight 与reduce一样，但是顺序是从最后一项到第一项
.sumBy
返回所有每一项通过函数转换之后的数据的总和
list.sumBy{ it%2 } // 3
.drop
返回包含去掉前n个元素的所有元素的列表
list.drop(4) // listOf(5,6)
.dropWhile
返回根据给定函数从第一项开始去掉指定元素的列表
list.dropWhile{it<3} // listOf(3,4,5,6)
.dropLastWhile
返回根据给定函数从最后一项开始去掉指定元素的列表
list.dropLastWhile{it>4} // listOf(1,2,3,4)
.filter
过滤所有符合给定函数条件的元素
list.filter{it%2 == 0} // listOf(2,4,6)
.filterNot
过滤所有不符合给定函数条件的元素
list.filterNot{ it % 2 == 0} // listOf(1,3,5)
.filterNotNull
过滤所有元素中不是null的元素
.slice
过滤一个list中指定index的元素
list.slice(listOf(1,3,4)) // listOf(2,4,5)
.take
返回从第一个开始的n个元素
list.take(2) // listOf(1,2)
.takeLast
返回从最后一个开始的n个元素
list.takeLast(2) // listOf(5,6)
.takeWhile
返回从第一个开始符合给定函数条件的元素
list.takeWhile{ it < 3} // listOf(1,2)
.flatMap
遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中
list.flatMap{listOf(it,it+1)}// listOf(1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7)
.groupBy
返回一个根据给定函数分组后的map
list.groupBy{ if(it % 2 == 0) "even" else "odd"} // {odd=[1, 3, 5], even=[2, 4, 6]}
.map
返回一个每一个元素根据给定的函数转换所组成的list
list.map{it*2} //listOf(2,4,6,8,10,12)
.mapIndexed
返回一个每一个元素根据给定的包含元素index的函数转换所组成的list(索引值与对应值的函数关系)
list.mapIndexed{index,it->index*it}//listOf (0, 2, 6, 12, 20, 30)
.mapNotNull
返回一个每一个非null元素根据给定的函数转换所组成的list
.contains
如果指定元素可以在集合中找到，则返回true
.elementAt
返回给定index对应的元素，如果index数组越界则会抛出IndexOutOfBoundsException
.elementAtOrElse
返回给定index对应的元素，如果index数组越界则会根据给定函数返回默认值
list.elementAtOrElse(10){2*it} //20
.elementAtOrNull
返回给定index对应的元素，如果index数组越界则会返回null。
.first
返回符合给定函数条件的第一个元素
list.first{it%2 == 0} // 2
. firstOrNull
返回符合给定函数条件的第一个元素，如果没有符合则返回null。
. indexOf
返回指定元素的第一个index，如果不存在，则返回-1。
list.indexOf(4) // 3
. indexOfFirst
返回第一个符合给定函数条件的元素的index，如果没有符合则返回-1。
list.indexOfFirst { it % 2 == 0 } // 1
. indexOfLast
返回最后一个符合给定函数条件的元素index，如果没有符合则返回-1
list.indexOfLast { it % 2 == 0 } // 5
.last
返回符合给定函数条件的最后一个元素
list.last { it % 2 == 0 } // 6
. lastIndexOf
返回指定元素的最后一个index，如果不存在，则返回-1。
. lastOrNull
返回符合给定函数条件的最后一个元素，如果没有符合则返回null。
.single
返回符合给定函数的单个元素，如果没有符合或者超过一个，则抛出异常。
list.single { it % 5 == 0 } // 5
. singleOrNull
返回符合给定函数的单个元素，如果没有符合或者超过一个，则返回null。
. merge
把两个集合合并成一个新的，相同index的元素通过给定的函数进行合并成新的元素作为新的集合的一个元素，返回这个新的集合。新的集合的大小由最小的那个集合大小决定。
val list = listOf(1, 2, 3, 4, 5, 6)
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
list.merge(listRepeated) { it1, it2 -> it1 + it2 }
// 结果 listOf(3, 4, 6, 8, 10, 11)
.partition
把一个给定的集合分割成两个，第一个集合是由原集合每一项元素匹配给定函数条件返回true的元素组成，第二个集合是由原集合每一项元素匹配给定函数条件返回false的元素组成。
list.partition(it % 2 == 0) // listOf(2,4,6) listOf(1,3,5)
.plus
返回一个包含原集合和给定集合中所有元素的集合，因为函数的名字原因，我们可以使用+操作符
val list = listOf(1,2,3,4,5,6)
Timber.e("demo ${list.plus(listOf(7,8))} and ${list+ listOf(9,10)}")
.zip
返回由pair组成的list，每个pair由两个集合中相同index的元素组成。这个返回的list的大小由最小的那个集合决定
val list = listOf(1,2,3,4,5,6,7)
list.zip(listOf(7,8)) //[(1, 7), (2, 8)]
. unzip
从包含pair的List中生成包含List的Pair。
listOf(Pair(5, 7), Pair(6, 8)).unzip()// ([5, 6], [7, 8])
. reverse
返回一个与指定list相反顺序的list
.sort
返回一个自然排序后的list
.sortBy
返回一个根据指定函数排序后的list。
. sortDescending
返回一个降序排序后的List。
. sortDescendingBy
返回一个根据指定函数降序排序后的list
