Java >> Tutoriel Java >  >> Tag >> ArrayList

Comment initialiser une ArrayList dans Kotlin :arrayListOf et plus

Pour ceux d'entre vous qui connaissent la série How to Python, j'ai pensé qu'il serait amusant de s'essayer à d'autres langages que j'utilise ces derniers temps. Aujourd'hui, apprenons à initialiser une ArrayList dans Kotlin.

Présentation du problème

En tant que personne venue de Java, je me retrouve souvent à utiliser la classe ArrayList pour stocker des données. Malheureusement, il n'y a pas de moyen propre d'initialiser une ArrayList en Java, alors je me suis demandé si Kotlin avait amélioré ce problème. Pour référence, voici ce que je ne veux pas faire :

ArrayList<Integer> list = new ArrayList<Integer>()
list.add(7)
list.add(-4)
list.add(3)

Comme vous pouvez probablement l'imaginer, cette solution ne s'adapte pas bien. En fait, je ne pense même pas qu'il se lit bien. Il y a tout simplement trop d'informations redondantes. Je préférerais pouvoir faire quelque chose comme ceci :

ArrayList<Integer> list = new ArrayList<Integer>(7, -4, 3)

Et, pour les ensembles de données plus volumineux, il serait bien de pouvoir répartir les valeurs sur plusieurs lignes :

ArrayList<Integer> list = new ArrayList<Integer>(
    7, -4, 3, 2, 1, 3, 6, 5, 9, 11,
    10, 7, -5, -6, 13, 6, -11, 13, 2, 1
)

Malheureusement, ce n'est tout simplement pas le cas. Il existe des solutions de contournement désagréables, mais j'espérais que Kotlin améliorerait un peu les conventions Java.

Solutions

Heureusement, Kotlin a beaucoup amélioré la verbosité de Java, donc je vous promets qu'il existe un meilleur moyen de créer une ArrayList. C'est juste une question de comment.

Initialisation d'une ArrayList par Brute Force

Naturellement, nous pouvons traduire la solution Java presque directement :

val list = ArrayList<Int>()
list.add(7)
list.add(-4)
list.add(3)

Ici, nous avons créé une ArrayList vide d'entiers. Ensuite, nous avons rempli cette liste un élément à la fois en utilisant le add() méthode.

Bien sûr, nous aimerions quelque chose de mieux que ça ! Voyons ce que Kotlin a à offrir.

Initialiser une ArrayList par conversion

Une façon de réduire une partie du code ci-dessus consiste à créer un Array avant de le convertir en ArrayList :

val list = intArrayOf(7, -4, 3).toCollection(ArrayList())

En une seule ligne de code, nous sommes capables de créer un tableau d'entiers en utilisant la syntaxe idéale. A partir de ce tableau, nous pouvons obtenir une ArrayList en utilisant le toCollection() méthode et en passant une ArrayList vide. Le toCollection() La méthode remplit ensuite ArrayList avec toutes les valeurs du tableau.

Évidemment, ce n'est pas idéal car nous devons convertir entre les deux types. Il serait beaucoup plus agréable de pouvoir créer et initialiser directement une ArrayList. Heureusement, nous le pouvons !

Initialiser une ArrayList avec arrayListOf

Il s'avère que la bibliothèque de collections inclut une fonction permettant de créer directement une ArrayList dans Kotlin :

val list = arrayListOf<Int>(7, -4, 3)

Je ne sais pas exactement comment cette méthode fonctionne sous le capot, mais j'imagine qu'elle fonctionne de la même manière que notre solution de force brute :

fun <T> arrayListOf(vararg elements: T): ArrayList<T> {
    val list = ArrayList<T>()
    for (element in elements) {
        list.add(element)
    }
    return list
}

Dans tous les cas, nous avons une solution concise pour créer une ArrayList. C'est excitant !

Performances

Depuis que j'ai pris l'habitude de mesurer les performances en Python, j'ai pensé que je pouvais transférer cette idée vers Kotlin. Heureusement, il existe une fonction standard qui fera exactement cela :measureNanoTime . Nous allons l'utiliser pour tester chacun des extraits de code ci-dessus :

import kotlin.system.measureNanoTime

val bruteForceTime = measureNanoTime {
    val list = ArrayList<Int>()
    list.add(7)
    list.add(-4)
    list.add(3)
}

val conversionTime = measureNanoTime {
    val list = intArrayOf(7, -4, 3).toCollection(ArrayList())
}

val arrayListOfTime = measureNanoTime {
    val list = arrayListOf<Int>(7, -4, 3)
}

println("Brute Force: $bruteForceTime")
println("Conversion: $conversionTime")
println("ArrayListOf: $arrayListOfTime")

Dans mon cas, la méthode de la force brute était nettement plus rapide que les deux autres méthodes, mais je ne sais pas comment ces fonctions évoluent avec plus d'entrées. N'hésitez pas à essayer et tenez-moi au courant. Quoi qu'il en soit, voici les résultats :

Force brute :38 700

Conversion :14728800

ArrayListOf : 6319000

Pour ce test, j'ai fini par utiliser measureNanoTime plus de measureTimeMillis parce que je continuais à obtenir une valeur de zéro pour la méthode de la force brute. Maintenant, c'est logique !

Pour référence, j'ai tout testé sur Windows 10 en utilisant Android Studio pour configurer un fichier de travail appelé scratch.kts . De plus, j'ai utilisé Kotlin 1.3.31.

Un petit récapitulatif

Comme toujours, voici toutes les solutions en un seul endroit pratique :

// Brute force
val list = ArrayList<Int>()
list.add(7)
list.add(-4)
list.add(3)

// Array conversion
val list = intArrayOf(7, -4, 3).toCollection(ArrayList())

// Direct method
val list = arrayListOf<Int>(7, -4, 3)

Comme je commence tout juste à jouer avec Kotlin, cela peut sembler être un tutoriel assez trivial. Cela dit, je vous garantis que je vais commencer à creuser des sujets plus intéressants. Par exemple, je suis déjà ravi de commencer à refléter certains des articles Python.

Pendant que vous êtes ici, pourquoi ne pas soutenir The Renegade Coder en devenant membre. Vous aurez accès à toutes sortes d'articles amusants comme :

  • Travailler avec des étudiants difficiles
  • 11 raisons pour lesquelles j'ai abandonné ma carrière d'ingénieur

Bien sûr, vous pouvez simplement sauter sur la newsletter et décider à une date ultérieure. Quoi qu'il en soit, j'apprécie le soutien.


Balise Java