如何用值初始化 Kotlin 中的数组？

Question

在 Java 中可以初始化一个数组，例如：

int numbers[] = new int[] {10, 20, 30, 40, 50}

Kotlin 的数组初始化是什么样子的？

Answer 1

val numbers: IntArray = intArrayOf(10, 20, 30, 40, 50)

有关详细信息，请参阅Kotlin - 基本类型。

您还可以提供初始化函数作为第二个参数：

val numbers = IntArray(5) { 10 * (it + 1) }
// [10, 20, 30, 40, 50]

Answer 2

值得一提的是，当使用 kotlin 内置函数（例如intArrayOf() 、 longArrayOf() 、 arrayOf()等）时，您无法使用给定大小的默认值（或所有值）初始化数组，而是需要根据类构造函数通过调用进行初始化。

// Array of integers of a size of N
val arr = IntArray(N)

// Array of integers of a size of N initialized with a default value of 2
val arr = IntArray(N) { i -> 2 }

Answer 3

在 Kotlin 中有几种方法。

var arr = IntArray(size) // construct with only size

然后只需从用户或其他集合或您想要的任何地方获取初始值。

var arr = IntArray(size){0}  // construct with size and fill array with 0
var arr = IntArray(size){it} // construct with size and fill with its index

我们还可以使用内置函数创建数组，例如-

var arr = intArrayOf(1, 2, 3, 4, 5) // create an array with 5 values

另一种方式

var arr = Array(size){0} // it will create an integer array
var arr = Array<String>(size){"$it"} // this will create array with "0", "1", "2" and so on.

您还可以使用doubleArrayOf()或DoubleArray()或任何原始类型来代替 Int。

Answer 4

这是一个例子：

fun main(args: Array<String>) {
    val arr = arrayOf(1, 2, 3);
    for (item in arr) {
        println(item);
    }
}

您还可以使用Playground来测试语言功能。

Answer 5

在 Kotlin 中，我们可以使用arrayOf() 、 intArrayOf() 、 charArrayOf() 、 booleanArrayOf() 、 longArrayOf()函数创建数组。

例如：

var Arr1 = arrayOf(1,10,4,6,15)  
var Arr2 = arrayOf<Int>(1,10,4,6,15)  
var Arr3 = arrayOf<String>("Surat","Mumbai","Rajkot")  
var Arr4 = arrayOf(1,10,4, "Ajay","Prakesh")  
var Arr5: IntArray = intArrayOf(5,10,15,20)  

Answer 6

老问题，但如果你想使用一个范围：

var numbers: IntArray = IntRange(10, 50).step(10).toList().toIntArray()

产生几乎相同的结果：

var numbers = Array(5, { i -> i*10 + 10 })

结果：10、20、30、40、50

我认为第一个选项更具可读性。 两者都有效。

Answer 7

Kotlin 有专门的类来表示基本类型的数组，而无需装箱开销。 例如 – IntArray 、 ShortArray 、 ByteArray等。我需要说这些类与父Array类没有继承关系，但它们具有相同的方法和属性集。 它们中的每一个也都有相应的工厂函数。 因此，要在 Kotlin 中使用值初始化数组，您只需输入以下内容：

val myArr: IntArray = intArrayOf(10, 20, 30, 40, 50)

...或者这样：

val myArr = Array<Int>(5, { i -> ((i + 1) * 10) })

myArr.forEach { println(it) }                            // 10, 20, 30, 40, 50

现在你可以使用它了：

myArr[0] = (myArr[1] + myArr[2]) - myArr[3]

Answer 8

你可以使用这个方法

var numbers=Array<Int>(size,init)
var numbers=IntArray(size,init)
var numbers= intArrayOf(1,2,3)

例子

var numbers = Array<Int>(5, { i -> 0 })

init 表示默认值（初始化）

Answer 9

我认为值得一提且文档不够直观的一件事是，当您使用工厂函数创建数组并指定其大小时，该数组将使用等于其索引值的值进行初始化。 例如，在这样的数组中： val array = Array(5, { i -> i }) ，分配的初始值为[0,1,2,3,4]而不是[0,0,0,0,0] 。 这就是为什么从文档中， val asc = Array(5, { i -> (i * i).toString() })产生["0", "1", "4", "9", "16"]

Answer 10

您可以像这样创建一个 Int 数组：

val numbers = IntArray(5, { 10 * (it + 1) })

5 是 Int 数组大小。 lambda 函数是元素初始化函数。 'it' 范围在 [0,4] 中，加上 1 使范围在 [1,5] 中

原点函数为：

 /**
 * An array of ints. When targeting the JVM, instances of this class are 
 * represented as `int[]`.
 * @constructor Creates a new array of the specified [size], with all elements 
 *  initialized to zero.
 */
 public class IntArray(size: Int) {
       /**
        * Creates a new array of the specified [size], where each element is 
        * calculated by calling the specified
        * [init] function. The [init] function returns an array element given 
        * its index.
        */
      public inline constructor(size: Int, init: (Int) -> Int)
  ...
 }

Arrays.kt 中定义的 IntArray 类

Answer 11

我的回答补充了@maroun，这些是初始化数组的一些方法：

使用数组

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

使用严格数组

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

混合类型的矩阵

val numbers = arrayOf(1,2,3.0,4f)

嵌套数组

val numbersInitials = intArrayOf(1,2,3,4,5)
val numbers = arrayOf(numbersInitials, arrayOf(6,7,8,9,10))

能够从动态代码开始

val numbers = Array(5){ it*2}

Answer 12

你可以试试这个：

var a = Array<Int>(5){0}

Answer 13

您可以简单地使用现有的标准库方法，如下所示：

val numbers = intArrayOf(10, 20, 30, 40, 50)

不过，使用特殊的构造函数可能是有意义的：

val numbers2 = IntArray(5) { (it + 1) * 10 }

您传递一个大小和一个描述如何初始化值的 lambda。 这是文档：

/**
 * Creates a new array of the specified [size], where each element is calculated by calling the specified
 * [init] function. The [init] function returns an array element given its index.
 */
public inline constructor(size: Int, init: (Int) -> Int)

Answer 14

我想知道为什么没有人给出最简单的答案：

 val array: Array<Int> = [1, 2, 3]

根据对我原始答案的评论之一，我意识到这仅在用于注释参数时才有效（这对我来说真的出乎意料）。

看起来 Kotlin 不允许在注释之外创建数组文字。

例如，使用 args4j 库中的 @Option 查看此代码：

@Option(
        name = "-h",
        aliases = ["--help", "-?"],
        usage = "Show this help"
    )
    var help: Boolean = false

选项参数“aliases”的类型为Array<String>

Answer 15

在下面初始化字符串检查时

val strings = arrayOf("January", "February", "March")

我们可以使用其专用的 arrayOf 方法轻松初始化原始 int 数组：

val integers = intArrayOf(1, 2, 3, 4)

Answer 16

就我而言，我需要初始化我的抽屉项目。 我通过以下代码填充数据。

    val iconsArr : IntArray = resources.getIntArray(R.array.navigation_drawer_items_icon)
    val names : Array<String> = resources.getStringArray(R.array.navigation_drawer_items_name)


    // Use lambda function to add data in my custom model class i.e. DrawerItem
    val drawerItems = Array<DrawerItem>(iconsArr.size, init = 
                         { index -> DrawerItem(iconsArr[index], names[index])})
    Log.d(LOGGER_TAG, "Number of items in drawer is: "+ drawerItems.size)

自定义模型类-

class DrawerItem(var icon: Int, var name: String) {

}

Answer 17

以这种方式初始化数组： val paramValueList : Array<String?> = arrayOfNulls<String>(5)

Answer 18

在全局声明 int 数组

var numbers= intArrayOf()

下一个 onCreate 方法用值初始化你的数组

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //create your int array here
    numbers= intArrayOf(10,20,30,40,50)
}

Answer 19

简单方法：

对于整数：

var number = arrayOf<Int> (10 , 20 , 30 , 40 ,50)

保留所有数据类型

var number = arrayOf(10 , "字符串值" , 10.5)

Answer 20

这个问题已经有了很好的答案。 这是一个创建 int 数组的合并文件。

1. 创建具有特定值的数组。

    var arr = intArrayOf(12,2,21,43,23) var arr = arrayOf<Int>(12,2,21,43,23)

[12、2、21、43、23]

2. 填充特定元素。 这里是 1。

    var arr = IntArray(5).apply{fill(1)} val arr = IntArray(5){1}

[1, 1, 1, 1, 1]

3. 用小于 20 的随机数填充大小为 5 的数组

   val arr = IntArray(5) { Random.nextInt(20) }

[0、2、18、3、12]

4. 填充数组元素，基于 position。 这里数组填充了 5 的倍数。

    val arr = IntArray(5) { i -> (i + 1) * 5 }

[5、10、15、20、25]

Answer 21

您可以执行以下操作：

val numbers = intArrayOf(10, 20, 30, 40, 50)

或者

val numbers = arrayOf<Int>(10, 20, 30, 40, 50)

还

val numbers = arrayOf(10, 20, 30, 40, 50)

Answer 22

在 Java 中，可以初始化数组，例如：

int numbers[] = new int[] {10, 20, 30, 40, 50}

但是在 Kotlin 中，数组初始化的方式很多，例如：

您可以使用arrayOf()函数的任何通用类型的数组：

val arr = arrayOf(10, 20, 30, 40, 50)

val genericArray = arrayOf(10, "Stack", 30.00, 40, "Fifty")

使用 Kotlin 的实用函数可以初始化数组

val intArray = intArrayOf(10, 20, 30, 40, 50)

Answer 23

这样就可以在 koltin 中初始化 int 数组了。

 val values: IntArray = intArrayOf(1, 2, 3, 4, 5,6,7)

Answer 24

对于二维数组：

val rows = 3
val cols = 3
val value = 0
val array = Array(rows) { Array<Int>(cols) { value } }

您可以将元素类型更改为您想要的任何类型（字符串、类、...），并将值更改为相应的默认值。

Answer 25

您还可以使用 ArrayList 进行填充，然后从中返回一个数组。 下面的方法将在列表中添加 10,000 个 Item 类型的元素，然后返回一个 Item 数组。

private fun populateArray(): Array<Item> {
    val mutableArray = ArrayList<Item>()
    for (i in 1..10_000) {
        mutableArray.add(Item("Item Number $i" ))
    }
    return mutableArray.toTypedArray()
}

项目数据 class 将如下所示：

data class Item(val textView: String)

Answer 26

在 Kotlin 中有几种初始化数组的方式：

数组（）：

var myarray = arrayOf(1,2,3,4,5)

数组（）：

var myarray = arrayOf<Int>(1,2,3,4,5)

使用 Array 构造函数：

val num = Array(3, {i-> i*1})

内置工厂方法：

val num1 = intArrayOf(1, 2, 3, 4)
//For Byte Datatype
val num2 = byteArrayOf()
//For Character Datatype
val num3 = charArrayOf()
//For short Datatype
val num4 = shortArrayOf()
//For long
val num5 = longArrayOf()

Answer 27

这是一个简单的例子

val id_1: Int = 1
val ids: IntArray = intArrayOf(id_1)