Comment initialiser un tableau dans Kotlin avec des valeurs?

En Java, un tableau peut être initialisé tel que:

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

À quoi ressemble l'initialisation du tableau de Kotlin?

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

Voir Kotlin - Types de base pour plus de détails.

Vous pouvez également fournir une fonction d'initialisation comme deuxième paramètre:

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

À noter que lors de l' utilisation builtines de Kotlin (par exemple intArrayOf(), longArrayOf(), arrayOf(), etc.) , vous n'êtes pas en mesure d'initialiser le tableau avec des valeurs par défaut (ou toutes les valeurs à la valeur désirée) pour une taille donnée, au lieu que vous devez faire initialize par appel selon constructeur de la 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 }

Voici un exemple:

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

Vous pouvez également utiliser une aire de jeux pour tester les fonctionnalités du langage.

À Kotlin, il existe plusieurs façons.

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

Il suffit ensuite de donner une valeur initiale aux utilisateurs ou à une autre collection ou où vous le souhaitez.

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

Nous pouvons également créer un tableau avec des fonctions intégrées comme

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

Autrement

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.

Vous pouvez également utiliser doubleArrayOf()ou DoubleArray()ou n'importe quel type primitif au lieu de Int.

En Kotlin nous pouvons créer une matrice en utilisant arrayOf(), intArrayOf(), charArrayOf(), booleanArrayOf(), longArrayOf()fonctions.

Par exemple:

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)  

Ancienne question, mais si vous souhaitez utiliser une plage:

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

Donne presque le même résultat que:

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

résultat: 10, 20, 30, 40, 50

Je pense que la première option est un peu plus lisible. Les deux fonctionnent.

vous pouvez utiliser ces méthodes

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

exemple

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

init représente la valeur par défaut (initialiser)

Langue Kotlin a des classes spécialisées pour représenter les tableaux de types primitifs sans boxe frais généraux: par exemple - IntArray, ShortArray, ByteArray, etc. Je besoin de dire que ces classes ont aucune relation d'héritage à la société mère Arrayclasse, mais ils ont le même ensemble de méthodes et propriétés. Chacun d'eux a également une fonction d'usine correspondante. Donc, pour initialiser un tableau avec des valeurs dans Kotlin, il vous suffit de taper ceci:

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

... ou de cette façon:

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

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

Vous pouvez maintenant l'utiliser:

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

J'espère que cela t'aides.

Je pense qu'une chose qui mérite d'être mentionnée et qui n'est pas suffisamment intuitive dans la documentation est que, lorsque vous utilisez une fonction d'usine pour créer un tableau et que vous spécifiez sa taille, le tableau est initialisé avec des valeurs égales à leurs valeurs d'index. Par exemple, dans un tableau comme celui - ci: val array = Array(5, { i -> i })les valeurs initiales sont attribuées [0,1,2,3,4]et ne pas dire, [0,0,0,0,0]. C'est pourquoi à partir de la documentation, val asc = Array(5, { i -> (i * i).toString() })produit une réponse de["0", "1", "4", "9", "16"]

Vous pouvez créer un tableau Int comme ceci:

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

5 est la taille Int Array. la fonction lambda est la fonction init de l'élément. gamme 'it' dans [0,4], plus 1 gamme make dans [1,5]

la fonction d'origine est:

 /**
 * 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 définie dans Arrays.kt

Vous pouvez essayer ceci:

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

Vous pouvez simplement utiliser les méthodes de bibliothèque standard existantes , comme indiqué ici:

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

Il peut être judicieux d'utiliser un constructeur spécial:

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

Vous passez une taille et un lambda qui décrivent comment initier les valeurs. Voici la documentation:

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

Je me demande pourquoi personne n'a donné la réponse la plus simple:

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

Selon l'un des commentaires de ma réponse d'origine, j'ai réalisé que cela ne fonctionne que lorsqu'il est utilisé dans les arguments d'annotations (ce qui était vraiment inattendu pour moi).

On dirait que Kotlin ne permet pas de créer des littéraux de tableau en dehors des annotations.

Par exemple, regardez ce code en utilisant @Option de la bibliothèque args4j:

    @Option(
        nom = "-h",
        alias = ["--help", "-?"],
        usage = "Afficher cette aide"
    )
    var help: Boolean = false

L'argument d'option "alias" est de type Array<String>

Dans mon cas, j'ai besoin d'initialiser mes articles de tiroir. Je remplis les données par le code ci-dessous.

    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 modèle personnalisé

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

}

Déclarer un tableau int au niveau global

var numbers= intArrayOf()

méthode onCreate suivante initialise votre tableau avec une valeur

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, un tableau peut être initialisé tel que:

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

Mais dans Kotlin, un tableau a été initialisé de plusieurs façons, comme:

Tout type générique de tableau que vous pouvez utiliser la fonction arrayOf () :

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

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

En utilisant les fonctions utilitaires de Kotlin, un tableau peut être initialisé

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

Manière simple:

Pour Integer:

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

Conserver tous les types de données

nombre var = arrayOf (10, "valeur de chaîne", 10,5)

intialiser le tableau de cette manière: val paramValueList : Array<String?> = arrayOfNulls<String>(5)

De cette façon, vous pouvez initialiser le tableau int en koltin.

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

Ma réponse complète @maroun voici quelques façons d'initialiser un tableau:

Utilisez un tableau

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

Utilisez un tableau strict

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

Mélanger les types de matrices

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

Tableaux d'imbrication

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

Possibilité de commencer avec du code dynamique

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