Kotlin-内置类型—数组（三）

阅读完需：约 3 分钟

java和kotlin的数组还是有一定的区别的。

数组在 Kotlin 中使用 Array 类来表示，它定义了 get 与 set 函数（按照运算符重载约定这会转变为 []）以及 size 属性，以及一些其他有用的成员函数：

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ……
}

我们可以使用库函数 arrayOf() 来创建一个数组并传递元素值给它，这样 arrayOf(1, 2, 3) 创建了 array [1, 2, 3]。 或者，库函数 arrayOfNulls() 可以用于创建一个指定大小的、所有元素都为空的数组。

另一个选项是用接受数组大小以及一个函数参数的 Array 构造函数，用作参数的函数能够返回给定索引的每个元素初始值：

// 创建一个 Array<String> 初始化为 ["0", "1", "4", "9", "16"]
val asc = Array(5) { i -> (i * i).toString() }
asc.forEach { println(it) }

后面的 { i -> (i * i).toString() } 是独有的，所代表着循环5次去执行后面的方法，方法中的i是自增的，再将结果返回一个数组。

Kotlin 中数组是不型变的（invariant）。这意味着 Kotlin 不让我们把 Array<String> 赋值给 Array<Any>，以防止可能的运行时失败（但是你可以使用 Array<out Any> 类似与泛型）

原生类型数组

Kotlin 也有无装箱开销的专门的类来表示原生类型数组: ByteArray、 ShortArray、IntArray 等等。这些类与 Array 并没有继承关系，但是它们有同样的方法属性集。它们也都有相应的工厂方法:

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

// 大小为 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 }

数组的创建

另一种遍历的写法：

例子：

java

public class JavaArrays {
    public static void main(String... args) {

        int[] a = new int[5];
        System.out.println(a.length);// only array use 'length'

        ArrayList<String> b = new ArrayList<>();
        System.out.println(b.size());

        int[] c = new int[]{1, 2, 3, 4, 5};

        String[] d = new String[]{"Hello", "World"};
        d[1] = "Java";
        System.out.println(d[0] + ", " + d[1]);

        float[] e = new float[]{1, 3, 5, 7};
        for (float element : e) {
            System.out.println(element);
        }

        for (int i = 0; i < e.length; i++) {
            System.out.println(e[i]);
        }

        // Test in an Array
        for (float element : e) {
            if(element == 1f){
                System.out.println("1f exists in variable 'e'");
                break;
            }
        }

        //Test not in an Array
        boolean exists = false;
        for (float element : e) {
            if(element == 1.2f){
                exists = true;
                break;
            }
        }

        if(!exists){
            System.out.println("1.2f not exists in variable 'e'");
        }

    }
}

kotlin：

fun main() {

    val a = IntArray(5)
    println(a.size) //same with the Collections(e.g. List)

    val b = ArrayList<String>()
    println(b.size)

    val c0 = intArrayOf(1, 2, 3, 4, 5)

    // 下面这两个后面都要跟方法才可以
    // it 是Lambda的隐藏参数
    val asc = Array(5) { 3 * (it + 1)}
    val c1 = IntArray(5){ 3 * (it + 1) } // y = 3*(x + 1)

    // contentToString() 可以直接打印出内容
    println(c1.contentToString())
    println(asc.contentToString())

   val d = arrayOf("Hello", "World")
    d[1] = "Kotlin"
    println("${d[0]}, ${d[1]}")

    val e = floatArrayOf(1f, 3f, 5f, 7f)
    for (element in e) {
        println(element)
    }

    // Lambda 表达式的写法, it是隐藏的参数
    e.forEach {
        println(it)
    }

   // 判断是否在1f在数组里面
    if(1f in e){
        println("1f exists in variable 'e'")
    }

    if(1.2f !in e){
        println("1.2f not exists in variable 'e'")
    }

}