数据容器：
容器是用于存放数据的载体，分为数组、集合。
- Kotlin数组
- Kotlin集合
Kotlin数组：
数组是一种初始化时指定容器大小，不可以动态调整其大小的容器（也就是不能改变数组的length，只能进行修改和查询）。元素按顺序存储在一串连续的内存段上。
1.创建数组方式：
下面这种方法与上面的动态创建数组相似：
//创建一个长度为5，值为100的IntArray:[100,100,100,100,100]
val intArr2=IntArray(5){100}
//创建一个长度为5的IntArray:[0,2,4,6,8]
val intArr3=IntArray(5){int*2}
//val intArr3=IntArray(5){i->i*2}
//it代表数组专有的下标
2.数组的操作：
3.数组循环：
val intArr3=IntArray(5){it*2}
//打印 [0,2,4,6,8]
for循环
1.依次取出数组种的元素---for-in的形式
//元素遍历
for(item in intArr3){
println(item)
}
//打印：0 2 4 6 8
//根据下标再取出对应位置的元素
for(i in intArr3.indices){
println(i.toString()+"->"+intArr3[i])
}
//打印：0->0 1->2 2->4 3->6 4->8
//同时遍历下标 和 元素
for((index,item) in intArr3.widthIndex()){
println("$index->$item")
}
//打印：0->0 1->2 2->4 3->6 4->8
2.forEach会依次回调给我们数组中的元素
//遍历数组的元素
intArr3.forEach{
println("forEach:$it")
//这里的it 代表的是数组的元素
}
//打印：forEach:0 forEach:2 forEach:4 forEach:6 forEach:8
3.forEach增强版 会依次回调给我们数组中的下标和元素
//遍历数组的元素 和 下标
intArr3.forEachIndexed{index,item->
println("$index:$item")
}
//打印：0:0 1:2 2:4 3:6 4:8
Kotlin集合：
各种集合对于解决问题都具有重要的意义，并且经常用到。与数组不同的是可变集合的大小可以动态改变。
- List:是一个有序集合，可通过索引(下标)访问元素。元素可以在list中出现多次、元素可重复。
- Set:是唯一元素的集合。一组无重复的对象。一般来说set中元素的顺序并不重要、无序集合。
- Map:(字典)是一组键值对。键是唯一的，每一个键都刚好映射到一个值，值可以重复。
1.集合创建的技巧：
集合：
- 可变集合，显而易见，是指集合创建完成之后，可以对集合进行增删改查操作
- 不可变集合，显而易见，是指集合创建完成之后，不能对集合进行增删操作，会抛出异常
1.列表的创建方式：
1.列表的创建方式---可变列表
val arrayString= mutableListOf<String>()
arrayString.add("1")
arrayString.add("2")
arrayString.add("2")
//可以指定下标，添加列表元素
arrayString.add(3,"3")
println(arrayString)
//[1, 2, 2, 3]
val arrayString2= mutableListOf<String>("1","2","3","4")
arrayString2.add("4")
println(arrayString2)
//[1, 2, 3, 4, 4]
2.列表的创建方式---不可变列表
val arrayInt= listOf<Int>(1,2,3)
//相较于上面的mutableListOf创建列表的方法，listOf方法创建的列表并不能向里面的元素进行操作
2.map字典的创建
(字典)是一组键值对。键是唯一的，每一个键都刚好映射到一个值，值可以重复
1.map字典的创建---可变字典
val array= arrayMapOf<String,String>(Pair("key","value"))
array.put("1","2")
array.put("2","3")
val arrayMap= mutableMapOf<String,String>()
arrayMap.put("1","1")
// arrayMap.put("1","1") => arrayMap["1"]="1"
arrayMap["2"]="2"
arrayMap["3"]="2"
//重新对key=3的value进行赋值，也就是会覆盖上面的值
arrayMap["3"]="3"
println(array)
//打印：{1=2, 2=3, key=value}
println(arrayMap)
//打印：{1=1, 2=2, 3=3}
2.map字典的创建---使用Pair指定集合中初始化的元素
val arrayMap2= mutableMapOf<String,String>(Pair("key","value"))
//同样是通过上面的方法对key进行赋值
arrayMap2["1"]="1"
arrayMap2["2"]="2"
println(arrayMap2)
//打印：{key=value, 1=1, 2=2}
//注意：这里的arrayMap2和array打印的结果，排列的顺序是不一样
3.map字典的创建---不可变字典，不可动态添加、删除元素
//可以指定arrayMap3创建之初的元素，也可以不指定
val arrayMap3= mapOf<String,String>(Pair("key","value"))
val arrayMap4= mapOf<String,String>()
println(arrayMap3)
//打印：{key=value}
println(arrayMap4)
//打印：{}
3.Set集合的创建
1.Set集合的创建---可变集合，元素唯一
val set= mutableSetOf<Int>()
set.add(1)
set.add(2)
set.add(3)
set.add(1)
//元素唯一，重复的元素是无法向set中进行添加
println(set)
//打印：[1, 2, 3]
val set2= mutableSetOf<Int>(1,2,3,4,5)
set2.add(1)
set2.add(2)
//元素唯一，重复的元素是无法向set中进行添加
println(set2)
//打印：[1, 2, 3, 4, 5]
2.Set集合的创建---不可变集合，元素唯一
val set3= setOf<Int>(1,2,3)
//set3没有add方法，无法进行添加，是不可变的
println(set3)
//打印：[1, 2, 3]
2.集合的操作：
1.增删改查操作:
val arrayExamples= mutableListOf<String>("1","2","3","4","5","6","2")
1.判断集合是否为空
println("isEmpty: ${arrayExamples.isEmpty()}")
2.判断集合中是否包含某个值
println("contains:${arrayExamples.contains("6")}")
3.查询集合中某一个下标的元素是什么
println("get:${arrayExamples.get(2)}")
4.判断元素在集合中的下标位置
//从前面开始对集合查询元素的下标，找到了，就返回
// 如果不在集合里面，返回-1
println("indexOf:${arrayExamples.indexOf("2")}")
//从集合的后面开始对集合进行查询元素的下标，找到了，就返回
println("lastIndexOf:${arrayExamples.lastIndexOf("2")}")
5.迭代器
val iterator=arrayExamples.iterator()
iterator.forEach { it-> println("it:${it}") }
6.清除集合中的元素
arrayExamples.clear()
7.修改下标对应的元素，index不能超过与集合size的大小
arrayExamples.set(0,"0")
8.向集合中指定下标插入元素
arrayExamples.add(1,"7")
9.移除集合指定位置的元素
arrayExamples.removeAt(0)
迭代器：对于遍历集合元素， Kotlin 标准库支持 迭代器 的常用机制—— 对象可按顺序提供对元素的访问权限，而不会暴露集合的底层结构。 当需要逐个处理集合的所有元素（例如打印值或对其进行类似更新）时， 迭代器非常有用。
Iterable<T> 接口的继承者 （包括 Set 与 List）可以通过调用 iterator() 函数获得迭代器。
一旦获得迭代器它就指向集合的第一个元素；调用 next() 函数将返回此元素，并将迭代器指向下一个元素（如果下一个元素存在）。
一旦迭代器通过了最后一个元素，它就不能再用于检索元素；也无法重新指向到以前的任何位置。要再次遍历集合，请创建一个新的迭代器。
fun main() {
//sampleStart
val numbers = listOf("one", "two", "three", "four")
val numbersIterator = numbers.iterator()
while (numbersIterator.hasNext()) {
println(numbersIterator.next())
}
//sampleEnd
}
遍历 Iterable 集合的另一种方法是众所周知的 for 循环。在集合中使用 for 循环时， 会隐式获取迭代器。因此，以下代码与上述示例等效：
fun main() {
//sampleStart
val numbers = listOf("one", "two", "three", "four")
for (item in numbers) {
println(item)
}
//sampleEnd
}
最后，有一个好用的 forEach() 函数，可自动迭代集合并为每个元素执行给定的代码。因此，等效的示例如下所示：
fun main() {
//sampleStart
val numbers = listOf("one", "two", "three", "four")
numbers.forEach {
println(it)
}
//sampleEnd
}
