Share
Kotlin est un langage de programmation moderne qui compile en bytecode Java. C'est gratuit et open source, et promet de rendre le codage pour Android encore plus amusant.
Dans le précédent article de cette série, vous avez appris à propos de l'annulation, des boucles et des conditions dans Kotlin. Dans ce didacticiel, nous allons continuer à apprendre le langage en consultant l'API des gammes et des collections dans Kotlin..
Une plage en Kotlin est un type unique qui définit une valeur de début et une valeur de fin. En d'autres termes, il s'agit d'un intervalle entre une valeur de début et une valeur de fin. Les plages de Kotlin sont fermées, ce qui signifie que la valeur initiale et la valeur finale sont incluses dans la plage..
Nous allons maintenant examiner les différentes façons de créer des gammes dans Kotlin..
Accentsconagua
… Opérateurval oneToFive = 1… 5
Dans le code ci-dessus, nous avons créé une plage fermée. Cette variable oneToFive comprendra les valeurs suivantes: 1, 2, 3, 4, 5. On peut y faire une boucle en utilisant le pour construction de boucle.
pour (n in oneToFive) print (n)
Le code ci-dessus peut être réduit à:
pour (n en 1… 5) print (n)
Nous pouvons également créer une gamme de caractères:
val aToZ = "a"… "z"
La variable de A à Z aura toutes les lettres de l'alphabet anglais.
rangeTo () Une fonctionle … l'opérateur peut être remplacé par le rangeTo () fonction d'extension pour créer une plage. Par exemple, nous pouvons aussi le faire 1.rangeTo (5) et il aurait toujours les mêmes résultats que d'utiliser le … opérateur comme discuté précédemment.
val oneToFive: IntRange = 1.rangeTo (5)
vers le bas () Une fonctionC'est une autre fonction d'extension qui va créer une plage allant d'un nombre donné à un autre..
val fiveToOne = 5.downTo (1)
Nous pouvons modifier la plage en utilisant le étape() une fonction. Cela modifiera le delta entre chaque élément de la plage.
val oneToTenStep = 1… 10 step 2 // 1, 3, 5, 7, 9
Le code ci-dessus contiendra des nombres impairs entre 1 et 10.
dans Opérateurle dans l'opérateur est utilisé pour déterminer si une valeur est présente dans une plage donnée.
if (5 in 1… 10) print ("Oui 5 est dans la plage") // affiche "Oui 5 est dans la plage"Dans le code ci-dessus, nous avons vérifié si 5 est compris entre 1 et 10 en utilisant le dans opérateur. Nous pouvons aussi faire le contraire en utilisant !n vérifier si 5 n'est pas dans la plage.
Les collections sont utilisées pour stocker des groupes d'objets liés en mémoire. Dans une collection, nous pouvons récupérer, stocker ou organiser les objets. Kotlin fournit son API de collections sous la forme d'une bibliothèque standard construite sur l'API Java Collections. (Nous discuterons des interfaces dans Kotlin dans un prochain article.)
Notez que ces interfaces sont liées à leur implémentation lors de la compilation. Vous ne pouvez pas voir le code source de l'implémentation dans Kotlin, car les collections sont en réalité implémentées par les collections Java standard telles que ArrayList, Plans, HashMap, Ensembles, HashSet, liste etc. Pour bien comprendre les API de collections dans Kotlin, vous devez être familiarisé avec ces classes et interfaces de base en Java..
Dans cette section, nous allons en apprendre davantage sur la liste, Ensemble et Carte collections à Kotlin. (Si vous souhaitez un rafraîchissement des tableaux de Kotlin, veuillez visiter le premier tutoriel de cette série.)
Les collections de Kotlin nous permettent d’obtenir beaucoup avec un peu de code, contrairement à Java, qui semble avoir besoin de beaucoup de code pour en obtenir un peu! Kotlin a deux variantes de collections: mutable et immuable. Une collection mutable nous permet de modifier une collection en ajoutant, supprimant ou remplaçant un élément. Les collections immuables ne peuvent pas être modifiées et ne disposent pas de ces méthodes auxiliaires.
Notez que l'ajout, la suppression ou le remplacement d'un élément dans une collection immuable est possible via des fonctions d'opérateur (nous y reviendrons dans quelques instants), mais elles finiront par créer une nouvelle collection..
Iterable InterfaceLe kotlin Iterable l'interface est au sommet de la hiérarchie des classes de collections. Cette interface permet de représenter les collections sous la forme d’une séquence d’éléments (qui peuvent être itérés naturellement).
interface publique Iterableopérateur abstrait public fun iterator (): Iterator
Collection InterfaceLe kotlin Collection l'interface étend la Iterable interface. le Collection l'interface est immuable. En d'autres termes, vous avez un accès en lecture seule aux collections. le Ensemble et liste Les interfaces (plus à propos de celles-ci bientôt) dans Kotlin étendent cette interface.
Certaines des fonctions et propriétés disponibles dans le Collection interface sont:
Taille: cette propriété retourne la taille de la collection.est vide(): renvoie true si la collection est vide ou false sinon. contient (élément: E): renvoie vrai si l'élément spécifié dans l'argument est présent dans la collection.containsAll (element: Collection) : retourne vrai si l'élément de la collection passé en argument est présent dans la collection. Collection d'interface publique: Iterable public val size: Int public fun isEmpty (): Opérateur booléen fun que contient (élément: @UnsafeVariance E): Boolean écrasera fun iterator (): Iterator amusement public contientTous (éléments: Collection<@UnsafeVariance E>): Boolean
MutableIterable InterfaceCette interface en Kotlin nous donne un itérateur spécialisé modifiable du parent Iterable interface.
interface publique MutableIterable: Iterable redéfinit fun iterator (): MutableIterator
MutableCollection Interfacele MutableCollection interface dans Kotlin est une interface spécialisée qui permet aux collections d’être mutables. En d'autres termes, des opérations d'ajout et de suppression peuvent être effectuées sur une collection donnée. Cette interface étend les deux Collection interface et la MutableIterable interface déjà discuté ci-dessus. le MutableSet et MutableList Les interfaces (nous y reviendrons sous peu) de Kotlin étendent cette interface. Les fonctions disponibles dans cette interface, en dehors de celles disponibles dans ses parents, sont:
add (élément: E): ajoute l'élément passé en tant qu'argument à la collection et renvoie true en cas de succès ou false si la collection ne prend pas en charge les doublons et si l'élément est déjà présent.supprimer (élément: E): supprime l'élément passé en tant qu'argument de la collection. Renvoie true en cas de succès ou false s'il n'était pas présent dans la collection..addAll (elements: Collection) : ajoute tous les éléments de la collection passés en arguments à la collection. Renvoie true en cas de succès ou false si rien n'a été ajouté.removeAll (elements: Collection) : supprime tous les éléments présents dans la collection passés en arguments. Renvoie true en cas de succès ou false en l'absence de suppression.rétentionTous (éléments: Collection) : conserve uniquement les éléments présents dans les collections transmises en tant qu'arguments. Renvoie true en cas de succès ou false si rien n'a été conservé. clair(): supprime tous les éléments de cette collection.interface publique MutableCollection: Collection , MutableIterable redéfinit fun iterator (): MutableIterator amusement public add (élément: E): Booléen amusement public remove (élément: E): Booléen amusement public addAll (éléments: Collection ): Boolean public fun supprimerTous (éléments: Collection ): Boolean Public Fun RetenirTout (éléments: Collection ): Boolean public fun clear (): Unit
Maintenant que vous connaissez les principales interfaces de la hiérarchie des classes de collection dans Kotlin, examinons maintenant la manière dont Kotlin gère les collections telles que Lists, Sets et Maps dans la partie restante du didacticiel..
Une liste est une collection ordonnée d'éléments. Ceci est une collection populaire qui est largement utilisée. Regardons différentes manières de créer une liste dans Kotlin.
liste de() Une fonctionDans Kotlin, nous pouvons créer une liste immuable (en lecture seule) en utilisant le liste de() fonction d'assistance de la bibliothèque standard Kotlin. Cette fonction retourne un Kotlin liste type d'interface.
numéros var: liste= listOf (1, 2, 3, 4, 5) noms divers: Liste = listOf ("Chike", "Nnamdi", "Mgbemena") pour (nom dans les noms) println (nom)
L'exécution du code ci-dessus imprimera:
Chike Nnamdi Mgbemena
De plus, nous pouvons passer des valeurs de types différents dans le liste de() comme arguments et le résultat fonctionnera toujours - ce sera une liste de types mélangés.
var listMixedTypes = listOf ("Chike", 1, 2.445, 's') // sera toujours compilé emptyList () Une fonctionCette fonction crée simplement une liste immuable vide et retourne un Kotlin liste type d'interface.
val emptyList: List= liste vide ()
listOfNotNull () Une fonctionCette fonction crée une nouvelle liste immuable contenant uniquement des éléments non nuls. Notez que cette fonction retourne un Kotlin liste type d'interface aussi.
val nonNullsList: List= listOfNotNull (2, 45, 2, null, 5, null)
le liste L’interface de la bibliothèque standard Kotlin ne s'étend qu’à la Collection interface. En d’autres termes, son seul parent est le Collection interface. Il remplace toutes les fonctions de l'interface parente pour répondre à ses besoins spécifiques et définit également ses propres fonctions, telles que:
get (index: Int): un opérateur de fonction qui renvoie l'élément à l'index spécifié. indexOf (élément: E): retourne l'index de la première occurrence de l'élément passé en tant qu'argument dans la liste, ou -1 si aucun n'est trouvé.lastIndexOf (élément: E): renvoie l'index de la dernière occurrence de l'élément passé en tant qu'argument dans la liste, ou -1 si aucun n'est trouvé. listIterator (): retourne un itérateur de liste sur les éléments de la liste.sous-liste (fromIndex: Int, toIndex: Int): retourne une liste contenant la partie de la liste entre les index de début et de fin spécifiés. println (names.size) // 3 println (names.get (0)) // "Chike" println (names.indexOf ("Mgbemena")) // 2 println (names.contains ("Nnamdi")) // 'vrai'arrayListOf () Une fonctionCeci crée une liste mutable et retourne un fichier Java. ArrayList type.
val stringList: ArrayList= arrayListOf ("Salut toi")
mutableListOf () Une fonctionPour ajouter, supprimer ou remplacer des valeurs dans une liste, nous devons rendre la liste modifiable. Nous pouvons convertir une liste immuable en liste mutable en appelant la fonction toMutableList () sur la liste. Cependant, notez que cette méthode créera une nouvelle liste.
var mutableNames1 = names.toMutableList () mutableNames1.add ("Ruth") // maintenant mutable et a ajouté "Ruth" à la listePour créer une liste modifiable d’un certain type à partir de rien, par exemple. Chaîne, nous utilisons mutableListOf, tandis que pour les types mixtes, nous pouvons simplement utiliser le mutableListOf () fonction à la place.
// une liste modifiable d'un certain type, par ex. String val mutableListNames: MutableList= mutableListOf ("Josh", "Kene", "Sanya") mutableListNames.add ("Mary") mutableListNames.removeAt (1) mutableListNames [0] = "Oluchi" // remplace l'élément de l'index 0 par "Oluchi" // a mutable liste de types mélangés val mutableListMixed = mutableListOf ("BMW", "Toyota", 1, 6.76, 'v')
Chacune de ces fonctions retournera un MutableList Type d'interface Kotlin. Cette interface étend les deux MutableCollection et liste interfaces discutées plus haut dans cette section. le MutableList interface ajoute des méthodes pour la récupération ou la substitution d'un élément en fonction de sa position:
ensemble (index: Int, élément: E): substitue un élément de la liste par un autre élément. Ceci retourne l'élément précédemment à la position spécifiée.add (index: Int, élément: E): insère un élément à l'index spécifié. removeAt (index: Int): se débarrasse de l'élément à un index particulier. val mutableListFood: MutableList= mutableListOf ("Riz et ragoût", "Riz Jollof", "Eba & Egusi", "Riz frit") mutableListFood.remove ("Riz frit") mutableListFood.removeAt (0) mutableListFood.set (0, "Beans") mutableListFood. add (1, "Pain et thé") pour (foodName dans mutableListFood) println (foodName)
En exécutant le code ci-dessus, nous produisons le résultat suivant:
Haricots Pain et thé Eba & Egusi
Notez que toutes ces fonctions créent une Java ArrayList Dans les coulisses.
Un ensemble est une collection non ordonnée d'éléments uniques. En d'autres termes, il ne peut pas y avoir de doublons! Examinons quelques-unes des différentes façons de créer un ensemble dans Kotlin. Chacune de celles-ci crée une structure de données différente, chacune optimisée pour un certain type de tâche..
ensemble de() Une fonctionPour créer un ensemble immuable (en lecture seule) dans Kotlin, nous pouvons utiliser la fonction ensemble de(), qui retourne un Kotlin Ensemble type d'interface.
// crée un ensemble immuable de types mélangés val mixedTypesSet = setOf (2, 4.454, "comment", "loin", 'c') // compilera var intSet: Set= setOf (1, 3, 4) // seuls les types entiers sont autorisés
Notez que le Kotlin Ensemble l'interface ne s'étend qu'au Kotlin Collection interface et remplace toutes les propriétés disponibles dans son parent.
hashSetOf () Une fonction En utilisant le hashSetOf () fonction crée un Java HashSet collection qui stocke des éléments dans une table de hachage. Parce que cette fonction retourne un Java HashSet type, nous pouvons ajouter, supprimer ou effacer des éléments de l’ensemble. En d'autres termes, c'est mutable.
val intsHashSet: java.util.HashSet= hashSetOf (1, 2, 6, 3) intsHashSet.add (5) intsHashSet.remove (1)
triéSetOf () Une fonctionEn utilisant le triéSetOf () fonction crée un Java TreeSet collection en coulisse, qui classe les éléments en fonction de leur ordre naturel ou par un comparateur. Cet ensemble est également mutable.
val intsSortedSet: java.util.TreeSet= triéSetOf (4, 1, 7, 2) intsSortedSet.add (6) intsSortedSet.remove (1) intsSortedSet.clear ()
linkedSetOf () Une fonctionCette fonction retourne un Java LinkedHashSet type. Cet ensemble mutable maintient une liste chaînée des entrées de l'ensemble, dans l'ordre dans lequel elles ont été insérées..
val intsLinkedHashSet: java.util.LinkedHashSet= linkedSetOf (5, 2, 7, 2, 5) // 5, 2, 7 intsLinkedHashSet.add (4) intsLinkedHashSet.remove (2) intsLinkedHashSet.clear ()
mutableSetOf () Une fonctionOn peut utiliser mutableSetOf () pour créer un ensemble mutable. Cette fonction retourne un Kotlin MutableSet type d'interface. En coulisse, cette fonction crée simplement un fichier Java. LinkedHashSet.
// crée un ensemble modifiable de types int uniquement val intsMutableSet: MutableSet= mutableSetOf (3, 5, 6, 2, 0) intsMutableSet.add (8) intsMutableSet.remove (3)
le MutableSet l'interface s'étend à la fois MutableCollection et le Ensemble interfaces.
Les cartes associent des clés aux valeurs. Les clés doivent être uniques, mais les valeurs associées ne doivent pas nécessairement l'être. Ainsi, chaque clé peut être utilisée pour identifier de manière unique la valeur associée, car la carte garantit que vous ne pouvez pas avoir de clés dupliquées dans la collection. En coulisse, Kotlin utilise le langage Java Carte collection pour implémenter son type de collection de cartes.
carte de() Une fonctionPour créer un immuable ou en lecture seule Carte collection à Kotlin, nous utilisons le carte de() une fonction. Nous créons une carte avec cette fonction en lui donnant une liste de paires - la première valeur est la clé et la seconde est la valeur. L'appel de cette fonction retourne un Kotlin Carte type d'interface.
