Como inicializar uma matriz no Kotlin com valores?

261

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?

Lars Blumberg
fonte
Talvez apenas ter um olhar para os documentos: kotlinlang.org/docs/reference/basic-types.html
khlr
6
A documentação esconde um pouco a resposta. Em vez de dar um exemplo de código-fonte, eles mencionam a array()função (obsoleta) em um comentário lateral: Para criar uma matriz, podemos usar uma função de biblioteca array () e passar os valores do item para ele, para que a matriz (1, 2, 3 ) cria uma matriz [1, 2, 3].
Lars Blumberg
8
Embora eu goste do Kotlin, mas já disse que "a documentação do Kotlin" não é boa o suficiente (eu aprendi mais com outros sites além do kotlinlang.org).
Hassan Tareq
1
Também em algum momento você só quer um intRange você poderia fazer: val numbers = 1..5o que dá uma gama int de 1 a 5.
Sylhare

Respostas:

313
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]
Maroun
fonte
9
É preferível usar intArrayOfsobre arrayOf? Assim, IntArraytem vantagens sobre Array<Int>?
Lars Blumberg
17
@LarsBlumberg IntArray é igual a int [], array <int> é o mesmo que Integer []
user2235698
3
Inicializar uma lista é muito semelhante:listOf(10, 20, 30, 40, 50)
Cristan 24/12
Quando estou usando a função intArrayOf (), enfrento Exception in thread "main" java.lang.NoClassDefFoundError: kotlin/KotlinPackage. Eu estou usando jdk1.8.0_241e Intellij IDEA
TeachMeJava
92

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 }
vtor
fonte
9
Esse segundo valor padrão init usando o lambda foi super útil! Graças
rf43
9
A segunda forma de inicialização pode ser escrito como: IntArray(N) {i -> 2}e ainda (quando inicializando com uma constante)IntArray(N) {2}
David Soroko
1
Em vez de i, podemos usar "_" var arr = IntArray (N) {_ -> false} #
Navas pk
1
Aquele com o lambda era exatamente o que eu precisava para iniciar uma matriz com tamanho dinâmico e valor padrão não opcional. Obrigado!
mithunc 10/04
48

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.

shadeglare
fonte
3
Um comentário, para imprimir o valor de uma matriz, podemos usar array.joinToString ("") em vez de repetir.
Anticafe
2
Funciona, mas parece mais Java escrito em Kotlin de Kotlin idiomática :)
m0skit0
47

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.

HM Nayem
fonte
var arr = IntArray(size, { it * 1 } )é o mesmo quevar arr = IntArray(size){it}
Det
30

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)  
RS Patel
fonte
Reformate esta resposta para que fique claro o que é código e o que é comentário.
6

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.

Brooks DuBois
fonte
5

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)

Ali hasan
fonte
1
Ajuda se você der exemplos para initin Array<Int>()e IntArray(), sua resposta não é muito útil a partir de agora.
Lars Blumberg
A resposta foi modificada
Ali hasan
A matriz <Int> fornece uma matriz de números inteiros em caixa, enquanto o IntArray fornece uma matriz int real.
Mike
4

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.

Andy
fonte
3

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"]

Alf Moh
fonte
3

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

zyc zyc
fonte
2

Você pode tentar isso:

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

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)
s1m0nw1
fonte
2

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>

hdkrus
fonte
2
Eu recebi o seguinte erro com este código: Não suportado [Literais de coleções fora das anotações] #
Rémi P
Eu não vi isso antes. Essa sintaxe é nova no Kotlin?
Lars Blumberg
@LarsBlumberg, provavelmente, eu só comecei a usar Kotlin recentemente com IntelliJ 2.019,1 e eu inicializado uma matriz de cadeia como eu mostrei e ele funcionou
hdkrus
@ RémiP, Bom ponto, usei-o em argumentos de anotações. Mas isso significaria que literais de matriz funcionam em alguns contextos e em outros não?
hdkrus
1
@hdkrus Por que você não atualiza sua resposta para mostrar como a inicialização de uma matriz funciona com anotações? Isso pode ser útil para muitos leitores dessas perguntas.
Lars Blumberg
1

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

}
Rahul
fonte
Isso realmente não responde à pergunta de maneira sensata.
Qwerp-Derp
Por favor, verifique o comentário no qual eu usei a função lambda para adicionar itens.
Rahul
Isso ainda parece uma maneira complicada de resolver esse problema, pelo menos em comparação com as outras respostas. Também olhei para a minha mensagem anterior e parece dura em retrospecto - me desculpe.
Qwerp-Derp
Isso é bom, não há problema. Eu apenas tentei responder de uma maneira que resolvesse meu problema, não o comparei com outras respostas. Obrigado!
Rahul
1

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)
}
Nihal Desai
fonte
Embora esse código possa responder à pergunta, fornecer um contexto adicional a respeito de por que e / ou como esse código responde à pergunta melhora seu valor a longo prazo.
Rollstuhlfahrer
1

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)
Samad Talukder
fonte
1

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)

Zafar Iqbal
fonte
0

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

Abhilash Das
fonte
0

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

 val values: IntArray = intArrayOf(1, 2, 3, 4, 5,6,7)
Nikhil Katekhaye
fonte
Embora esse código possa responder à pergunta, fornecer um contexto adicional a respeito de como e / ou por que ele resolve o problema melhoraria o valor a longo prazo da resposta.
leopal 18/02
0

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}
Fahed Hermoza
fonte