如何用值初始化 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)