数组
val arrayOf = arrayOf(1, 2, 3)//[1,2,3]
val arrayOfNulls = arrayOfNulls<String>(5)//创建一个大小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提供的标准库函数创建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)
关联
//以原集合作为 键，创建一个相关联的Map
val a = listOf("one", "two", "three", "four")
val associateWith = a.associateWith { it.length }
println(associateWith)
//以原集合作为 值，创建一个相关联的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,用于后续的 对所有分组进行的操作，比如 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)
