Listes en Groovy

1. Vue d'ensemble

Dans Groovy, nous pouvons travailler avec des listes comme nous le faisons en Java. Mais, avec son support pour les méthodes d'extension, il est livré avec un peu plus.

Dans ce didacticiel, nous examinerons le point de vue de Groovy sur la mutation, le filtrage et le tri des listes.

2. Création de listes Groovy

Groovy fournit certains raccourcis intéressants lorsque vous travaillez avec des collections qui utilise sa prise en charge du typage dynamique et de la syntaxe littérale.

Commençons par créer une liste avec quelques valeurs en utilisant la syntaxe abrégée:

def list = [1,2,3]

De même, nous pouvons créer une liste vide:

def emptyList = []

Par défaut, Groovy crée une instance de java.util.ArrayList. Cependant, nous pouvons également spécifier le type de liste à créer :

def linkedList = [1,2,3] as LinkedList ArrayList arrList = [1,2,3]

Ensuite, les listes peuvent être utilisées pour créer d'autres listes à l'aide d'un argument constructeur:

def copyList = new ArrayList(arrList)

ou par clonage:

def cloneList = arrList.clone()

Notez que le clonage crée une copie superficielle de la liste.

Groovy utilise l'opérateur «==» pour comparer les éléments de deux listes pour l'égalité. En continuant avec l'exemple précédent, en comparant cloneList avec arrlist, le résultat est vrai:

assertTrue(cloneList == arrList)

Voyons maintenant comment effectuer certaines opérations courantes sur les listes.

3. Récupération des éléments d'une liste

Nous pouvons obtenir un élément d'une liste en utilisant la syntaxe littérale telle que:

def list = ["Hello", "World"] assertTrue(list[1] == "World")

ou en utilisant les méthodes get () et getAt () :

assertTrue(list.get(1) == "World") assertTrue(list.getAt(1) == "World")

Nous pouvons également obtenir des éléments d'une liste en utilisant à la fois des indices positifs et négatifs. Lorsqu'un index négatif est utilisé, la liste est lue de droite à gauche:

assertTrue(list[-1] == "World") assertTrue(list.getAt(-2) == "Hello")

Notez que la méthode get () ne prend pas en charge les index négatifs.

4. Ajout d'éléments à une liste

Il existe plusieurs méthodes abrégées pour ajouter des éléments à la liste. Définissons une liste vide et ajoutons-y quelques éléments:

def list = [] list << 1 list.add("Apple") assertTrue(list == [1, "Apple"])

Ensuite, nous pouvons également spécifier l'index sur lequel placer l'élément. De plus, si la longueur de la liste est inférieure à l'index spécifié, Groovy ajoute autant de valeurs nulles que la différence :

list[2] = "Box" list[4] = true assertTrue(list == [1, "Apple", "Box", null, true])

Enfin, nous pouvons utiliser l' opérateur « + =» pour ajouter de nouveaux éléments à la liste. Par rapport aux autres approches, cet opérateur crée un nouvel objet liste et l'assigne à la liste de variables :

def list2 = [1,2] list += list2 list += 12 assertTrue(list == [1, 6.0, "Apple", "Box", null, true, 1, 2, 12])

5. Mise à jour des éléments d'une liste

Nous pouvons mettre à jour les éléments d'une liste en utilisant la syntaxe littérale ou la méthode set () :

def list =[1, "Apple", 80, "App"] list[1] = "Box" list.set(2,90) assertTrue(list == [1, "Box", 90, "App"])

Dans cet exemple, les éléments aux index 1 et 2 sont mis à jour avec de nouvelles valeurs.

6. Suppression d'éléments d'une liste

Nous pouvons supprimer un élément à un index particulier en utilisant la méthode remove () :

def list = [1,2,3,4,5,5,6,6,7] list.remove(3) assertTrue(list == [1,2,3,5,5,6,6,7])

Ou nous pouvons également supprimer un élément en utilisant la méthode removeElement () . Cela supprime la première occurrence de l'élément de la liste:

list.removeElement(5) assertTrue(list == [1,2,3,5,6,6,7])

De plus, nous pouvons utiliser l' opérateur moins pour supprimer toutes les occurrences d'un élément de la liste . Cet opérateur, cependant, ne modifie pas la liste sous-jacente - il renvoie une nouvelle liste:

assertTrue(list - 6 == [1,2,3,5,7])

7. Itération sur une liste

Groovy a ajouté de nouvelles méthodes à l' API Java Collections existante . Ces méthodes simplifient les opérations telles que le filtrage, la recherche, le tri, l'agrégation, etc. en encapsulant le code standard. Ils prennent également en charge un large éventail d'entrées, y compris les fermetures et les structures de données de sortie.

Commençons par examiner les deux méthodes d'itération sur une liste.

La méthode each () accepte une fermeture et est très similaire à la méthode foreach () en Java. Groovy passe un paramètre implicite ce qui correspond à l'élément courant dans chaque itération:

def list = [1,"App",3,4] list.each {println it * 2}

L'autre méthode, eachWithIndex () fournit la valeur d'index actuelle en plus de l'élément actuel:

list.eachWithIndex{ it, i -> println "$i : $it" }

8. Filtrage

Le filtrage est une autre opération fréquemment effectuée sur les listes, et Groovy propose de nombreuses méthodes différentes.

Définissons une liste sur laquelle opérer:

def filterList = [2,1,3,4,5,6,76]

Pour trouver le premier objet qui correspond à une condition, nous pouvons utiliser find :

assertTrue(filterList.find {it > 3} == 4)

Pour trouver tous les objets qui correspondent à une condition, nous pouvons utiliser findAll :

assertTrue(filterList.findAll {it > 3} == [4,5,6,76])

Regardons un autre exemple. Ici, nous voulons une liste de tous les éléments qui sont des nombres:

assertTrue(filterList.findAll {it instanceof Number} == [2,1,3,4,5,6,76])

Alternativement, nous pouvons utiliser la méthode grep pour faire la même chose:

assertTrue(filterList.grep( Number ) == [2,1,3,4,5,6,76])

La différence entre les méthodes grep et find est que grep peut accepter un objet ou une fermeture comme argument. Ainsi, cela permet de réduire davantage la déclaration de condition au strict minimum:

assertTrue(filterList.grep {it > 6} == [76])

De plus, grep utilise Object # isCase (java.lang.Object) pour évaluer la condition sur chaque élément de la liste.

Parfois, nous ne sommes intéressés que par les éléments uniques d'une liste . Il existe deux méthodes surchargées que nous pouvons utiliser à cette fin.

La méthode unique () accepte facultativement une fermeture et ne conserve dans la liste sous-jacente que les éléments qui correspondent aux conditions de fermeture tout en rejetant les autres. Il utilise l'ordre naturel par défaut pour déterminer l'unicité:

def uniqueList = [1,3,3,4] uniqueList.unique() assertTrue(uniqueList == [1,3,4])

Alternativement, si l'exigence n'est pas de muter la liste sous-jacente, nous pouvons utiliser la méthode toUnique () :

assertTrue(["A", "B", "Ba", "Bat", "Cat"].toUnique {it.size()} == ["A", "Ba", "Bat"])

Si nous voulons vérifier que certains ou tous les éléments d'une liste satisfont à une certaine condition, nous pouvons utiliser les méthodes every () et any () .

La méthode every () évalue la condition de la fermeture par rapport à chaque élément de la liste. Ensuite, il ne renvoie vrai que si tous les éléments de la liste satisfont à la condition:

def conditionList = [2,1,3,4,5,6,76] assertFalse(conditionList.every {it < 6})

La méthode any () , en revanche, retourne true si un élément de la liste satisfait la condition:

assertTrue(conditionList.any {it % 2 == 0})

9. Tri

Par défaut, Groovy trie les éléments dans une liste en fonction de leur ordre naturel:

assertTrue([1,2,1,0].sort() == [0,1,1,2])

Mais nous pouvons également passer un comparateur avec une logique de tri personnalisée :

Comparator mc = {a,b -> a == b? 0: a < b? 1 : -1} def list = [1,2,1,0] list.sort(mc) assertTrue(list == [2,1,1,0])

De plus, nous pouvons utiliser les méthodes min () ou max () pour trouver la valeur maximale ou minimale sans appeler explicitement sort ():

def strList = ["na", "ppp", "as"] assertTrue(strList.max() == "ppp")
Comparator minc = {a,b -> a == b? 0: a < b? -1 : 1} def numberList = [3, 2, 0, 7] assertTrue(numberList.min(minc) == 0)

10. Collecte

Parfois, nous souhaitons modifier les éléments d'une liste et renvoyer une autre liste avec des valeurs mises à jour. Cela peut être fait en utilisant la méthode collect () :

def list = ["Kay","Henry","Justin","Tom"] assertTrue(list.collect{"Hi " + it} == ["Hi Kay","Hi Henry","Hi Justin","Hi Tom"])

11. Rejoindre

Parfois, nous pouvons avoir besoin de joindre les éléments dans une liste. Pour ce faire, nous pouvons utiliser la méthode join () :

assertTrue(["One","Two","Three"].join(",") == "One,Two,Three")

12. Conclusion

Dans cet article, nous avons couvert quelques-unes des extensions que Groovy ajoute à l' API Java Collections .

Nous avons commencé par examiner la syntaxe littérale, puis son utilisation dans la création, la mise à jour, la suppression et la récupération d'éléments dans une liste.

Enfin, nous avons examiné le support de Groovy pour l'itération, le filtrage, la recherche, la collecte, la jonction et le tri des listes.

Comme toujours, tous les exemples abordés dans l'article sont disponibles à l'adresse over sur GitHub.