在kotlin中數組和list的操做符基本共同，因此在數組中可用的操做符也能夠在list中使用。數組
統計操做符
- any 只要有一個符合就返回true
- all 全部條件符合才返回true
- count 返回符合條件的數目
- none 若是沒有任何元素與給定的函數匹配，則返回true
- max 返回最大值
- min 返回最小值
- fold 在一個初始值的基礎上 從第一項到最後一項經過 一個函數操做 全部的元素
- reduce 從第一項到最後一項經過 一個函數操做 全部的元素，相對於fold，沒有初始值
- sum 求數組中全部值的和
val array = arrayOf(1, 2, 3, 4, 5, 6, 7)
println("any,數組中有值等於7，${array.any { it == 7 }}")
println("all,數組中是否全部值都大於3，${array.all { it > 3 }}")
println("count,數組中大於5的值有幾個，${array.count { it > 5 }}")
println("none,數組中沒有大於9的數，${array.none { it > 9 }}")
println("max,數組中的最大值，${array.max()}")
println("min,數組中的最小值，${array.min()}")
println("fold操做符的例子，${array.fold(4) { returnValue, next -> returnValue + next }}")
//相對於fold操做符，至關於返回值的初始值爲0
println("reduce操做符的例子，${array.reduce { returnValue, next -> returnValue + next }}")
println("sum,求數組中全部值的總和(也能夠用 fold和reduce操做實現)，${array.sum()}")
any,數組中有值等於7，true all,數組中是否全部值都大於3，false count,數組中大於5的值有幾個，2 none,數組中沒有大於9的數，true max,數組中的最大值，7 min,數組中的最小值，1 fold操做符的例子，32 reduce操做符的例子，28 sum,求數組中全部值的總和(也能夠用 fold和reduce操做實現)，28app
元素操做符
- contains,數組中是否包含某個元素
- first,返回第一個知足給定條件的元素
- last,返回最後一個知足給定條件的元素
- indexOf,返回某個值在數組中的下標值
- elementAt,返回數組中某個下標的值
- single,返回數組中的知足條件的一個元素，若是沒有或者知足條件的有多個就拋出異常
println("* contains,數組中是否包含值爲5的元素，${array.contains(5)}")
println("* first,返回第一個知足給定條件的元素,大於3的條件，${array.first { it > 3 }}")
println("* last,返回最後一個知足給定條件的元素，大於5的條件，${array.last { it > 5 }}")
println("* indexOf,返回值爲3在數組中的下標值，${array.indexOf(3)}")
println("* elementAt,返回數組中下標爲2的值，${array.elementAt(2)}")
println("* single,返回數組中的知足條件的一個元素，若是沒有或者知足條件的有多個就拋出異常，${array.single{it >6}}")
contains,數組中是否包含值爲5的元素，true first,返回第一個知足給定條件的元素,大於3的條件，4 last,返回最後一個知足給定條件的元素，大於5的條件，7 indexOf,返回值爲3在數組中的下標值，2 elementAt,返回數組中下標爲2的值，3 single,返回數組中的知足條件的一個元素，若是沒有或者知足條件的有多個就拋出異常，7dom
順序操做符
- reversed，返回一個具備相反順序的數組
- sorted，返回一個升序的排序的數組
- sortedDescending，返回一個降序排序的數組
- sortedBy，根據指定的值進行升序排序
- sortedByDescending，根據指定的值進行降序排序
fun <T> Array<T>.toString1(): String {
val sb = StringBuilder("[")
for ((index, value) in this.withIndex()) {
sb.append(value)
sb.append(",")
}
sb.delete(sb.length - 1, sb.length)
sb.append("]")
return sb.toString()
}
data class Person(val age: Int, val weight: Int){
override fun toString(): String {
return "{$age,$weight}"
}
}
fun main() {
val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
println("reversed，返回一個具備相反順序的數組${array.reversed()}")
println("sorted，返回一個升序的排序的數組，${array.sorted()}")
println("sortedDescending，返回一個降序排序的數組${array.sortDescending()}")
val persons = arrayOf(Person(18, 45), Person(16, 50), Person(22, 48))
persons.sortBy { it.age }
println("sortedBy，根據指定的值進行升序排序，${persons.toString1()}")
persons.sortByDescending { it.weight }
println("sortedByDescending，根據指定的值進行降序排序，${persons.toString1()}")
}
reversed，返回一個具備相反順序的數組[7, 6, 3, 4, 5, 2, 1] sorted，返回一個升序的排序的數組，[1, 2, 3, 4, 5, 6, 7] sortedDescending，返回一個降序排序的數組kotlin.Unit sortedBy，根據指定的值進行升序排序，[{16,50},{18,45},{22,48}] sortedByDescending，根據指定的值進行降序排序，[{16,50},{22,48},{18,45}]ide
映射操做符
- map，返回一個列表，其中包含將給定 函數 應用於原始數組中每一個元素的結果.
- flatMap，返回在原始數組的每一個元素上調用 函數 的結果，所產生的全部元素的單個列表。（flatMap的傳入函數的返回必須是可迭代的 Iterable），flatMap的主要主要就是把多層的集合平鋪成一層的。
- flatten，返回給定集合中全部集合的全部元素的單個列表，至關於flatmap中的函數不對元素進行任何操做
- groupBy 按照給定的元素進行分組，返回的是一個map
val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
println("map1: ${array.map { it % 2 == 0 }}")
println("map2: ${array.map { it + 3 }}")
val array1 = mutableListOf(mutableListOf(1, 5, 9),mutableListOf(11, 40, 21), mutableListOf(3, 15, 10), mutableListOf(6, 8, 10))
println("array1 = $array1")
//平鋪array1中的數據 並過濾掉 大於等於10的數據
println("flatMap: ${array1.flatMap { it -> it.filter { it < 10 } }}")
println("flatten: ${array1.flatten()}")
val persons = arrayOf(Person(16,45,"小紅"),Person(16,50,"小綠"),Person(18,45,"小紫"),Person(18,50,"小藍"))
println("groupBy_age: ${persons.groupBy{it.age}}")
println("groupBy_weight: ${persons.groupBy{it.weight}}")
//經過應用到元素*的給定[keySelector]函數返回的鍵，將應用於原始數組*的[valueTransform]函數返回的值分組，
// 並返回一個映射，其中每一個組鍵與對應值列表相關聯。 * *返回的映射保留了從原始數組產生的鍵的條目迭代順序。
println("groupBy 按年齡分組，並修改年齡分組中的實體類 == ${persons.groupBy({it.age}){Student(it.age,it.weight,(9..12).random(),it.name)}}")
map1: [false, true, false, true, false, true, false] map2: [4, 5, 8, 7, 6, 9, 10] array1 = [[1, 5, 9], [11, 40, 21], [3, 15, 10], [6, 8, 10]] flatMap: [1, 5, 9, 3, 6, 8] flatten: [1, 5, 9, 11, 40, 21, 3, 15, 10, 6, 8, 10] groupBy_age: {16=[{16,45,小紅}, {16,50,小綠}], 18=[{18,45,小紫}, {18,50,小藍}]} groupBy_weight: {45=[{16,45,小紅}, {18,45,小紫}], 50=[{16,50,小綠}, {18,50,小藍}]} groupBy 按年齡分組，並修改年齡分組中的實體類 == {16=[{學生:小紅,年級:9,年齡:16,體重:45}, {學生:小綠,年級:9,年齡:16,體重:50}], 18=[{學生:小紫,年級:11,年齡:18,體重:45}, {學生:小藍,年級:12,年齡:18,體重:50}]}函數
過濾操做符
- filter，返回數組中符合給定條件的元素列表
- take，返回包含前[n]個元素的列表，（入參就是n值）
- drop，返回包含除前[n]個元素外的全部元素的列表
val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
println("filter：${array.filter { it < 5 }}")
println("take：${array.take(4)}")
println("drop：${array.drop(4)}")
filter：[1, 2, 4, 3] take：[1, 2, 5, 4] drop：[3, 6, 7]ui
生成操做符
- zip，將兩個數組進行和並，返回一個Pair的list ，pair中包含有兩個數組中相同下標的元素，返回的list的長度，由最短的數組決定。（也能夠自定義返回列表中的類型）
- partition，返回一個Pair 其中包含兩個列表，第一個列表時符合給定條件的列表，第二個列表時不合符條件的列表。（相似於filter ，只是把過來後的元素組成了一個列表一塊兒返回了）
- plus，返回一個在原數組的基礎上，追加了一個新元素的新數組。原數組沒有改變
data class Person(val age: Int, val name: String) {
override fun toString(): String {
return "{$age,$name}"
}
}
fun <T> Array<T>.toString1(): String {
val sb = StringBuilder("[")
for ((index, value) in this.withIndex()) {
sb.append(value)
sb.append(",")
}
sb.delete(sb.length - 1, sb.length)
sb.append("]")
return sb.toString()
}
fun main() {
val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
val array1 = arrayOf("今天", "明天", "後天", "每天都愛你")
println("zip1：${array.zip(array1)}")
println("zip2：${array.zip(array1) { a, b -> Person(a,b) }}")
println("partition：${array.partition { it < 5 }}")
println("plus：${array.plus(19).toString1()}")
println("array：${array.toString1()}")
}
zip1：[(1, 今天), (2, 明天), (5, 後天), (4, 每天都愛你)] zip2：[person={1,今天}, person={2,明天}, person={5,後天}, person={4,每天都愛你}] partition：([1, 2, 4, 3], [5, 6, 7]) plus：[1,2,5,4,3,6,7,19] array：[1,2,5,4,3,6,7]this