Kotlin：多维（2D、3D 等）数组初始化

最新推荐文章于 2024-03-24 16:27:54 发布

程序员小何SS

最新推荐文章于 2024-03-24 16:27:54 发布

阅读量2.8k

点赞数

分类专栏： Android Kotlin 文章标签： kotlin android 开发语言

本文链接：https://blog.csdn.net/xiaokangss/article/details/126777436

版权

Android 同时被 2 个专栏收录

70 篇文章 3 订阅

订阅专栏

Kotlin

27 篇文章 0 订阅

订阅专栏

在某些时候，我们都使用过数组。在单个变量中存储多个相同类型的值是一种有用的数据结构。数组的复杂用法包括将数据存储在 2D、3D 或其他多维数组中。这使我们能够有效地表示矩阵、网格和立方体等事物。

在本文中，我们将特别关注在 Kotlin 编程语言中声明、初始化和使用 2D、3D 和其他多维数组。

Kotlin 中的一维数组

具有预定义数据的一维数组

kotlin 中的简单一维数组是使用arrayOf()标准库函数声明的。它将值列表作为参数并返回一维数组。

这是一个例子：

val array = arrayOf(1, 2, 3, 4, 5)

这将创建一个包含 5 个元素的整数值数组：1、2、3、4、5。

类型声明是可选的arrayOf()，这使数组变得灵活。如果未定义数组类型，那么您可以在数组中存储任何类型的元素。例如，您可以使用：

val array = arrayOf(1, "two", 3.0, true)

它会工作得很好。您可以通过遍历数组并打印值来验证这一点：

for(i in array) {
    println("$i is of type ${i::class.simpleName}")
}

/*
Output:

1 is of type Int
two is of type String
3.0 is of type Double
true is of type Boolean
*/

但这违背了 Kotlin 中类型安全的目的。我们不想将字符串存储在整数数组中。为了保证类型安全，我们在初始化时声明了数组的类型，以保证数组的元素是相同的类型。否则，他们会抛出错误。

为了在 kotlin 中声明一个类型安全的一维数组，我们使用arrayOf()函数 whereT是数组中元素的类型。

例如，要声明一个类型安全的一维整数数组，我们使用arrayOf()：

val array = arrayOf<Int>(10, 20, 30)

如果您尝试将字符串添加到类型安全的 Int 数组，您将收到错误消息：

val array = arrayOf<Int>(10, 20, 30, "40")

/*
Doesn't even compile, error:

Type mismatch: inferred type is String but Int was expected
*/

如果要存储强类型的数据，它非常有用。

有趣的事实

Kotlin 标准库支持 , , 等函数intArrayOf()来doubleArrayOf()声明booleanArrayOf()强类型数组。

具有动态大小的一维数组

对于动态大小的列表，我们使用函数mutableListOf(). 它的工作方式类似于arrayOf()，但为我们提供了对列表执行操作的功能。使用它们，我们可以添加、删除或修改列表中的元素，而无需重新创建它！

注意：与不同的arrayOf()是，一旦mutableListOf()自动推断出单一数据类型，就不能更改列表的数据类型。要明确允许它，请使用mutableListOf()将混合数据类型添加到列表中。如果在构造函数中传入多个数据类型，列表将自动为 type Any。

mutableListOf()允许我们手动定义类型安全列表。

以下是使用各种示例声明类型安全的可变列表的示例：

val list2 = mutableListOf(10, 20, 30) // Type is inferred as Int, similar to mutableListOf<Int>()
list2 += "test" // Error, can't add a string to an Int list

val list2 = mutableListOf(10, 20, 30, true, "hehe") // Type is inferred as Any because of multiple data types
list2 += 100 // Works fine

val list3 = mutableListOf<Any>() // Type is explicitly set to Any
list3 += 10 // Works fine
list3 += "test" // That's okay too :D
list3 += true // All good!

使用数组和列表中存在的数据相当容易：

// The below code works for both lists and arrays

for(i in listOrArray.indices) { 
    // indices is a built-in function that returns the range of indices of the list
    // now you can use listOrArray[i] to access the elements
    print("${listOrArray[i]} ")
}

// You can also use listOrArray[number] to access the element at the given index.

Kotlin 中的二维数组

二维数组是存储网格/板/矩阵类型数据的便捷方式。

如果我们深入研究 Kotlin 标准库，该函数arrayOf()实际上是返回数组Array中T元素的类型。这实际上意味着如果我们传入T我们会得到一个数组Array。

这意味着如果我们传入arrayOf()函数arrayOf()，我们就可以有效地退出Array<Array>，这正是 2D 数组的表示！

具有预定义数据的二维数组

让我们看看如何使用预定义的值制作二维数组：

val array = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6),
    arrayOf(7, 8, 9)
)

这将创建一个 2D Kotlin 数组，它是 1D Kotlin 数组的集合。这是数组的表示：

General Form:
[[1 2 3], [4,5,6], [7,8,9]]

As a matrix:
1 2 3
4 5 6
7 8 9

同样，这些数组不是类型安全的。您可以毫无问题地向数组添加另一种数据类型。为了使其类型安全，我们需要在初始化期间声明数组的类型：

val array = arrayOf<Array<Int>>( // Declaring the type gives error if data types are mixed
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6, "this string will give error"),
    arrayOf(7, 8, 9)
)

具有动态大小的二维数组
要创建没有固定已知大小的 2D 列表，我们使用mutableListOf<MutableList>()声明 whereT是我们期望内部列表保存的数据类型。我们不传递任何初始值，因为稍后将使用一些逻辑填充数组。

让我们看看它的实际效果：

val list = mutableListOf<MutableList<Int>>()

// The elements within the inner lists can be anything, the numbers below are just an example.

// `repeat()` takes in a number and iterates from 0 to number-1
repeat(4) {
    // `row` is a new row in the array
    val row = mutableListOf<Int>()

    repeat(4) { col -> // `col` is a new column in the row, ranges from 0 to 3
        row += col
    }

    // Append the row to the array, can also use the `add()` function
    list += row
}

// for each list in the list, print its element in matrix form
for(sublist in list) {
    for (j in sublist.indices){
        print("$j ")
    }

    println() // new line after each row
}

/*
You can also access particular elements like:
list[0][0] -> First element of the first row
or
list.get(0).get(0) -> Same as above
*/

此代码输出以下内容：