¿Cómo inicializar una matriz en Kotlin con valores?

En Java, se puede inicializar una matriz como:

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

¿Cómo se ve la inicialización de la matriz de Kotlin?

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

Ver Kotlin - Tipos básicos para más detalles.

También puede proporcionar una función de inicializador como segundo parámetro:

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

Cabe mencionar que cuando se utiliza builtines Kotlin (por ejemplo intArrayOf(), longArrayOf(), arrayOf(), etc.) no es capaz de inicializar la matriz con los valores por defecto (o todos los valores a valor deseado) para un tamaño dado, en lugar que necesita hacer initialize a través de llamar según constructor de la clase .

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

Aquí hay un ejemplo:

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

También puede usar un patio de juegos para evaluar las características del lenguaje.

En Kotlin hay varias formas.

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

Luego, simplemente el valor inicial de los usuarios o de otra colección o donde quieras.

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

También podemos crear una matriz con funciones integradas como:

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

De otra manera

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.

También puede usar doubleArrayOf()o DoubleArray()cualquier tipo primitivo en lugar de Int.

En Kotlin podemos crear matriz utilizando arrayOf(), intArrayOf(), charArrayOf(), booleanArrayOf(), longArrayOf()funciones.

Por ejemplo:

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)  

Antigua pregunta, pero si desea utilizar un rango:

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

Produce casi el mismo resultado que:

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

resultado: 10, 20, 30, 40, 50

Creo que la primera opción es un poco más legible. Ambos trabajan.

puedes usar estos métodos

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

ejemplo

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

init representa el valor predeterminado (inicializar)

Idioma Kotlin ha especializado clases para representar matrices de tipos primitivos y sin sobrecarga de boxeo: por ejemplo - IntArray, ShortArray, ByteArray, etc. Me necesidad de decir que estas clases no tienen relación de herencia a los padres Arrayde clase, pero tienen el mismo conjunto de métodos y propiedades. Cada uno de ellos también tiene una función de fábrica correspondiente. Entonces, para inicializar una matriz con valores en Kotlin solo necesita escribir esto:

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

... o de esta manera:

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

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

Ahora puedes usarlo:

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

Espero que esto ayude.

Creo que una cosa que vale la pena mencionar y que no es lo suficientemente intuitiva de la documentación es que, cuando usa una función de fábrica para crear una matriz y especifica su tamaño, la matriz se inicializa con valores que son iguales a sus valores de índice. Por ejemplo, en una matriz tal como este: val array = Array(5, { i -> i }), los valores iniciales asignados son [0,1,2,3,4]y no dicen, [0,0,0,0,0]. Es por eso que a partir de la documentación, val asc = Array(5, { i -> (i * i).toString() })produce una respuesta de["0", "1", "4", "9", "16"]

Puede crear una matriz Int como esta:

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

5 es el tamaño de la matriz Int. la función lambda es la función init del elemento. rango 'it' en [0,4], más 1 rango de marca en [1,5]

la función de origen es:

 /**
 * 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)
  ...
 }

Clase IntArray definida en Arrays.kt

Puedes probar esto:

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

Simplemente puede usar los métodos de biblioteca estándar existentes como se muestra aquí:

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

Sin embargo, podría tener sentido usar un constructor especial:

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

Pasa un tamaño y una lambda que describe cómo iniciar los valores. Aquí está la documentación:

/**
 * 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)

Me pregunto por qué nadie acaba de dar la respuesta más simple:

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

Según uno de los comentarios a mi respuesta original, me di cuenta de que esto solo funciona cuando se usa en argumentos de anotaciones (lo cual fue realmente inesperado para mí).

Parece que Kotlin no permite crear literales de matriz fuera de las anotaciones.

Por ejemplo, mire este código usando @Option de la biblioteca args4j:

    @Opción(
        nombre = "-h",
        alias = ["--help", "-?"],
        uso = "Mostrar esta ayuda"
    )
    ayuda var: booleano = falso

El argumento de opción "alias" es de tipo Array<String>

En mi caso, necesito inicializar mis elementos del cajón. Completo los datos con el siguiente código.

    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)

Clase de modelo personalizado

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

}

Declarar int array en global

var numbers= intArrayOf()

El siguiente método onCreate inicializa tu matriz con valor

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

En Java, se puede inicializar una matriz como:

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

Pero en Kotlin, una matriz se inicializó de muchas maneras, tales como:

Cualquier tipo genérico de matriz puede usar la función arrayOf () :

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

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

Usando funciones de utilidad de Kotlin, se puede inicializar una matriz

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

Manera simple:

Para entero:

número var = arrayOf <Int> (10, 20, 30, 40, 50)

Retener todos los tipos de datos

número var = arrayOf (10, "valor de cadena", 10.5)

Intialize array de esta manera: val paramValueList : Array<String?> = arrayOfNulls<String>(5)

De esta manera, puede inicializar la matriz int en koltin.

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

Mi respuesta complementa @maroun, estas son algunas formas de inicializar una matriz:

Use una matriz

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

Use una matriz estricta

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

Mezclar tipos de matrices

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

Matrices de anidamiento

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

Capacidad para comenzar con código dinámico

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