GROOVY - Collections

En groovy tenemos disponibles varios tipos de colecciones que nos facilitarán bastante la vida: arrays, listas, rangos, sets y mapas. Véamos un poco cada uno de ellos.

Arrays

Los arrays en groovy son iguales que en Java. Groovy nos facilita su uso, pero tenemos las mismas limitaciones que con los arrays de Java.
def stringA = new String[3]

println stringA.size() // 3
stringA[0] = 'Eylen'
println stringA // {'Eylen',null,null}
stringA[1] = "Pepe"
stringA[2] = "Juan"
println stringA // {"Eylen","Pepe","Juan"}
println stringA[1] // "Eylen"
stringA.each{println it} // "Eylen" "Pepe" "Juan"

Listas (Lists)

Una lista es una colección ordenada de objetos, como en java. Es una implementación de la interfaz java.util.List. Veamos unos ejemplos de creación y uso, ya que seguramente las utilizaréis mucho.

//Creamos unas listas...
def emptyList = []
println emptyList.class.name // java.util.ArrayList (just Java! :) )
println emptyList.size() // 0

def list = ["Lara"]

//Ahora añadimos algunos elementos
list.add "Mark"
list << "Sara"
println list.size() // 3
println list // {"Lara","Mark","Sara"}

//Es muy fácil iterar 
list.each{println it} // Lara Mark Sara

//Y también acceder a los elementos.
println list[1] // Mark
list[1] = "Carla"
println list[1] // Carla
println list.get(1) // Carla

list.remove(2)
list-= "Carla" // El operador - está sobrecargado 
println list.size() // 1
list.each{println it} // Lara

list << "Lia"
list+="María" // El operador + también está sobrecargado
list.each{println it} //Lara Lia María
println list[-1] // María. Como veis también se puede recorrer la lista al revés.

Sets

Un Set en groovy es una colección no ordenada, sin duplicados, de elementos, como en Java. Implementa la interfaz java.util.Set. Por defecto, un set en groovy es un java.util.HashSet. Si se quiere especificar otro tipo basta con instanciarlo de la forma: def miSet = new TreeSet(). Ahora unos ejemplitos, aunque yo no lo utilizo demasiado, suele emplear más las listas, pero nunca viene mal conocerlos.

def emptySet = [] as Set
println emptySet.class.name // java.util.HashSet
println emptySet.size() // 0

def set = ["Lia","Lia"] as Set
println set  // {"Lia"} Recordemos que no hay duplicados

//La forma de acceso y modificación es igual que en las listas
set.add("Jim")
set << "Mike"
println set.size() // 3

set.each{println it}

set.remove(1)
set-="Lia"
println set // {Mike}

set+="Jim"
set+="Carla"
set.each{println it} // Mike Jim Carla

//También se puede convertir un set en una lista
def list = set as List
println list.class.name // java.util.ArrayList
println set.asList().class.name // java.util.ArrayList
println set.toList().class.name // java.util.ArrayList

Rangos (Ranges)

Un rango es una lista de valores secuenciales. Por ejemplo del 1 al 10 o de la 'a' a la 'z'. La forma de declararlo es 0..9 (así me gusta, haciendo las cosas lógicas :) ).

Un rango es una lista de cualquier elemento que implemente la interfaz java.lang.Comparable. Estos objetos tienen los métodos prev() y next() para facilitar la navegación.

Ahora unos ejemplitos, a ver si alguno os sorprende.

def numeros = 0..9
println numeros.size() //10
println numeros.contains(1) // true
numeros.each{println it} //0123456789

def letras = 'a'..'z'
println letras[1] // b
println letras.size() // 26

def exclusivo = 0..<10
println exclusivo.size() //10
println exclusico.contains(10) //false

def reverseRange = 9..0
reverseRange.each{println it} //9876543210

//Y ahora lo interesante...
for(i in 0..9)
{
   println i
}

//Pero aún podemos "mejorarlo"
(0..9).each{i->println i}

Mapas (Maps)

Bueno, un mapa en Groovy es como un mapa en Java, una colección no ordenada de pares clave/valor, donde la clave es única. Por defecto, mientras no se indique lo contrario, la implementación por defecto es java.util.LinkedHashMap (son ordenador por orden de inserción).

Si se quiere especificar otra implementación, basta con indicarlo a la hora de instanciarlo: def map = new TreeMap().

Os aconsejo que pongáis todos vuestros ojos atentos a este tipo de colección ya que echaréis mano de él muy a menudo (al menos yo lo hago :P) .

def emptyMap = [:]
println emptyMap.getClass().name // java.util.LinkedHashMap
println emptyMap.size() // 0

def mapa = ['a':'bici','b':'coche']
println mapa.size() // 2
println mapa['a'] // bici
println mapa.'a' // bici
println mapa.a // bici
println mapa.getAt("a") // bici
println mapa.get("a") // bici
println mapa.getAt("c","moto") //sorpresa, sorpresa, ahora lo tenemos en el mapa
println mapa // [a:bici, b:coche, c:moto]

mapa.d = "monopatín"
mapa.put 'e','patines'
mapa.putAt 'f','tren'
println mapa.d // monopatín
println mapa.e // patines
println mapa.f // tren

//se puede utilizar el objeto nulo como clave
mapa[null] = 'a pie'
println mapa[null] // a pie

//ahora, a iterar
mapa.each{"Clave: ${it.key} Valor: ${it.value}"}
//y con índice
mapa.each{it,i->"Posición ${i} Clave: ${it.key} Valor: ${it.value}"}
//Y si sólo queremos los valores...
mapa.values.each{println it}

Bueno, eso es todo por hoy, que ha quedado más largo de lo que esperaba. Espero que al menos le sirva a alguien.

Enjoy!

Posted in: array,collection,groovy,list,map,range,set