jueves, febrero 05, 2009

Groovy - Referencia #12

Usando Listas - Parte 1

En Groovy el manejo de vistas es bastante abreviado y la sobrecarga de ciertos operadores también facilita la tarea, vamos a los ejemplos:

Esta línea define una lista vacía, por defecto instancia un ArrayList.
def list = []
println list.class

Salida:
class java.util.ArrayLis

Las siguientes dos líneas muestran una primera lista, como un vector de cadenas, con tres valores.
La segunda, implementa la lista como un conjunto.
def listString = ["String1", "String2", "String3"] as String []
def listSet = ["String1", "String2", "String3"] as Set
println listString.class
println listSet.class

Salida:
class [Ljava.lang.String;
class java.util.HashSet

Ahora vamos agregar algunos elementos; en Groovy contamos con el operador << para agregar nuevos elementos a la lista, los que programaron en C++, recordaran que la STL utilizaba este operador para el mismo objetivo, vamos al ejemplo.

(1..3).each { list << "String" + it }
println list


Salida:
["String1", "String2", "String3"]

No preste atencion al "(1..3)", solo basta saber que esta sentencia nos hace un siglo de 1 a 3 y lo almacena en la variable implicita "it".
El resto de la sentencia, nos muestra como se van agregando elementos a la lista, concatenando a la cadena "String" el indice actual.
Para darnos una idea, en Java esta sentencia sería algo como:

for (int i = 1; i <= 3; ++i) {

list.add ("String" + i)
}


Como notarán la sintaxis es bastante mas comoda y además me parece mas natural, ahora si queremos obtener un elemento podríamos hacer:
println "element 0 ${list [0]}"
println "element 2 ${list [2]}\n"

Salida:
element 0 String1
element 2 String3

Notese que estamos utilizando GString para obtener los elementos de la lista, para obtener un elemento utilizamos los corchetes cuadrados [i] o de la forma tradicional, get(i).
Una ventaja de utilizar los operadores [] recae en el hecho que si la lista es un vector, un set o un list, el acceso sigue siendo identico atraves de este operador.

Para cerrar este capitulo, veremos algunos closures definidos para las listas, con los cuales podemos recorrer las listas, con o sin conocer el indice actual; el primer closure es el each, veamos un ejemplo:

list.each {item -> print "${item} -- " }

Salida:
String1 -- String2 -- String3 --

Al aplicar el closure "each", necesitamos indicar una parámetro al mismo, en nuestro caso lo llamamos "item", pero usted puede colocarle el nombre que desee, vale decir que este item, es el objeto actual que se esta recorriendo en la lista, en Java una sentencia equivalente seria.

for(String item : list) {

System.out.println (item + " -- ");
}

Como nota, este closure no nos da información acerca del índice actual, para ello vayamos al siguiente y ultimo ejemplo:

list.eachWithIndex {item, index -> println "${index}) ${item}" }

Salida:
0) String1
1) String2
2) String3

Note que este closure necesita de dos parámetros, el objeto actual que esta siendo iterado y el índice actual al cual pertenece el objeto iterado, en Java haríamos algo como;

En caso que sea un collection:
for (int i = 1; i <= list.size(); ++i) {

System.out.println (i+ " ) " + list.get(i));
}

En caso de un array:
for (int i = 1; i <= list.length; ++i) {

System.out.println (i+ " ) " + list.get(i));
}

Notese de nuevo que en Groovy, la iteración tanto del array como del collection, son iguales.

Pronto la parte dos de Listas

No hay comentarios.: