如何初始化一个数组在Kotlin的值?

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

详见Kotlin -基本类型。

你也可以提供一个初始化函数作为第二个参数:

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

这里有一个例子:

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

你也可以使用操场上来测试语言特性。

值得一提的是，当使用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 }

您可以使用这些方法

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表示默认值(initialize)

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

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

产生几乎相同的结果:

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

结果:10,20,30,40,50

我认为第一个选项更有可读性。这两个工作。

在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。

在我的情况下，我需要初始化我的抽屉项目。我通过以下代码填充数据。

    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) {


}

你可以试试这个:

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

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

你可以像这样创建一个Int数组:

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

5是Int数组的大小。函数是元素init函数。“it”范围在[0,4]，加上1 make范围在[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类

在全局声明int array

var numbers= intArrayOf()

方法用value初始化数组

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)
}

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

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)

在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)

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]

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

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

< / s >

根据对我最初答案的一个评论，我意识到这只在注释参数中使用时才有效(这对我来说真的是出乎意料)。

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

例如，使用args4j库中的@Option查看以下代码:

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

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

在Java中，数组可以这样初始化:

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

但是在Kotlin中，数组初始化的方式有很多，比如:

任何泛型类型的数组都可以使用劳动力素质()函数:

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)

通过这种方式，可以在koltin中初始化int数组。

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

简单的方法:

整数:

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

保持所有数据类型

var number = arrayOf(10， "string value"， 10.5)

我的回答补充了@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}

这里有一个简单的例子

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

对于二维数组:

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

您可以将元素类型更改为您想要的任何类型(String, Class，…)，并将值更改为相应的默认值。

当初始化下面的字符串检查

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

我们可以使用原始int数组专用的arrayOf方法简单地初始化它:

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

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

Item数据类看起来像这样:

data class Item(val textView: String)

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. 根据位置填充数组元素。

   .数组被5的倍数填充

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

[5,10,15,20,25]

你可以这样做:

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)