Elenchi in Groovy

1. Panoramica

In Groovy, possiamo lavorare con gli elenchi proprio come facciamo in Java. Ma, con il suo supporto per i metodi di estensione, viene fornito con un po 'di più.

In questo tutorial, esamineremo l'opinione di Groovy sulla modifica, il filtraggio e l'ordinamento degli elenchi.

2. Creazione di elenchi Groovy

Groovy fornisce alcune scorciatoie interessanti quando si lavora con le raccolte che fa uso del suo supporto per la digitazione dinamica e la sintassi letterale.

Iniziamo creando un elenco con alcuni valori utilizzando la sintassi abbreviata:

def list = [1,2,3]

Allo stesso modo, possiamo creare un elenco vuoto:

def emptyList = []

Per impostazione predefinita, Groovy crea un'istanza di java.util.ArrayList. Tuttavia, possiamo anche specificare il tipo di elenco da creare :

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

Successivamente, gli elenchi possono essere utilizzati per creare altri elenchi utilizzando un argomento del costruttore:

def copyList = new ArrayList(arrList)

o clonando:

def cloneList = arrList.clone()

Nota che la clonazione crea una copia superficiale dell'elenco.

Groovy utilizza l'operatore "==" per confrontare gli elementi in due elenchi per l'uguaglianza. Continuando con l'esempio precedente, confrontando cloneList con arrlist il risultato è vero:

assertTrue(cloneList == arrList)

Vediamo ora come eseguire alcune operazioni comuni sugli elenchi.

3. Recupero di elementi da un elenco

Possiamo ottenere un elemento da un elenco utilizzando la sintassi letterale come:

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

o usando i metodi get () e getAt () :

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

Possiamo anche ottenere elementi da un elenco utilizzando indici sia positivi che negativi. Quando viene utilizzato un indice negativo, l'elenco viene letto da destra a sinistra:

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

Nota che il metodo get () non supporta gli indici negativi.

4. Aggiunta di elementi a un elenco

Esistono diversi modi abbreviati per aggiungere elementi all'elenco. Definiamo un elenco vuoto e aggiungiamo alcuni elementi:

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

Successivamente, possiamo anche specificare l'indice in cui posizionare l'elemento. Inoltre, se la lunghezza dell'elenco è inferiore all'indice specificato, Groovy aggiunge tanti valori nulli quante sono le differenze :

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

Infine, possiamo usare l' operatore " + =" per aggiungere nuovi elementi alla lista. Rispetto agli altri approcci, questo operatore crea un nuovo oggetto lista e lo assegna alla lista delle variabili :

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

5. Aggiornamento degli elementi in un elenco

Possiamo aggiornare gli elementi in un elenco utilizzando la sintassi letterale o il metodo set () :

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

In questo esempio, gli elementi all'indice 1 e 2 vengono aggiornati con nuovi valori.

6. Rimozione di elementi da un elenco

Possiamo rimuovere un elemento in un particolare indice usando il metodo 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])

Oppure possiamo anche rimuovere un elemento utilizzando il metodo removeElement () . Ciò rimuove la prima occorrenza dell'elemento dall'elenco:

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

Inoltre, possiamo usare l' operatore meno per rimuovere tutte le occorrenze di un elemento dall'elenco . Questo operatore, tuttavia, non modifica l'elenco sottostante, ma restituisce un nuovo elenco:

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

7. Iterazione su un elenco

Groovy ha aggiunto nuovi metodi all'API Java Collections esistente . Questi metodi semplificano le operazioni come il filtraggio, la ricerca, l'ordinamento, l'aggregazione, ecc. Incapsulando il codice standard. Inoltre supportano un'ampia gamma di input, comprese le chiusure e le strutture dei dati di output.

Iniziamo esaminando i due metodi per l'iterazione su un elenco.

Il metodo each () accetta una chiusura ed è molto simile al metodo foreach () in Java. Scanalato passa un parametro implicito è che corrisponde all'elemento corrente in ogni iterazione:

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

L'altro metodo, eachWithIndex () fornisce il valore di indice corrente oltre all'elemento corrente:

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

8. Filtraggio

Il filtraggio è un'altra operazione che viene eseguita di frequente sugli elenchi e Groovy fornisce molti metodi diversi tra cui scegliere.

Definiamo una lista su cui operare:

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

Per trovare il primo oggetto che corrisponde a una condizione possiamo usare find :

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

Per trovare tutti gli oggetti che corrispondono a una condizione possiamo usare findAll :

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

Diamo un'occhiata a un altro esempio. Qui, vogliamo un elenco di tutti gli elementi che sono numeri:

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

In alternativa, possiamo usare il metodo grep per fare la stessa cosa:

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

La differenza tra i metodi grep e find è che grep può accettare un oggetto o una chiusura come argomento. Pertanto, consente di ridurre ulteriormente la dichiarazione della condizione al minimo indispensabile:

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

Inoltre, grep utilizza Object # isCase (java.lang.Object) per valutare la condizione su ogni elemento della lista.

A volte potremmo essere interessati solo agli elementi unici in un elenco . Ci sono due metodi sovraccaricati che possiamo usare per questo scopo.

Il metodo unique () accetta opzionalmente una chiusura e mantiene nell'elenco sottostante solo gli elementi che corrispondono alle condizioni di chiusura scartandone gli altri. Utilizza l'ordinamento naturale per impostazione predefinita per determinare l'unicità:

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

In alternativa, se il requisito non è quello di modificare l'elenco sottostante, possiamo utilizzare il metodo toUnique () :

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

Se vogliamo controllare che alcuni o tutti gli elementi in una lista soddisfino una certa condizione, possiamo usare i metodi every () e any () .

Il metodo every () valuta la condizione nella chiusura rispetto a ogni elemento nell'elenco. Quindi, restituisce vero solo se tutti gli elementi nell'elenco soddisfano la condizione:

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

Il metodo any () , d'altra parte, restituisce true se qualsiasi elemento nell'elenco soddisfa la condizione:

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

9. Ordinamento

Per impostazione predefinita, Groovy ordina gli elementi in un elenco in base al loro ordinamento naturale:

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

Ma possiamo anche passare un comparatore con logica di ordinamento personalizzata :

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])

Inoltre, possiamo usare i metodi min () o max () per trovare il valore massimo o minimo senza chiamare esplicitamente 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. Raccolta

A volte potremmo voler modificare gli elementi in un elenco e restituire un altro elenco con valori aggiornati. Questo può essere fatto usando il metodo collect () :

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

11. Partecipazione

A volte, potrebbe essere necessario unire gli elementi in un elenco. Per fare ciò possiamo il metodo join () :

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

12. Conclusione

In questo articolo, abbiamo trattato alcune delle estensioni che Groovy aggiunge all'API Java Collections .

Abbiamo iniziato osservando la sintassi letterale e quindi il suo utilizzo nella creazione, aggiornamento, rimozione e recupero di elementi in un elenco.

Infine, abbiamo esaminato il supporto di Groovy per l'iterazione, il filtraggio, la ricerca, la raccolta, l'unione e l'ordinamento di elenchi.

Come sempre tutti gli esempi discussi nell'articolo sono disponibili su GitHub.