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}
A 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.
Il est à noter que lorsque vous utilisez des structures Kotlin (par exemple, intArrayOf(), longArrayOf(), arrayOf(), etc.), vous ne pouvez pas initialiser le tableau avec les valeurs par défaut (ou toutes les valeurs sur la valeur souhaitée) pour une taille donnée. Vous devez l'initialiser via un appel selon constructeur de 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 un playground pour tester les fonctionnalités linguistiques.
À Kotlin, il y a plusieurs façons.
var arr = IntArray(size) // construct with only size
Il vous suffit ensuite de saisir la valeur des utilisateurs, d’une autre collection ou de n’importe où.
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
Nous pouvons aussi créer un tableau avec une fonction intégrée 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 tout type de primitive au lieu de Int.
Dans Kotlin, nous pouvons créer un tableau en utilisant les fonctions arrayOf(), intArrayOf(), charArrayOf(), booleanArrayOf(), longArrayOf().
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 cette méthode
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 (initialize)
Vous pouvez créer un tableau Int comme ceci:
val numbers = IntArray(5, { 10 * (it + 1) })
5 est la taille du tableau interne. la fonction lambda est la fonction élément init. 'it' range dans [0,4], plus 1 marque range 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 le tableau Arrays.kt
Je pense qu’une chose qui mérite d’être mentionnée et qui n’est pas assez intuitive de la documentation est que, lorsque vous utilisez une fonction 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 tel que celui-ci: val array = Array(5, { i -> i }), les valeurs initiales attribuées sont [0,1,2,3,4] et non pas, [0,0,0,0,0]. C’est pourquoi, dans la documentation, val asc = Array(5, { i -> (i * i).toString() }) génère une réponse de ["0", "1", "4", "9", "16"]
Vous pouvez simplement utiliser la bibliothèque standard existante méthodes comme indiqué ici:
val numbers = intArrayOf(10, 20, 30, 40, 50)
Toutefois, il peut être judicieux d’utiliser un constructeur spécial:
val numbers2 = IntArray(5) { (it + 1) * 10 }
Vous transmettez une taille et un lambda décrivant comment initialiser 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)
Vous pouvez essayer ceci:
var a = Array<Int>(5){0}
Je me demande pourquoi personne n'a simplement donné la plus simple des réponses:
val array: Array<Int> = [1, 2, 3]
Selon l'un des commentaires à ma réponse initiale, j'ai réalisé que cela ne fonctionne que 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 ( Name = "-h", Alias = = ""help", "-?"], utilisation = "Afficher cette aide" ) var help: Boolean = false
L'argument d'option "alias" est de type Array<String>
Le langage Kotlin a des classes spécialisées pour représenter des tableaux de types primitifs sans surcharge de boxe: par exemple, IntArray, ShortArray, ByteArray, etc. Je dois dire que ces classes n'ont pas de relation d'héritage la classe parent Array, mais ils ont le même ensemble de méthodes et de propriétés. Chacun d'entre 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
Maintenant vous pouvez l'utiliser:
myArr[0] = (myArr[1] + myArr[2]) - myArr[3]
J'espère que cela t'aides.
Déclarer int array à global
var numbers= intArrayOf()
la prochaine méthode onCreate 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)
}
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)
Modèle personnalisé
class DrawerItem(var icon: Int, var name: String) {
}
initialiser le tableau de cette manière: val paramValueList : Array<String?> = arrayOfNulls<String>(5)