Array和List的区别

Array<T> 是一个具有已知实现的类：它是一个存储项的顺序固定大小的内存区域 如果Java中Int[]

List<T> 和 MutableList<T> 是具有不同实现的接口： ArrayList<T> ， LinkedList<T> 等 . 列表的存储器表示和操作逻辑在具体实现中定义，例如， LinkedList<T> 中的索引遍历链接并占用O（n）时间，而 ArrayList<T> 将其项目存储在动态分配的数组中 . Array 是一个类

Array<T> 是可变的（可以通过对它的任何引用来更改），但 List<T> 没有修改方法

val a = arrayOf(1, 2, 3)
a[0] = a[1] // OK

val l = listOf(1, 2, 3)
l[0] = l[1] // doesn't compile

val m = mutableListOf(1, 2, 3)
m[0] = m[1] // OK

//初始化一个多数据类型的数组
        var array4 = arrayOf(1,2,3)
        array4[1] = 3 
        //或者
        array4.set(1,3)

        for (i in array4) {
            println(" =====${i}")
        }

//初始化一个list，list只有一个get方法，没有修改那个元素的方法
        var array4 = listOf(1,2,3)
        array4[1]
        
        for (i in array4) {
            println(" =====${i}")
        }

数组具有固定大小，无法扩展或缩小保留标识（您需要复制数组以调整其大小） . 至于列表， MutableList<T> 具有 add 和 remove 函数，因此它可以增加和减小其大小 .

val a = arrayOf(1, 2, 3)
println(a.size) // will always be 3 for this array

val l = mutableListOf(1, 2, 3)
l.add(4)
println(l.size) // 4

• 数组针对基元进行了优化：有单独的 IntArray ， DoubleArray ， CharArray 等，它们映射到Java原始数组（ int[] ， double[] ， char[] ），而不是boxed（ Array<Int> 映射到Java的 Integer[] ） . 列表一般没有针对基元优化的实现，尽管一些库（在JDK之外）提供基元优化列表 .

• List<T> 和 MutableList<T> 是mapped types并且在Java互操作性方面有特殊行为（Java的 List<T> 在Kotlin中被视为 List<T> 或 MutableList<T> ） . 数组也被映射，但它们具有Java互操作性 .

• 某些数组类型用于annotations（原始数组， Array<String> 和带有 enum class 条目的数组），并且有一个特殊的array literal syntax for annotations . 列表和其他集合不能用于注释 .

• 至于用法，好的做法是更喜欢在数组中使用列表，除了代码的性能关键部分，其推理与that for Java相同 .

与使用方面的主要区别在于Arrays具有固定大小，而(Mutable)List可以动态调整其大小 . 此外 Array 是可变的，而 List 则不是 .

一.Kotlin数组（Array）

kotlin为数组增加了一个Array类，为元素是基本类型的数组增加了xxArray类（其中xx也就是Byte，Short， Int等基本类型）
注意是：类

Kotlin创建数组大致有如下两种方式：

1.使用arrayOf(), arrayOfNulls()，emptyArray()工具函数。

2.使用Array(size: Int, init:(Int) -> T)

        val c = arrayOf<String>()
        val c1 = emptyArray<String>()
        val c2 = arrayOfNulls<String>(10)
        val c3 = Array<String>(10,{  })

 
        //初始化一个空的数组，实际上它是大小为0继承arrayOfNulls的数组
        var array1 = emptyArray<String>()
        //初始化一个空的数组，需要传入数组大小
        var array2 = arrayOfNulls<String>(3)
        //初始化一个指定大小数组，第一个参数是size，第二个参数是生成逻辑的函数，
        // 相当于java中遍历数组，给每个下标为k的数组赋值array2[k] = k * k;
        var array3 = Array(10) { k -> k * k}
        //初始化一个多数据类型的数组
        var array4 = arrayOf("1",2,3)
        //初始化一个特定数据类型-字符类型的数组
        var array5 = charArrayOf('d')

Array(size: Int, init: (Int) -> T) 第一个参数就是对数组设置的大小很好理解。那么第二个参数是什么。 其实在kotlin里中参数也可以定义某个方法的类型的。哇，感觉很神奇吧！我们在写java的时候基本上就是参数要不传普通类型要不就是对象类型，没有听说过可以传方法类型的。 因为在kotlin里中方法其实也是有类型的。所以第二个参数 init:(Int) -> T 代表这这个方法返回的类型是T只能有一个参数类型是Int型。虽然没有看源码，但是从它的字面是就可以看出这个参数其实就是对array的每个索引进行初始化的。Int就是该array的所对应的索引。下面看一下这个代码:

image.png

看过我以前的文章的朋友应该知道这个it代表什么了吧，就是代表（Int）的参数传入的值，也就是array的下标的索引。arrayInit的结果就是每个下标的索引所对应的值为下标索引 * 2， arrayInitTwo下标索引对应的值就是索引值。在接下来的Kotlin值函数的文章中我会具体讲讲kotlin函数的用法。

其实有些朋友也许会有这样的疑虑，为什么在写数组的时候有的时候需要指定泛型，有的时候不需要呢。其实你记住一点就可以了，在初始化的时候如果你是已经将参数写进去了，kotlin用自动识别的就不需要指定泛型了，如果只是指定大小没有写入参数的话。因为kotlin不知道需要什么类型，所以需要指定泛型。kotlin还提供了一个emptyArray()函数，用法基本一致，这种方式创建了一个长度为0的空数组。

数组元素的填充：fill

array提供了fill函数，给原有的数组填充数组（如果原来有数据将会被覆盖），操作示范：

//初始化一个多数据类型的数组
        var array4 = arrayOf("1",2,3)
        //往数组里填入数据"4",fromIndex 0 toIndex 2,从下标0到2,不包含2
        array4.fill("4",0,2)
        for (i in array4){
            println(i)
        }

结果可以猜得到：

4
4
3
 
Process finished with exit code 0

注意：fill的index 不能超过原来定义的范围，如上，如果toIndex 设为4 就会奔溃

判断数组里边所有的元素：all

 判断是否数组里的值都大于1，如果是返回true，不是返回false

var array4 = arrayOf(1,2,3)
        var c = array4.all {
            it > 1
        }

判断数组里边一个元素的值

判断是否数组里的值其中有一个大于1，如果是返回true，不是返回false

var array4 = arrayOf(1,2,3)
        var c = array4.any {
            it > 1
        }

对Array的扩充：plus

注意应用了plus后并没有修改原来的数组，要接受他的返回值，才是加了以后的数组如：d

var array4 = arrayOf(1,2,3)
        array4.plus(5)
        var d = array4.plus(5)
        for (i in d) {
            println("arry4 ======${i}")
        }

Kotlin的List

kotlin集合类同样有两个接口派生：Collection和Map。但Kotlin的结合被分成两个大类，可变集合和不可变集合。只有可变集合才可以添加修改，删除等处理操作。不可变集合只能读取元素。

image.png

val a = listOf<String>()
        val b = arrayListOf<String>()

        val d = List(10,{
            it.toString()
        })

        //初始化一个多数据类型的数组
        var array4 = arrayOf("1",2,3)
        //往数组里填入数据"4",fromIndex 0 toIndex 2,从下标0到2,不包含2
        array4.fill("4",0,2)
        for (i in array4){
            println(i)
        }



        //listof 函数是emptyList //就是生成了一个单利类，遵守List协议的单利类
        //List(10,{
        // it.toString()
        // }) 实际返回的ArrayList

        //List 和Array的不同点 Array是一个数组是一个类，而List是一个协议
        val e = Array(1, {
            it.toString()
        })

        val f = ArrayList<String>()
        val g:List<String>? = null

所以Array和List的用法区别是，要用Array 就像之前的Int[] 这个，list 是只读的，mutableListOf是可以add remove的 set 这些方法，也可以扩展内存，

ArrayList 实际上就是mutableList 的

Kotlin——高级篇（五）：集合之常用操作符汇总

如map 方法 flatmap