Como inicializar uma matriz no Kotlin com valores?

Em Java, uma matriz pode ser inicializada, como:

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

Como é a inicialização do array do Kotlin?

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

Consulte Kotlin - Tipos básicos para obter detalhes.

Você também pode fornecer uma função inicializadora como um segundo parâmetro:

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

Vale a pena mencionar que, ao usar builtines KOTLIN (por exemplo intArrayOf(), longArrayOf(), arrayOf(), etc) você não é capaz de inicializar a matriz com os valores padrão (ou todos os valores para o valor desejado) para um determinado tamanho, em vez disso você precisa fazer inicialização via chamando de acordo com construtor da classe .

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

Aqui está um exemplo:

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

Você também pode usar um playground para testar os recursos do idioma.

Em Kotlin, existem várias maneiras.

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

Em seguida, simplesmente valor inicial dos usuários ou de outra coleção ou onde quiser.

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

Também podemos criar um array com funções internas como

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

Outra maneira

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.

Você também pode usar doubleArrayOf()ou DoubleArray()ou qualquer tipo primitivo em vez de Int.

Em Kotlin podemos criar matriz usando arrayOf(), intArrayOf(), charArrayOf(), booleanArrayOf(), longArrayOf()funções.

Por exemplo:

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)  

Pergunta antiga, mas se você quiser usar um intervalo:

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

Rende quase o mesmo resultado que:

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

resultado: 10, 20, 30, 40, 50

Eu acho que a primeira opção é um pouco mais legível. Ambos funcionam.

você pode usar esses métodos

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

exemplo

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

init representa o valor padrão (inicializar)

Linguagem Kotlin especializou classes para representar matrizes de tipos primitivos sem o boxe sobrecarga: por exemplo - IntArray, ShortArray, ByteArray, etc. Eu preciso dizer que essas classes não têm relação herança para o pai Arrayclasse, mas eles têm o mesmo conjunto de métodos e propriedades. Cada um deles também possui uma função de fábrica correspondente. Portanto, para inicializar uma matriz com valores no Kotlin, basta digitar isto:

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

... ou desta maneira:

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

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

Agora você pode usá-lo:

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

Espero que isto ajude.

Acho que uma coisa que vale a pena mencionar e não é intuitiva o suficiente da documentação é que, quando você usa uma função de fábrica para criar uma matriz e especifica seu tamanho, a matriz é inicializada com valores iguais aos seus valores de índice. Por exemplo, em uma matriz como esta val array = Array(5, { i -> i }):, os valores iniciais atribuídos são [0,1,2,3,4]e não dizem [0,0,0,0,0],. É por isso que, a partir da documentação, val asc = Array(5, { i -> (i * i).toString() })produz uma resposta de["0", "1", "4", "9", "16"]

Você pode criar uma Matriz Int assim:

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

5 é o tamanho da matriz Int. a função lambda é a função init do elemento. faixa 'it' em [0,4], mais 1 faixa de make em [1,5]

A função de origem é:

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

Classe IntArray definida em Arrays.kt

Você pode tentar isso:

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

Você pode simplesmente usar os métodos existentes da biblioteca padrão , como mostrado aqui:

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

Pode fazer sentido usar um construtor especial:

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

Você passa um tamanho e uma lambda que descrevem como iniciar os valores. Aqui está a documentação:

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

Gostaria de saber por que ninguém deu as respostas mais simples:

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

De acordo com um dos comentários à minha resposta original, percebi que isso só funciona quando usado nos argumentos das anotações (o que foi realmente inesperado para mim).

Parece que o Kotlin não permite criar literais de matriz fora das anotações.

Por exemplo, observe este código usando @Option da biblioteca args4j:

    @Opção(
        nome = "-h",
        aliases = ["--help", "-?"],
        use = "Mostrar esta ajuda"
    )
    var ajuda: Booleano = false

O argumento da opção "aliases" é do tipo Array<String>

No meu caso, preciso inicializar os itens da minha gaveta. Eu preencho os dados pelo código abaixo.

    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)

Classe de modelo personalizado

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

}

Declare int array em global

var numbers= intArrayOf()

próximo método onCreate inicialize sua matriz com 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)
}

Em Java, uma matriz pode ser inicializada, como:

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

Mas em Kotlin, uma matriz inicializou de várias maneiras, como:

Qualquer tipo genérico de matriz que você pode usar a função arrayOf () :

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

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

Usando funções utilitárias do Kotlin, uma matriz pode ser inicializada

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

Maneira simples:

Para Inteiro:

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

Reter todos os tipos de dados

var number = arrayOf (10, "valor da string", 10,5)

inicialize a matriz desta maneira: val paramValueList : Array<String?> = arrayOfNulls<String>(5)

Dessa maneira, você pode inicializar a matriz int em koltin.

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

Minha resposta complementa @maroun, estas são algumas maneiras de inicializar uma matriz:

Use uma matriz

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

Use uma matriz estrita

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

Misture tipos de matrizes

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

Matrizes de aninhamento

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

Capacidade de começar com código dinâmico

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