val listIntTotal = listOf(1, 2, 3, 4, 5, 6)
val listStrTotal = listOf("yes", "no", "sure")
fun main(args: Array) {
//1.any 如果至少有一个元素符合给出的判断条件，则返回true
println(listIntTotal.any { it % 2 == 0 })//true
println("--------------any1 -------------------------------")
println(listIntTotal.any { it > 10 })//false
println("--------------any2 -------------------------------")
//2.all 如果全部的元素符合给出的判断条件，则返回true
println(listIntTotal.all { it < 10 })//true
println("--------------all1 -------------------------------")
println(listIntTotal.all { it % 2 == 0 })//false
println("--------------all2 -------------------------------")
//3.count 返回符合给出判断条件的元素总数
println(listIntTotal.count { it % 2 == 0 })//3
println("--------------count-------------------------------")
//4.fold 在一个初始值的基础上从第一项到最后一项通过一个函数累计所有的元素
//其实fold 就是折叠的意思，把一个集合的元素折叠起来的并得到一个最终的结果
//从4开始，1+4,2+5,3+7,4+10,5+14,6+19=25
println(listIntTotal.fold(4) { total, next -> total + next })//25
println("--------------fold1-------------------------------")
//将int 转换为字符串
val r1 = listIntTotal.fold(StringBuilder()) {
strBuilder, it ->
strBuilder.append(it).append(",")
}
println(r1.toString() is String)
println("--------------fold2-------------------------------")
//5.foldRight 与 fold 一样，但是顺序是从最后一项到第一项
//从4开始，4+6,10+5,15+4，19+3,22+2，24+1=25
println(listIntTotal.foldRight(4) { total, next -> total + next })//25
println("--------------foldRight-------------------------------")
//6.reduce 与 fold 一样，但是没有一个初始值。通过一个函数从第一项到最后一项进行累计
println(factorial(5))//120
println("--------------factorial-------------------------------")
println(listIntTotal.reduce { total, next -> total + next })//21
println("--------------reduce-------------------------------")
println(listIntTotal.reduceRight { i, acc -> i + acc })//21
println("--------------reduceRight-------------------------------")
//7.forEach
listStrTotal.forEach { println(it) }
println("--------------forEach-------------------------------")
//与forEach类似 但是我们同时可以得到元素的index
listStrTotal.forEachIndexed { index, s -> println("$index $s") }
println("--------------forEachIndexed-------------------------------")
listStrTotal.forEachWithIndex { i, s -> println("$i $s") }
println("--------------forEachWithIndex-------------------------------")
listStrTotal.forEachReversedWithIndex { i, s -> println("$i $s") }
println("--------------forEachReversedWithIndex-------------------------------")
listStrTotal.forEachReversed { println(it) }
println("--------------forEachReversed-------------------------------")
listStrTotal.forEachByIndex { println(it) }
println("--------------forEachByIndex-------------------------------")
//8.max 返回最大的一项，如果没有则返回null
println(listIntTotal.max())
println("--------------max-------------------------------")
println(listIntTotal.maxBy { -(4 - it * 8) })
println("--------------maxBy-------------------------------")
//9.min 返回最小的一项，如果没有则返回null
println(listIntTotal.min())
println("--------------min-------------------------------")
println(listIntTotal.minBy { -(4 - it * 8) })
println("--------------minBy-------------------------------")
//10.none 如果没有任何元素与给定的函数匹配，则返回true。
println(listIntTotal.none())//false
println("--------------none-------------------------------")
println(listIntTotal.none { it % 3 == 0 })//false
println("--------------none-------------------------------")
//11.sumBy 返回所有每一项通过函数转换之后的数据的总和
println(listIntTotal.sumBy { it % 2 })//3
println("--------------sumBy-------------------------------")
}
//阶乘
fun factorial(n: Int): Int {
if (n == 0) return 1
return (1..n).reduce { factorial, element -> factorial * element }
}
val listIntFilter = listOf(1, 2, 3, 4, 5, 6)
fun main(args: Array) {
//1.drop 返回包含去掉前n个元素的所有元素的列表
(listIntFilter.drop(3)).forEach { println(it) }//4,5,6
println("--------------drop -------------------------------")
//2.filter 过滤所有符合给定函数条件的元素
(listIntFilter.filter { it % 2 == 0 }).forEach { println(it) }//2,4,6
println("--------------filter -------------------------------")
//3.filterNot 过滤所有不符合给定函数条件的元素
(listIntFilter.filterNot { it % 2 == 0 }).forEach { println(it) }//1,3,5
println("--------------filterNot -------------------------------")
//4.slice 过滤掉非指定下标的元素，即保留下标对应的元素过滤List中指定下标的元素（比如这里只保留下标为1，3，4的元素），当过滤list中有元素值大于目标List大小时会出现异常
(listIntFilter.slice(listOf(1, 4)).forEach { println(it) })//2,5
println("--------------slice -------------------------------")
//5.take 返回从第一个开始的n个元素
(listIntFilter.take(3)).forEach { println(it) }//1,2,3
println("--------------take -------------------------------")
//6.takeLast 返回从最后一个开始的n个元素
(listIntFilter.takeLast(3)).forEach { println(it) }//4,5,6
println("--------------takeLast -------------------------------")
//7.takeWhile 返回从第一个开始符合给定函数条件的元素
(listIntFilter.takeWhile { it < 3 }).forEach { println(it) }//1,2
println("--------------takeWhile -------------------------------")
}
val listIntMap = listOf(1, 2, 3, 4, 5, 6)
val listStrMap = listOf("y,s", "n,o", "su,e")
fun main(args: Array) {
//1.flatMap 遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中
(listStrMap.flatMap { it.split(",") }).forEach { print(it) }
(listStrMap.flatMap { it.split(",") }).map { println(it) }
val list = listOf(
1..20,
2..5
)
(list.flatMap { it }).forEach { println(it) }
(list.flatMap { it.map { it * 2 } }).forEach { println(it) }
println("--------------flatMap -------------------------------")
//2.groupBy 返回一个根据给定函数分组后的map
(listIntMap.groupBy { if (it > 4) "大于4" else "小于4" }).forEach { t, u -> println("$t $u") }
println("--------------groupBy -------------------------------")
//3.map 返回一个每一个元素根据给定的函数转换所组成的List
(listIntMap.map { it * 2 }).forEach { println(it) }
println("--------------map -------------------------------")
//4.mapIndexed 返回一个每一个元素根据给定的包含元素index的函数转换所组成的List
listIntMap.mapIndexed { index, i -> println("$index $i") }
println("--------------mapIndexed -------------------------------")
}
val listIntElement = listOf(1, 2, 3, 4, 5, 6)
fun main(args: Array) {
//1.contains 如果指定元素可以在集合中找到，则返回true
println(listIntElement.contains(3))//true
println("--------------contains -------------------------------")
//2.elementAt 返回给定index对应的元素，如果index数组越界则会抛出 IndexOutOfBoundsException
println(listIntElement.elementAt(2))//3
println("--------------elementAt -------------------------------")
//3.elementAtOrElse 返回给定index对应的元素，如果index数组越界则会根据给定函数返回默认值
println(listIntElement.elementAtOrElse(3, { "没有哦" }))//4
println(listIntElement.elementAtOrElse(8, { "没有哦" }))//没有哦
println("--------------elementAtOrElse -------------------------------")
//4.first 返回符合给定函数条件的第一个元素
println(listIntElement.first())//1
println(listIntElement.first{ it % 3 == 0 })//3
println("--------------first -------------------------------")
//5.indexOf 返回指定元素的第一个index，如果不存在，则返回 -1
println(listIntElement.indexOf(3))//2
println(listIntElement.indexOf(8))//-1
println("--------------indexOf -------------------------------")
//6.indexOfFirst 返回第一个符合给定函数条件的元素的index，如果没有符合则返回 -1
println(listIntElement.indexOfFirst{ it % 3 == 0 })//2
println("--------------indexOfFirst -------------------------------")
//同理还有indexOfLast，表示返回最后一个符合给定函数条件的元素的index，如果没有符合则返回 -1
println(listIntElement.indexOfLast{ it % 3 == 0 })//5
println("--------------indexOfLast -------------------------------")
//7.last 返回符合给定函数条件的最后一个元素
println(listIntElement.last())//6
println("--------------last -------------------------------")
//8.lastIndexOf 返回指定元素的最后一个index，如果不存在，则返回 -1
println(listIntElement.lastIndexOf(2))//1 如果list为(1, 2, 3, 4, 2, 5, 6)则结果为4
println("--------------lastIndexOf -------------------------------")
}
val listIntProduct1 = listOf(1, 2, 3, 4, 5, 6)
val listIntProduct2 = listOf(3, 5, 7, 9)
fun main(args: Array) {
//1.partition 把一个给定的集合分割成两个，第一个集合是由原集合每一项元素匹配给定函数条件返回 true 的元素组成，第二个集合是由原集合每一项元素匹配给定函数条件返回 false 的元素组成
println(listIntProduct1.partition { it > 3 })//([4, 5, 6], [1, 2, 3])
println("--------------partition -------------------------------")
//2.plus 合并两个List，可以用”+”替代
println(listIntProduct1.plus(listIntProduct2))//[1, 2, 3, 4, 5, 6, 3, 5, 7, 9]
println("--------------plus -------------------------------")
//3.zip 两个集合按照下标组合成一个个的Pair塞到集合中返回
println(listIntProduct1.zip(listIntProduct2))//[1, 2, 3, 4, 5, 6, 3, 5, 7, 9]
println("--------------zip -------------------------------")
//merge的替代方法，把两个集合，按照相同下标，合成新的元素，合成的集合大小由最小的集合决定
println(listIntProduct1.zip(listIntProduct2) { it1, it2 -> it1 + it2 })//[4, 7, 10, 13]
println("--------------zip 替代 merge-------------------------------")
}
val listIntOrder1 = listOf(1, 2, 3, 4, 5, 6)
val listIntOrder2 = listOf(5, 2, 4, 8, 1, 6)
fun main(args: Array) {
//1.reverse 返回一个与指定list相反顺序的list
println(listIntOrder1.reversed())//[6, 5, 4, 3, 2, 1]
println("--------------reversed-------------------------------")
//2.sorted 返回一个自然排序后的list
println(listIntOrder2.sorted())//[1, 2, 4, 5, 6, 8]
println("--------------sorted-------------------------------")
//3.sortedBy 返回一个根据指定函数排序后的list
println(listIntOrder1.sortedBy { it * 2 })//[1, 2, 4, 5, 6, 8]
println("--------------sortedBy-------------------------------")
//4.sortDescending 返回一个降序排序后的List
println(listIntOrder1.sortedDescending())//[6, 5, 4, 3, 2, 1]
println("--------------sortedDescending-------------------------------")
//5.sortDescendingBy 返回一个根据指定函数降序排序后的list
println(listIntOrder1.sortedByDescending { it % 2 })//[1, 3, 5, 2, 4, 6]
println("--------------sortedByDescending-------------------------------")
}
