arrays - initialize - kotlin longarray




Como inicializar um array no Kotlin com valores? (11)

Em Java, um array pode ser inicializado como:

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

Como é a inicialização da matriz de Kotlin?


A linguagem Kotlin tem classes especializadas para representar matrizes de tipos primitivos sem sobrecarga de boxe: por exemplo - IntArray , ShortArray , ByteArray , etc. Eu preciso dizer que essas classes não têm relação de herança com a classe Array pai, mas elas têm o mesmo conjunto de métodos e propriedades. Cada um deles também possui uma função de fábrica correspondente. Então, para inicializar um array com valores no Kotlin você só precisa digitar isto:

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

... ou assim:

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 a partir 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 que são 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 digamos, [0,0,0,0,0] . É por isso que, da documentação, val asc = Array(5, { i -> (i * i).toString() }) produz uma resposta de ["0", "1", "4", "9", "16"]


Declare array int em todo o mundo

var numbers= intArrayOf()

próximo método onCreate inicializa 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 Kotlin existem várias maneiras.

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

Então simplesmente valor inicial de usuários ou de outra coleção ou onde você quiser.

var arr = IntArray(size, { 0 } ) // construct with size and fill array with 0
var arr = IntArray(size, { it * 1 } ) // construct with size and fill with its index

Nós também podemos criar matriz com construído em função 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.


No meu caso, preciso inicializar os itens da minha gaveta. Eu preencho os dados abaixo do 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)

Classe de modelo personalizado

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

}

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

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

Produz 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 criar um Int Array assim:

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

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

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 do IntArray definida no Arrays.kt


Você pode simplesmente usar os methods biblioteca padrão existentes methods 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 um lambda que descreve 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)

intialize array desta forma: val paramValueList : Array<String?> = arrayOfNulls<String>(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)






kotlin