數組
val arrayOf = arrayOf(1, 2, 3)//[1,2,3]
val arrayOfNulls = arrayOfNulls<String>(5)//創(chuàng)建一個大小5，元素都為空的數組
val array = Array(5, { i -> i * 2 })
//最后一個參數是Lambda表達式時可以移出去
val array1 = Array(5) { i -> i * 2 }
原生類型數組
Kotlin 也有無裝箱開銷的專門的類來表示原生類型數組: ByteArray粟害、 ShortArray悲幅、IntArray 等等
// 大小為 5、值為 [0, 0, 0, 0, 0] 的整型數組
val arr = IntArray(5)
// 例如：用常量初始化數組中的值
// 大小為 5汰具、值為 [42, 42, 42, 42, 42] 的整型數組
val arr = IntArray(5) { 42 }
// 例如：使用 lambda 表達式初始化數組中的值
// 大小為 5留荔、值為 [0, 1, 2, 3, 4] 的整型數組（值初始化為其索引值）
var arr = IntArray(5) { it * 1 }
集合
Kotlin 標準庫提供了基本集合類型的實現： set、list 以及 map
- List 是一個有序集合聚蝶，可通過索引（反映元素位置的整數）訪問元素。元素可以在 list 中出現多次稚失。列表的一個示例是一句話：有一組字恰聘、這些字的順序很重要并且字可以重復吸占。
- Set 是唯一元素的集合凿宾。它反映了集合（set）的數學抽象：一組無重復的對象。一般來說 set 中元素的順序并不重要件蚕。例如产禾，字母表是字母的集合（set）。
- Map 是一組鍵值對妄痪。鍵是唯一的楞件，每個鍵都剛好映射到一個值。值可以重復罪针。map 對于存儲對象之間的邏輯連接非常有用黄伊，例如，員工的 ID 與員工的位置。
接口圖
List
由于List是一個接口憋活，所以只能用kotlin提供的標準庫函數創(chuàng)建list
//1.不可變 list
val a = listOf(1, 2, 3, "4")
val b = listOf<Int>(1, 2, 3, 4)
val array = arrayOf(1, 2, 3)
val c = listOf(array)
//2.不為空 list
val d = listOfNotNull(1, null, 3)//會自動去掉傳入的null
println(d.size)
d.forEach(::print)
//3.可變 list
val aa = mutableListOf(1, 2, 3)
aa.add(4)
aa.forEach { println(it) }
//4
val d = arrayListOf(1, 2, 3)
Set
//1.不可變set
val a = setOf(1, 2, 3, 1, 2, 4)
a.forEach(::print)
println()
//2.可變set
val b = mutableSetOf("a", "b", "c")
b.forEach(::print)
println()
b.add("d")
b.forEach(::print)
println()
b.first()//可變set實現默認為 LinkHashSet
//3.HashSet
val c = hashSetOf(1, 2, 3)
//4.LinkedHashSet
val linkedSetOf = linkedSetOf(1, 2, 3)
//5.TreeSet
val e = sortedSetOf(5, 1, 8, 3)
e.forEach(::print)
Map
//1.不可變map
val a = mapOf(1 to "a", 2 to "b", 3 to "c")
//2.可變map
val b = mutableMapOf("a" to 1, "b" to 2)
b.put("c", 3)
b["c"] = 3
//3.HashMap
val c = hashSetOf(1 to "a", 2 to "b", 3 to "c")
//4.LinkedHashMap
val d = linkedMapOf(1 to "a", 2 to "b", 3 to "c")
//5.TreeMap
val e = sortedMapOf(2 to "b", 1 to "a", 3 to "c")
e.forEach(::println)
集合轉換
映射
val a = listOf(1, 2, 3)
val b = a.map { it * 3 }
b.forEach(::print)
println()
//轉換的過程中產生了null,mapNotNull可以過濾掉
val c = listOf(1, 2, 3)
val mapNotNull = c.mapNotNull {
if (2 == it) null else it
}
mapNotNull.forEach(::print)
println()
val d = mapOf(1 to "a", 2 to "b", 3 to "c")
val mapKeys = d.mapKeys { it.key + 1 }//value不變悦即，key變成對應值
mapKeys.forEach(::print)
println()
val mapValues = d.mapValues { it.value.toUpperCase() }//key不變橱乱，value變成對應值
mapValues.forEach(::print)
println()
合并
val colors = listOf("red", "brown", "grey")
val animals = listOf("fox", "bear", "wolf")
println(colors.zip(animals))
val twoAnimals = listOf("fox", "bear")
println(colors zip twoAnimals)
val a = listOf(1 to "a", 2 to "b", 3 to "c")
val unzip = a.unzip()
println(unzip)
關聯(lián)
//以原集合作為 鍵，創(chuàng)建一個相關聯(lián)的Map
val a = listOf("one", "two", "three", "four")
val associateWith = a.associateWith { it.length }
println(associateWith)
//以原集合作為 值作瞄，創(chuàng)建一個相關聯(lián)的Map
val b = listOf("one", "two", "three", "four")
val associateBy = b.associateBy { b.indexOf(it) }
println(associateBy)
//Map 鍵和值都是通過集合元素生成的
val aa = listOf("1 a", "2 b", "3 c")
val associate = aa.associate {
val split = it.split(" ")
split[0] to split[1]
}
println(associate)
字符串表示
val numbers = listOf("1", "2", "3", "4", "5", "6", "7", "8")
println(numbers)
println(numbers.joinToString())
println(
numbers.joinToString(
separator = " ; ",
prefix = "{",
postfix = "}",
limit = 5,
truncated = "..."
)
)
println(numbers.joinToString(
separator = " ; ",
prefix = "{",
postfix = "}"
) {
"${it}_${it}"
})
//joinTo返回 Appendable對象
val listString = StringBuffer("The list of numbers: ")
val joinTo = numbers.joinTo(listString)
joinTo.append("...")
println(listString)
過濾
過濾
對于 List 和 Set危纫，過濾結果都是一個 List，對 Map 來說結果還是一個 Map
val aa = listOf(1, 2, 3, 4, 5, 6)
val filter = aa.filter { it > 3 }
println(filter)
val bb = mapOf("100" to 1, "101" to 2, "200" to 3, "201" to 4)
val filteredMap = bb.filter {
it.key.startsWith("1") && it.value < 3
}
println(filteredMap)
//考慮元素在集合中位置中的過濾
val numbers = listOf("one", "two", "three", "four")
val filterIndexed = numbers.filterIndexed { index, s ->
index > 1 && s.length > 4
}
println(filterIndexed)
//過濾某類的實例對象
val cc = listOf(1, "2", 3, null, "5")
val filterIsInstance = cc.filterIsInstance<String>()
println(filterIsInstance)
//過濾非空
val dd = listOf(1, 3, null)
val filterNotNull = dd.filterNotNull()
println(filterNotNull)
+/-操作符
- +的結果包含原始集合 和 第二個操作數中的元素瞒大。
- -的結果包含原始集合中的元素搪桂，但第二個操作數中的元素 除外。 如果第二個操作數是一個元素踢械，那么 minus 移除其在原始集合中的 第一次 出現；如果是一個集合顾瞻，那么移除其元素在原始集合中的 所有 出現
val numbers = listOf("one", "two", "three", "four")
val plusList = numbers + "five"
val minusList = numbers - listOf("three", "four")
println(plusList)
println(minusList)
分組
val numbers = listOf("one", "two", "three", "four", "five")
//返回一個Map,Map的key是 lambda 的結果, value是List, 對應的值是返回此結果key的元素
println(numbers.groupBy { it.first().toUpperCase() })
//返回一個Map,Map的key是keySelector的結果, value是List, 對應的值是返回此結果key的元素 通過valueTransform轉換的結果
println(numbers.groupBy(keySelector = { it.first() }, valueTransform = { it + "66" }))
//獲取一個 Grouping,用于后續(xù)的 對所有分組進行的操作德绿，比如 fold reduce操作
val grouping = numbers.groupingBy { it.first() }
//eachCount
println(grouping.eachCount())
//fold,有初始值累積
val fold = grouping.fold("aaa") { sum, it ->
"$sum-$it"
}
println(fold)
//reduce, 無初始值累積
val reduce = grouping.reduce { key, sum, it ->
"$sum-$it-$key"
}
println(reduce)
取一部分
val numbers = listOf("one", "two", "three", "four", "five", "six")
//取指定索引
println(numbers.slice(1..3))
println(numbers.slice(0..4 step 2))
println(numbers.slice(setOf(3, 5, 0)))
//從頭開始取3個
println(numbers.take(3))
//從尾取三個
println(numbers.takeLast(3))
//從頭丟棄一個
println(numbers.drop(1))
//從尾丟棄5個
println(numbers.dropLast(5))
//分塊
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.chunked(3))
取單個元素
val numbers = linkedSetOf("one", "two", "three", "four", "five")
println(numbers.elementAt(0))
//第一個
numbers.first()
//最后一個
numbers.last()
//滿足條件的第一個
numbers.first { it.startsWith("th") }
//避免超出索引范圍導致異常
println(numbers.elementAtOrNull(5))
//索引超出范圍移稳，可以返回一個lambda表達式結果
println(numbers.elementAtOrElse(5) { "the index of $it is null" })
//隨機取
val numbers = listOf(1, 2, 3, 4)
println(numbers.random())
//是否包含
println(numbers.contains("one"))
//可以使用 in 關鍵字以操作符的形式調用 contains()
println("one" in numbers)
