Mapas
Los mapas o hash son variables que pueden almacenar múltiples valores. Estos valores son accesibles a través de una clave que los identifica de manera única, de manera que no pueden existir dos claves iguales. Para crear un mapa tan solo hay que indicar la parejas separadas con comas con la siguiente sintaxis:
mapa = #{clave1:valor1, clave2:valor2, ... , claveN:valorN}
Creación de mapas en linea
Tanto las claves como los valores pueden ser de cualquier tipo, aunque, por lo general, las claves al menos si suelen ser del mismo tipo.
mapaVacio = #{}
// Claves y valores de texto
mapa2 = #{"foo": "Soy foo", "bar": "Soy bar"}
// Claves de texto y valores desconocidos (variables u objetos)
mapa1 = #{"foo": x, "bar": y}
// Claves numéricas y valores de texto (con null)
otroMapa = #{0: "nada", 43: null, 154: "foo", 201: "bar", 999: null}
// Claves de texto, valores booleanos
masMapas = #{"A":true, "B":false, "C":false, "D":true, "E":false}
Leer elementos
Para acceder a cada uno de los valores, es necesario indicar entre corchetes la clave del valor que deseamos encontrar con mapa[valor]. Si se accede a una clave que no existe, devolverá null (aunque también puede ser que la clave exista, pero que el valor almacenado en esa clave sea null).
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Accede a la clave foo (imprime Persona foo)
println mapa["foo"]
// Accede a la clave 22 (imprime Persona bar)
println mapa[22]
// Esto imprime null porque la clave "foo2" no existe
println mapa["foo2"]
Si las claves son cadenas de texto, podemos acceder a ellas directamente como si fuera una propiedad con mapa.propiedad.
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Acceso directo a la clave foo ya que es una clave de texto
println mapa.foo
// Esta es la única manera de acceder a la clave 22 (imprime Persona bar)
// ya que como NO es una cadena de texto, no podemos hacer mapa.22 porque daría un error
println mapa[22]
Distinguir un elemento con valor null de otro que no existe.
Si se accede a una clave que no existe, el valor devuelto será null, aunque también puede ser que la clave exista, pero que el valor almacenado en esa clave sea null. Por esta razón, para saber si un elemento existe o no, independientemente de si el valor almacenado es null o no, existen los métodos containsKey() o hasKey(), que nos devolverá true solo si el valor existe.
mapa = #{"existe": null}
// Las dos claves devuelven valor null, una porque existe y vale null, y la otra porque no existe.
println mapa.existe
println mapa.noExiste
// Sin embargo, containsKey() solo devolverá true en la clave que exista
// Pintará true
println mapa.containsKey("existe")
// Pintará false
println mapa.containsKey("noExiste")
Modificar o añadir elementos
Para modificar el valor de una clave, tan solo tenemos que asignárselo con el simbolo = como si de una variable normal se tratase. Se pueden crear nuevas entradas simplemente asignando un valor a una clave inexistente.
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Modifica la clave foo asignandole el nuevo valor otro
mapa.foo = "otro"
// Añadimos un nuevo elemento, asignando un valor a una clave que no existe como foo2
mapa.foo2 = "nueva entrada en el mapa"
Leer con método get(clave) y modificar con put(clave, valor) o store(clave, valor)
Los elementos también se pueden leer con el método get() y se pueden modificar o añadir con los métodos put() o store(), aunque es más cómodo utilizar los corchetes o el acceso directo en caso de claves de texto.
// Esto equivale a mapa.foo o mapa["foo"]
mapa.get("foo")
// Esto equivale a mapa.foo = "hola" o mapa["foo"] = "hola"
mapa.put("foo", "hola")
mapa.store("foo", "hola")
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#put(java.lang.Object,-java.lang.Object)
Añadir un mapa a otro mapa: método putAll(mapa)
El método putAll() añade todas las claves y valores del mapa especificado como parámetro. Si alguna clave ya existiera, se sobreescribirá con el valor del nuevo mapa. El funcionamiento interno consiste en recorrerse todas las parejas de claves/valor a añadir y llamar por cada uno de ellas al método put(). También se puede utilizar los métodos update() o merge()
mapa = #{"foo": "Persona foo"}
otromapa = #{22: "Persona bar"}
// Ahora el contenido del mapa será #{"foo": "Persona foo", 22: "Persona bar"}
mapa.putAll(otromapa)
Borrar elementos: método remove(clave,..)
Se pueden eliminar elementos en función de su clave con el método remove(clave), si es que la clave existe. Una vez eliminada, el tamaño del mapa se reducirá en uno y el método retornara true. Si la clave a borrar no se encuentra, retornará false.
El método puede recibir más de un parámetro, de esta manera se pueden eliminar varias claves en la misma llamada. En este caso, el método devuelve true o false en función de si ha conseguido borrar o no la última clave (último parámetro).
mapa = #{"foo": "Persona foo", "bar": "Persona bar", "mola": "Persona mola"}
// Borra los elementos con las clave "foo" y "mola", pinta true ya que el último elemento se
// ha encontrado. El mapa se queda en #{"bar": "Persona bar"}
println mapa.remove("foo", "mola")
// Esta clave no existe, el mapa se queda como estaba y pinta false por no haber encontrado la clave
println mapa.remove("noexiste")
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#remove(java.lang.Object)
Elimina el las claves de una lista: método removeAll(lista)
Este método recibe como parámetro una lista y se encarga de buscar y borrar los elementos de esta en la lista actual. El funcionamiento interno consiste en recorrerse todos los elementos de la colección a borrar y llamar por cada uno de ellos al método remove().
mapa = #{"foo": "Persona foo", "bar": "Persona bar", "mola": "Persona mola"}
otra = {"foo", "bar"}
// Elimina del mapa la claves de la lista, el mapa se queda solo con "mola"
mapa.removeAll(otra)
Obtener el tamaño del mapa: método size()
El método size() devuelve el tamaño del mapa. Devuelve 0 si está vacío. También se puede utilizar el método length()
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Imprime 2, que es el tamaño del mapa
println mapa.size()
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#size()
¿Mapa vacío? método isEmpty()
El método isEmpty() devuelve true si el mapa está vacío (es decir, si size() == 0). También se puede utilizar el método empty()
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Imprime false, pues no esta vacio
println mapa.isEmpty()
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#isEmpty()
Vaciar el mapa: método clear()
El método clear() vacía todos los elementos, dejando su tamaño a 0.
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
mapa.clear()
// Imprime 0, pues esta vacio
println mapa.size()
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#clear()
¿Existe una clave? método containsKey(clave)
El método containsKey() devuelve true si el parámetro especificado existe como clave en el mapa. También se puede utilizar el método hasKey()
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Imprime true, pues la clave 22 existe
println mapa.containsKey(22)
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#containsKey(java.lang.Object)
¿Existe un valor? método containsValue(valor)
El método containsValue() devuelve true si el parámetro especificado existe como valor en el mapa. También se puede utilizar el método hasValue()
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Imprime true, pues el valor "Persona foo" existe
println mapa.containsValue("Persona foo")
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#containsValue(java.lang.Object)
Claves del mapa: método keySet()
El método keySet() devuelve un conjunto iterable con todas las claves del mapa. También se puede utilizar el método keys().
El conjunto de claves devuelto está ligado con el mapa actual, de manera que si se borra una clave en este conjunto, se borra en el mapa y viceversa: si se borra en el mapa, también desaparece en este conjunto de claves.
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Este bucle se recorre todos las claves del mapa y los pinta
foreach valor : mapa.keySet()
println valor
endfor
El resultado sería:
foo 22
Ver más: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html#keySet()
Valores del mapa: método values()
El método values() devuelve una colección con todos los valores del mapa.
La colección de valores devuelta está ligada con el mapa actual, de manera que si se borra un elemento de esta colección, se borra en el mapa y viceversa: si se borra en el mapa, también desaparece en esta colección de valores.
mapa = #{"foo": "Persona foo", 22: "Persona bar"}
// Este bucle se recorre todos los valores del mapa y los pinta
foreach valor : mapa.values()
println valor
endfor
El resultado sería:
Persona foo Persona bar
Más información
Los mapas en OgnlScript se corresponden con la implementación de LinkedHashMap de Java. La ventaja de esta clase con respecto a un HashMap, es que LinkedHashMap guarda sus elementos ordenados por orden de entrada, mientras que HashMap los guarda en orden aleatorio.
- Sobre la construcción de Mapas en OGNL: http://www.ognl.org/2.6.9/Documentation/html/LanguageGuide/collectionConstruction.html
- java.util.Map: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html
- java.util.LinkedHashMap http://java.sun.com/j2se/1.4.2/docs/api/java/util/LinkedHashMap.html