1螺戳、數(shù)組類型
2、集合類型1折汞、List
2倔幼、Map
3、Set3爽待、集合操作符操作符
1凤藏、toMutableList()
2、轉(zhuǎn)換為數(shù)組
3堕伪、轉(zhuǎn)換為集合
4揖庄、操作類
5、順序操作符
6欠雌、映射操作符
7蹄梢、過濾操作符
8、生產(chǎn)操作符
9富俄、統(tǒng)計操作符
一禁炒、數(shù)組類型
幾個常用的方法：
- 用
arr[index]的獲取元素。 - 用
arr.component1() ... arr.component5()獲取數(shù)組的前5個元素霍比。同樣適用與集合幕袱。 - 用
arr.reverse()反轉(zhuǎn)元素。
fun main() {
var arr = arrayOf(1, 2, 3, 4, 5)
println(arr[0])
println(arr.component1())
println(arr.component2())
arr.reverse()
for (i in arr) {
print(i)
}
}
輸出結(jié)果:
結(jié)果圖
二悠瞬、集合類型
-
Kotlin中的集合和其他語言不同的是们豌，Kotlin集合可分為可變和不可變集合。
1浅妆、使用List<E>望迎、Set<E>、Map<K,V>聲明的時候該集合則是不可變集合
2凌外、使用MutableList<E>辩尊、MutableSet<E>、MutableMap<K,V>的時候該集合才是可變類型集合康辑。 -
在Kotlin中摄欲，集合類型包含三種類型：它們分別是：List轿亮、Set、Map,他們之間存在以下幾個異同點：
1胸墙、它們都是接口哀托，并不是實際的類。
2劳秋、它們只實現(xiàn)了isEmpty()、size胖齐、contains()等函數(shù)以及屬性玻淑。
3、List<E>和Set<E>都繼承至Collection<out E>接口,且Collection<out E>繼承于Iterable<out T>接口呀伙〔孤模 而Map<K,V>是獨立出來的一個接口。這一點和Java相同剿另。
4箫锤、這三種集合類型分別有存在MutableList<E>、MutableSet<E>雨女、MutableMap<K,V>接口谚攒，這些接口中提供了改變、操作集合的方法氛堕。例如add()馏臭、clear()、remove()等函數(shù)讼稚。
2.1 List
不可變集合:
1括儒、聲明
使用listOf(..)函數(shù)
fun main() {
var arr = arrayOf(1, 2, 3, 4, 5)
var list = listOf(1, 2, 3, 4, 5) //隨意創(chuàng)建
var list1 = listOf<String>("1", "2", "3", "4", "5") //指定原始的數(shù)值類型
var list2 = listOf(arr) //可傳入一個數(shù)組
for(value in list1){
print("$value \t")
}
}
可變集合:
1、聲明
(1) 使用mutableListOf()函數(shù)
(2) 使用arrayListOf()函數(shù)
var arr = arrayOf(1, 2, 3, 4, 5)
var list = mutableListOf(1, 2, 3, 4, 5)
var list1 = mutableListOf<String>("1", "2", "3", "4", "5")
var list2 = mutableListOf(arr)
list1.add("6")
list1.add("7")
list1.removeAt(1)
for (value in list1) {
print("$value \t")
}
var arrayListOf = arrayListOf<Int>(1, 2, 3, 4, 5)
arrayListOf.add(6)
for (value in arrayListOf) {
print("$value \t")
}
2.2 Map
可變集合:
1锐想、聲明：
mutableMapOf()函數(shù)
var mutableMapOf = mutableMapOf<String, String>("name" to "kotlin", "age" to "18")
mutableMapOf.put("sex","boy")
mutableMapOf.forEach { t, u -> println("$t"+" : "+"$u") }
var hashMapOf = hashMapOf<String, String>("a" to "A", "b" to "B") //同java的hashMap一樣
hashMapOf.put("c","C")
hashMapOf.forEach { t, u -> println("$t" + " : " + "$u") }
不可變集合:
1帮寻、聲明：
mapOf()函數(shù)
var mapOf = mapOf<Int, String>(1 to "value1", 2 to "value2")
mapOf.forEach { t, u -> println("$t" + " : " + "$u") }
注意：當我們的鍵存在重復時，集合會過濾掉之前重復的元素赠摇。
2.3 Set
可變集合:
1固逗、聲明：
setOf()函數(shù)
var setOf = setOf<String>("1", "1", "2", "3")
setOf.forEach { println(it) }
不可變集合:
1、聲明：
mutableSetOf()函數(shù)
var mutableSetOf = mutableSetOf<Int>(1, 2, 3, 4, 4, 5, 5)
mutableSetOf.add(6)
mutableSetOf.forEach { println(it) }
注意 : Set類型集合會把重復的元素去除掉藕帜。
三抒蚜、集合操作符操作符
1、toMutableList()
將List轉(zhuǎn)換成了MutableList,也成為協(xié)變,此外還有 toList()耘戚、toHashSet()嗡髓、toSet()
var listOf = listOf<String>("111", "222", "333")
var mutableList = listOf.toMutableList()
mutableList.add("444")
mutableList.forEach { println(it) }
2、轉(zhuǎn)換為數(shù)組
集合類提供了 toTypedArray 收津，把這個集合根據(jù)調(diào)用集合類相應的高階函數(shù)來轉(zhuǎn)換成相應的數(shù)組饿这。
var listOf = listOf<String>("111", "222", "333")
var toTypedArray = listOf.toTypedArray() //轉(zhuǎn)換
println(listOf.javaClass.toString()) // 打印listOf的類型
println(toTypedArray.javaClass.toString()) // 打印toTypedArray的類型
3浊伙、轉(zhuǎn)換為集合
我們聲明一個集合或者數(shù)組，可以轉(zhuǎn)換成相應類型的集合长捧。調(diào)用toXXX()轉(zhuǎn)換成不可變集合嚣鄙。調(diào)用toMutableXXX()轉(zhuǎn)換為可變集合。集合類提供了toList()串结、toMutableList()哑子、toSet()、toMutableSet()肌割、toHashSet()卧蜓、toMap()等高階函數(shù)去處理。
var arrayOf = arrayOf("111", "222", "333")
var toList = arrayOf.toList()
var toMutableList = arrayOf.toMutableList()
println("變量arrayOf的類型為：${arrayOf.javaClass}")
println("變量toList的類型為：${toList.javaClass}")
println("變量toMutableList的類型為：${toMutableList.javaClass}")
4把敞、操作類
| 名稱 | 描述 |
|---|---|
| contains(元素) | 檢查集合中是否包含指定的元素 |
| elementAt(index) | 獲取對應下標的元素 |
| first() | 獲取第一個元素弥奸，若集合為空集合，這會拋出NoSuchElementException異常 |
| last() | 同first()相反 |
| indexOf(元素) | 返回指定元素的下標奋早，若不存在盛霎，則返回-1 |
| forEach{...} | 遍歷元素。一般用作元素的打印 |
| componentX() | 這個函數(shù)在前面的章節(jié)中提過多次了耽装。用于獲取元素愤炸。其中的X只能代表1..5。 |
var arrayListOf = arrayListOf<Int>(1, 2, 3, 4, 5)
println("contains(元素) : " + arrayListOf.contains(1))
println("elementAt(index) : " + arrayListOf.elementAt(2))
println("first() : " + arrayListOf.first())
println("last() : " + arrayListOf.last())
println("indexOf() : " + arrayListOf.indexOf(5))
arrayListOf.forEach { print(it) }
println()
println("componentX() : " + arrayListOf.component4())
5掉奄、順序操作符
| 名稱 | 描述 |
|---|---|
| reversed() | 反序摇幻。即和初始化的順序反過來。 |
| sorted() | 自然升序挥萌。 |
| sortedBy{} | 根據(jù)條件升序绰姻，即把不滿足條件的放在前面，滿足條件的放在后面 |
| sortedDescending() | 自然降序。 |
| sortedByDescending{} | 根據(jù)條件降序。和sortedBy{}相反 |
var arrayListOf = arrayListOf<Int>(6, 3, 8, -1, 2, 4)
println("反轉(zhuǎn) : " + arrayListOf.reversed())
println("升序 : " + arrayListOf.sorted())
println("條件升序 : " + arrayListOf.sortedBy { it % 2 == 0 })
println("降序 : " + arrayListOf.sortedDescending())
println("條件降序 : " + arrayListOf.sortedByDescending { it % 2 == 0 })
6纽门、映射操作符
| 名稱 | 描述 |
|---|---|
| map{...} | 把每個元素按照特定的方法進行轉(zhuǎn)換，組成一個新的集合帜矾。 |
| mapIndexed{index,result} | 把每個元素按照特定的方法進行轉(zhuǎn)換，只是其可以操作元素的下標(index)屑柔，組成一個新的集合屡萤。 |
| flatMap{...} | 根據(jù)條件合并兩個集合，組成一個新的集合掸宛。 |
| groupBy{...} | 分組死陆。即根據(jù)條件把集合拆分為為一個Map<K,List<T>>類型的集合。具體看實例 |
var arrayListOf = arrayListOf<Int>(6, -3, 8, -1, 2, 4)
println("map : " + arrayListOf.map { "aa".plus(it) })
println("mapIndexed{index,result} : " + arrayListOf.mapIndexed { index, i -> index.toString()+"aa" + i })
println("flatMap : "+arrayListOf.flatMap { listOf(it,"new"+it) })
println("groupBy : "+arrayListOf.groupBy { if (it>0) "big" else "small"})
7、過濾操作符
| 名稱 | 描述 |
|---|---|
| filter{...} | 把不滿足條件的元素過濾掉 |
| filterNot{...} | 和filter{}函數(shù)的作用相反 |
| take(num) | 返回集合中前num個元素組成的集合 |
| takeWhile{...} | 循環(huán)遍歷集合措译，從第一個元素開始遍歷集合别凤，當?shù)谝粋€出現(xiàn)不滿足條件元素的時候，退出遍歷领虹。然后把滿足條件所有元素組成的集合返回规哪。 |
| takeLast(num) | 返回集合中后num個元素組成的集合 |
| takeLastWhile{...} | 循環(huán)遍歷集合，從最后一個元素開始遍歷集合塌衰，當?shù)谝粋€出現(xiàn)不滿足條件元素的時候诉稍，退出遍歷。然后把滿足條件所有元素組成的集合返回最疆。 |
| drop(num) | 過濾集合中前num個元素 |
| dropWhile{...} | 相同條件下杯巨，和執(zhí)行takeWhile{...}函數(shù)后得到的結(jié)果相反 |
| dropLast(num) | 過濾集合中后num個元素 |
| dropLastWhile{...} | 相同條件下，和執(zhí)行takeLastWhile{...}函數(shù)后得到的結(jié)果相反 |
| distinct() | 去除重復元素 |
| distinctBy{...} | 根據(jù)操作元素后的結(jié)果去除重復元素 |
| slice | 過濾掉所有不滿足執(zhí)行下標的元素肚菠。 |
var arrayListOf = arrayListOf<Int>(6, -3, 8, -1, 2, 4, 4)
println("filter{...} : " + arrayListOf.filter { it > 0 })
println("filterNot{...} : " + arrayListOf.filterNot { it > 0 })
println()
println("take(num) : " + arrayListOf.take(3))
println("takeWhile{...} : " + arrayListOf.takeWhile { it > 0 })
println("takeLast(num) : " + arrayListOf.takeLast(3))
println("takeLastWhile{...} : " + arrayListOf.takeLastWhile { it > 0 })
println()
println("drop{...} : " + arrayListOf.drop(3))
println("dropWhile{...} : " + arrayListOf.dropWhile { it > 0 })
println("dropLast{...} : " + arrayListOf.dropLast(3))
println("dropLastWhile{...} : " + arrayListOf.dropLastWhile { it > 0 })
println()
println("distinct() : " + arrayListOf.distinct())
println("distinctBy() : " + arrayListOf.distinctBy { it + 3 })
println()
println("slice ："+arrayListOf.slice(IntRange(2,6)))
8、生產(chǎn)操作符
| 名稱 | 描述 |
|---|---|
| plus() | 合并兩個集合中的元素罩缴，組成一個新的集合蚊逢。也可以使用符號+ |
| zip | 由兩個集合按照相同的下標組成一個新集合。該新集合的類型是：List<Pair> |
| unzip | 和zip的作用相反箫章。把一個類型為List<Pair>的集合拆分為兩個集合烙荷。看下面的例子 |
| partition | 判斷元素是否滿足條件把集合拆分為有兩個Pair組成的新集合檬寂。 |
var arrayListOf = arrayListOf<Int>(6, -3, 8, -1, 2, 4, 4)
var subList = arrayListOf<Int>(40, 20, 30)
val newList = listOf(Pair(1, "Kotlin"), Pair(2, "Android"), Pair(3, "Java"), Pair(4, "PHP"))
println("plus() : " + arrayListOf.plus(subList))
println("zip() : " + arrayListOf.zip(subList))
println(newList.unzip())
println("partition () : " + arrayListOf.partition { it > 0 })
9终抽、統(tǒng)計操作符
| 名稱 | 描述 |
|---|---|
| any() | 判斷是不是一個集合，若是桶至，則在判斷集合是否為空昼伴，若為空則返回false,反之返回true,若不是集合，則返回hasNext |
| any{...} | 判斷集合中是否存在滿足條件的元素镣屹。若存在則返回true,反之返回false |
| all{...} | 判斷集合中的所有元素是否都滿足條件圃郊。若是則返回true,反之則返回false |
| none() | 和any()函數(shù)的作用相反 |
| none{...} | 和all{...}函數(shù)的作用相反 |
| max() | 獲取集合中最大的元素，若為空元素集合女蜈，則返回null |
| maxBy{...} | 獲取方法處理后返回結(jié)果最大值對應那個元素的初始值持舆，如果沒有則返回null |
| min() | 獲取集合中最小的元素，若為空元素集合伪窖，則返回null |
| minBy{...} | 獲取方法處理后返回結(jié)果最小值對應那個元素的初始值逸寓，如果沒有則返回null |
| sum() } | 計算出集合元素累加的結(jié)果。 |
| sumBy{...} | 根據(jù)元素運算操作后的結(jié)果覆山，然后根據(jù)這個結(jié)果計算出累加的值竹伸。 |
| sumByDouble{...} | 和sumBy{}相似，不過sumBy{}是操作Int類型數(shù)據(jù)簇宽，而sumByDouble{}操作的是Double類型數(shù)據(jù) |
| average() | 獲取平均數(shù) |
| reduce{...} | 從集合中的第一項到最后一項的累計操作佩伤。 |
| reduceIndexed{...} | 和reduce{}作用相同聊倔，只是其可以操作元素的下標(index) |
| reduceRight{...} | 從集合中的最后一項到第一項的累計操作。 |
| reduceRightIndexed{...} | 和reduceRight{}作用相同生巡，只是其可以操作元素的下標(index) |
| fold{...} | 和reduce{}類似耙蔑，但是fold{}有一個初始值 |
| foldIndexed{...} | 和reduceIndexed{}類似，但是foldIndexed{}有一個初始值 |
| foldRight{...} | 和reduceRight{}類似孤荣，但是foldRight{}有一個初始值 |
| foldRightIndexed{...} | 和reduceRightIndexed{}類似甸陌，但是foldRightIndexed{}有一個初始值 |
var arrayListOf = arrayListOf<Int>(1, -1, 1, -1, 1, 2, 3)
println("any() : " + arrayListOf.any())
println("any{...} : " + arrayListOf.any { it > 0 })
println("all{...} : " + arrayListOf.all { it > 0 })
println()
println("none() : " + arrayListOf.none())
println("none{...} : " + arrayListOf.none { it > 0 })
println()
println("max() : " + arrayListOf.max())
println("maxBy{...} : " + arrayListOf.maxBy { it % 3 })
println()
println("min() : " + arrayListOf.min())
println("minBy{...} : " + arrayListOf.minBy { it % 2 })
println()
println("sum() : " + arrayListOf.sum())
println("sumBy() : " + arrayListOf.sumBy { it + 2 })
println()
println("average() : " + arrayListOf.average())
println()
println("reduce{...} : " + arrayListOf.reduce { acc, i -> acc + i })// acc 是 1,2,3,4,5 i是 和 i+=acc
println("reduceIndexed{...} : " + arrayListOf.reduceIndexed { index, acc, i -> index + acc + i }) //index是下表 0+1+2+3+4+i(i+=acc)
println("reduceRight{...} : " + arrayListOf.reduceRight { acc, i -> acc + i })
println("reduceRightIndexed{...} : " + arrayListOf.reduceRightIndexed { index, acc, i -> index + acc + i })
println()
println("fold{...} : " + arrayListOf.fold(1) { result, next -> result + next })
println("foldIndexed{...} : " + arrayListOf.foldIndexed(1) { index, result, next -> index + result + next })
println("reduce{...} : " + arrayListOf.foldRight(1) { result, next -> result + next })
println("foldRightIndexed{...} : " + arrayListOf.foldRightIndexed(1) { index, result, next -> index + result + next })
我尼瑪.好多函數(shù),咋記得過來.
