val listIntTotal = listOf(1, 2, 3, 4, 5, 6)
val listStrTotal = listOf("yes", "no", "sure")
fun main(args: Array<String>) {
//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 返回符合給出判斷條件的元素總數(shù)
println(listIntTotal.count { it % 2 == 0 })//3
println("--------------count-------------------------------")
//4.fold 在一個初始值的基礎(chǔ)上從第一項到最后一項通過一個函數(shù)累計所有的元素
//其實(shí)fold 就是折疊的意思懦窘，把一個集合的元素折疊起來的并得到一個最終的結(jié)果
//從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 轉(zhuǎn)換為字符串
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 一樣，但是沒有一個初始值蛇数。通過一個函數(shù)從第一項到最后一項進(jìn)行累計
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 如果沒有任何元素與給定的函數(shù)匹配耳舅，則返回true碌上。
println(listIntTotal.none())//false
println("--------------none-------------------------------")
println(listIntTotal.none { it % 3 == 0 })//false
println("--------------none-------------------------------")
//11.sumBy 返回所有每一項通過函數(shù)轉(zhuǎn)換之后的數(shù)據(jù)的總和
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<String>) {
//1.drop 返回包含去掉前n個元素的所有元素的列表
(listIntFilter.drop(3)).forEach { println(it) }//4,5,6
println("--------------drop -------------------------------")
//2.filter 過濾所有符合給定函數(shù)條件的元素
(listIntFilter.filter { it % 2 == 0 }).forEach { println(it) }//2,4,6
println("--------------filter -------------------------------")
//3.filterNot 過濾所有不符合給定函數(shù)條件的元素
(listIntFilter.filterNot { it % 2 == 0 }).forEach { println(it) }//1,3,5
println("--------------filterNot -------------------------------")
//4.slice 過濾掉非指定下標(biāo)的元素，即保留下標(biāo)對應(yīng)的元素過濾List中指定下標(biāo)的元素（比如這里只保留下標(biāo)為1浦徊，3馏予，4的元素），當(dāng)過濾list中有元素值大于目標(biāo)List大小時會出現(xiàn)異常
(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 返回從第一個開始符合給定函數(shù)條件的元素
(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<String>) {
//1.flatMap 遍歷所有的元素盔性，為每一個創(chuàng)建一個集合霞丧，最后把所有的集合放在一個集合中
(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 返回一個根據(jù)給定函數(shù)分組后的map
(listIntMap.groupBy { if (it > 4) "大于4" else "小于4" }).forEach { t, u -> println("$t $u") }
println("--------------groupBy -------------------------------")
//3.map 返回一個每一個元素根據(jù)給定的函數(shù)轉(zhuǎn)換所組成的List
(listIntMap.map { it * 2 }).forEach { println(it) }
println("--------------map -------------------------------")
//4.mapIndexed 返回一個每一個元素根據(jù)給定的包含元素index的函數(shù)轉(zhuǎn)換所組成的List
listIntMap.mapIndexed { index, i -> println("$index $i") }
println("--------------mapIndexed -------------------------------")
}
val listIntElement = listOf(1, 2, 3, 4, 5, 6)
fun main(args: Array<String>) {
//1.contains 如果指定元素可以在集合中找到，則返回true
println(listIntElement.contains(3))//true
println("--------------contains -------------------------------")
//2.elementAt 返回給定index對應(yīng)的元素纯出，如果index數(shù)組越界則會拋出 IndexOutOfBoundsException
println(listIntElement.elementAt(2))//3
println("--------------elementAt -------------------------------")
//3.elementAtOrElse 返回給定index對應(yīng)的元素蚯妇，如果index數(shù)組越界則會根據(jù)給定函數(shù)返回默認(rèn)值
println(listIntElement.elementAtOrElse(3, { "沒有哦" }))//4
println(listIntElement.elementAtOrElse(8, { "沒有哦" }))//沒有哦
println("--------------elementAtOrElse -------------------------------")
//4.first 返回符合給定函數(shù)條件的第一個元素
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 返回第一個符合給定函數(shù)條件的元素的index，如果沒有符合則返回 -1
println(listIntElement.indexOfFirst{ it % 3 == 0 })//2
println("--------------indexOfFirst -------------------------------")
//同理還有indexOfLast硬贯，表示返回最后一個符合給定函數(shù)條件的元素的index焕襟，如果沒有符合則返回 -1
println(listIntElement.indexOfLast{ it % 3 == 0 })//5
println("--------------indexOfLast -------------------------------")
//7.last 返回符合給定函數(shù)條件的最后一個元素
println(listIntElement.last())//6
println("--------------last -------------------------------")
//8.lastIndexOf 返回指定元素的最后一個index，如果不存在饭豹，則返回 -1
println(listIntElement.lastIndexOf(2))//1 如果list為(1, 2, 3, 4, 2, 5, 6)則結(jié)果為4
println("--------------lastIndexOf -------------------------------")
}
val listIntProduct1 = listOf(1, 2, 3, 4, 5, 6)
val listIntProduct2 = listOf(3, 5, 7, 9)
fun main(args: Array<String>) {
//1.partition 把一個給定的集合分割成兩個鸵赖，第一個集合是由原集合每一項元素匹配給定函數(shù)條件返回 true 的元素組成，第二個集合是由原集合每一項元素匹配給定函數(shù)條件返回 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 兩個集合按照下標(biāo)組合成一個個的Pair塞到集合中返回
println(listIntProduct1.zip(listIntProduct2))//[1, 2, 3, 4, 5, 6, 3, 5, 7, 9]
println("--------------zip -------------------------------")
//merge的替代方法它褪，把兩個集合，按照相同下標(biāo)翘悉，合成新的元素茫打，合成的集合大小由最小的集合決定
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<String>) {
//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 返回一個根據(jù)指定函數(shù)排序后的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 返回一個根據(jù)指定函數(shù)降序排序后的list
println(listIntOrder1.sortedByDescending { it % 2 })//[1, 3, 5, 2, 4, 6]
println("--------------sortedByDescending-------------------------------")
}
