Kotlin为数组增加了一个Array类，为基本元素类型增加了XxxArray类（Xxx可以是Byte、Short、Int等基本类型）
Kotlin抛弃了Java集合体系中的Queue集合，增加了可变集合和不可变集合
Kotlin的集合体系由三种集合组成

• List(有序集合元素可重复)
• Set(无序集合元素不可重复)
• Map(采用key-value对的形式存储数据)

数组

Kotlin的数组使用Array<T>类代表，Kotlin的数组就是一个Array类的实例，因此Kotlin数组当然也算引用类型

创建数组

Kotlin创建数组其实就是创建Array<T>类的实例，Kotlin可允许通过Array<T>类的构造器来创建实例，也可通过arrayOf()等工具函数来创建实例

• 使用arrayOf()、arrayOfNulls()、emptyArray()工具函数
• 使用Array(size:Int,init:(Int)->T)构造器

//创建一个包含字符串的数组 相当于java的数组静态初始化
    var arr1 = arrayOf("Java","Kotlin","C++")
    //int 数组
    var intArr = arrayOf(1,2,3,4,5)
    //创建指定长度，元素为null的数组 相当于java的动态初始化
    var arr2 = arrayOfNulls<Double>(5)
    var intArr2 = arrayOfNulls<Int>(2)
    //创建长度为0的空数组
    var arr3 = emptyArray<String>()
    var arr4 = emptyArray<Long>()
    //创建指定长度，使用lambda表达式初始化数组元素
    var arr5 = Array(5,{(it*2+97).toChar()})
    var strArr2 = Array(2,{"abc"})

• arrayOf() 这种方式无须显式指定数组长度，但需要依次列出每个数组元素，这种方式就相当于Java的静态初始化，这种方式创建数组不需要使用泛型来指定数组元素的类型
• arrayOfNulls() 这种方式需要显式指定数组的长度，数组元素全部被初始化为null，这种方式就相当于Java数组的动态初始化
• emptyArray() 这种方式会创建一个长度为0的空数组，需要使用泛型来指定数组元素的类型
• Array(size:Int,init:(int)->T)构造器：这种方式需要显式指定数组的长度，并可以通过lambda表达式来动态计算各数组元素的值

由于Array<T>类要求它的元素必须是引用类型，所以，如果程序将基本类型的值存入Array<T>中，Kotlin会将这些基本类型的值自动装箱成包装类的实例，然后再讲这些实例添加到Array<T>数组中，为此Kotlin专门提供了ByteArray、ShortArray、IntArray、LongArray、CharArray、FloatArray、DoubleArray、BooleanArray

使用数组

访问数组元素 就是在数组引用变量后面跟一个方括号实现的。方括号里是数组元素的索引值。

  var strArr = arrayOf("java","kotlin","Swift")
    //访问数组第一个元素
    println(strArr[0])
    println(strArr.get(0))
    //修改数组第二个元素
    strArr[1]="Ruby"
    strArr.set(1,"ruby1")
    println(Arrays.toString(strArr))

所有的数组都提供了一个size属性，通过这个属性可以访问到数组的长度，一旦获得了数组的长度，就可以通过循环来遍历该数组的每个数组元素

var booksArr = arrayOfNulls<String>(5)
    booksArr[0] = "《疯狂Kotlin讲义》"
    booksArr[1] = "《疯狂Android讲义》"
    //循环输出books数组的每个值
    for (i in 0 until booksArr.size) {
        println(booksArr[i])
    }

使用for-in循环遍历数组

 var booksArr = arrayOfNulls<String>(5)
    booksArr[0] = "《疯狂Kotlin讲义》"
    booksArr[1] = "《疯狂Android讲义》"
    //for in循环遍历数组
    for (book in booksArr) {
        println(book)
    }

使用数组索引

Kotlin的数组提供了一个indices属性，该属性即可返回数组的索引区间

 val testArr = arrayOf("abc","bcd","def","efg")
    for (i in testArr.indices) {
        println(testArr[i])
    }

还可以使用in、!in来检查某个索引是否位于数组的索引区间内

  //创建随机数
    val i = Random().nextInt(10)
    println(i in testArr.indices)

Kotlin还为数组提供了一个lastIndex属性，该属性用于返回数组最后一个元素的索引值，该索引值通常等于size-1

 println(testArr.lastIndex)
    println(testArr.size - 1 == testArr.lastIndex)

如果程序需要同时访问数组的索引和元素，也可使用数组的withIndex()，该方法返回一个Iterable对象。该对象的所有元素都是IndexedValue

 val testArr = arrayOf("abc","bcd","def","efg")
    //withIndex()
    for((index,value) in testArr.withIndex()){
        println("索引为${index}值为${value}")
    }

数组的常用方法

Kotlin为数组提供的方法大致相当于Java的Arrays工具类提供的操作数组的方法

• all(predicate:(T)->Boolean):使用Lambda表达式要求所有数组元素都满足该表达式，如果都满足，那么该方法返回true
• any(predicate:(T)->Boolean):使用Lambda表达式要求任一数组元素都满足该表达式，如果都满足，那么返回true
• asList()：将该数组转换成List集合
• associate(transform:(T)->Pair<K,V>):使用Lambda表达式根据数组元素进行计算，返回元素是<K,V>的map集合
• associateBy(keySelector:(T)->K):使用Lambda表达式根据数组元素进行计算，返回元素是<K,T>的Map集合
• average()：计算数值型数组的平均值
• contains(element:T)判断该数组是否包含某个元素，可用in、!in运算符执行
• containsEquals()：比较两个数组是否相等
• contentToString()：把数组转换成字符串 Arrays.toString()
• copyOf(newSize:Int) 将数组复制成一个新数组，newSize是新数组的长度，如果newSize小于原数组的长度，则新数组就是原数组前面newSize个长度，如果newSize大于原数组的长度，则新数组的前面元素就是原数组的所有元素
• copyOfRange(fromIndex:Int,toIndex:Int):复制该数组的from到to索引的元素
• count(predicate:(T)->Boolean)返回该数组符合给定Lambda条件的元素的个数
• distinct()去掉数组中重复的元素
• drop|dropLast(n:Int) 用于去掉数组前面或后面n个元素
• dropWhile|dropLastWhile(predicate:(T)->Boolean)用于去掉数组前面或后面的某些元素，直到前面或后面第一个元素不再符合predicate条件
• fill(element:T,fromIndex:Int=0,toIndex:Int=size)：该方法将会把数组中从fromIndex到toIndex索引的数组元素赋值为element
• filterXxx()：一系列过滤方法，用于对数组元素进行过滤
• findXxx()：一系列用于查找元素的方法
• first|last(predicate:(T)->Boolean):获取数组中第一个或最后一个符合predicate条件的元素
• indexOf|lastIndexOf(element T):获取从前搜索或从后搜索时元素element在数组中的索引
• indexOfFirst|indexOfLast(predicate(T):->Boolean)返回第一个或最后一个符合predicate条件的元素的索引
• intersect|plus(other:Iterable<T>)获取两个数组的交集或并集
• max|min()按照自然排序规则，找出数组中的最大值或最小债
• sort(fromIndex:Int=0,toIndex:Int=size)对数组的元素按自然排序进行排列
• sortWith(comparator:Comparator<in T>):该方法对数组的所有元素按comparator排序进行排列

 //定义一个数组
    val intArr = arrayOf(1,2,3,4)
    //判断数组中所有元素的平方是否大于20
    println(intArr.all { it * it > 10 })//false
    //判断数组中任意元素的平方是否大于20
    println(intArr.any { it * it > 10 })//true
    //返回key+2 value平方的map集合
    val result = intArr.associate { it + 2 to it * it }
    println(result)

    //定义一个相同的数组
    val intArr2 = arrayOf(1,2,3,4)
    //判断数组是否相等
    println("intArr intArr2是否相等${intArr.contentEquals(intArr2)}")
    //复制intArr2
    val intArr2Copy = intArr2.copyOf(4)
    //输出string intArr2Copy
    println(intArr2Copy.contentToString())
    //将intArr2Copy第5个到第7个元素替换为1
    intArr2Copy.fill(0,1,3)
    println("输出intArr2Copy${intArr2Copy.contentToString()}")
    //对intArr2进行排序
    intArr2.sort()
    println(intArr2.contentToString())