Conjuntos
Los conjuntos o sets son variables que pueden almacenar múltiples valores. Un conjunto es como un mapa (ver Mapas) en el que no se guardan valores, por lo que su comportamiento es parecido a una lista, en el sentido de que los elementos se pueden iterar normalmente. Sin embargo para acceder a ellos solo se puede hacer a través de la clave, que es el propio elemento. Los conjuntos son útiles para guardar información y luego saber si están dentro del conjunto o no.
Algunos métodos, como el método filtro() de la listas, devuelven un conjunto.
No existe una sintaxis específica para los conjuntos, por lo que para crearlos es necesario crearlos con new Set(). A este constructor se le puede especificar una lista de valores opcionalmente.
También es posible crear conjuntos a partir de una lista dada con el método createSet() de las listas
// Estos dos conjuntos son iguales
conjuntoVacio = new Set()
conjuntoVacio = {}.createSet()
// Estos dos conjuntos son iguales
conjunto = new Set( {"a", "b", "c"} )
conjunto = {"a", "b", "c"}.createSet()
// Estos dos conjuntos son iguales
otroConjunto = new Set( {1, 2, 44, 23} )
otroConjunto = {1, 2, 44, 23}.createSet()
Verificar elementos
En un conjunto no tiene sentido leer sus elementos, solo tiene sentido verificar si existen o no. Por esta razón, los elementos se leen igual que en los mapas y devuelven true si existen o false si no existen. Para hacer esto, indicar entre corchetes la clave del valor que deseamos encontrar con conjunto[valor].
conjunto = new Set( {1,2,44,23} )
// Pintará true por que el elemento 23 existe
println conjunto[23]
// Esto imprime false porque la clave "foo" no existe
println conjunto["foo"]
Si el elemento es una cadenas de texto, podemos averiguar si existe o no directamente como si fuera una propiedad con conjunto.propiedad.
conjunto = new Set( {"a", "b", "c"} )
// Equivale a conjunto["a"]
println conjunto.a
Verificar elementos usando contains(valor)
Al igual que en las listas, también es posible utilizar el método contains() para saber si un elemento existe dentro del conjunto, unque es más cómodo utilizar los corchetes o el acceso directo en caso de claves de texto. También se puede utilizar el método has()
conjunto = new Set( {"a", "b", "c"} )
// Equivale a conjunto["a"] o a conjunto.a
println mapa.contains("a")
Modificar elementos
No tiene sentido modificar un conjunto: o se añaden nuevos elementos, o se borran. Es decir, una modificación de un elemento es igual a eliminar el elemento que queremos modificar y añadir el elemento nuevo.
Pero podemos borrar y crear elementos directamente asigando true o false a su elemento con =.
conjunto = new Set( {"a", "b", "c"} )
// Borrar el elemento a
conjunto.a = false
// Volvemos a añadir el elemento a
conjunto.a = true
Añadir elementos: método add(valor,...)
Existe otra manera de añadir elementos, equivalente a su asignación con true. En este sentido, añadir elementos en un conjunto es igual que en las listas. Aunque es más cómodo utilizar los corchetes o el acceso directo en caso de claves de texto. La ventaja del método add() es que permite añadir varios elementos a la vez.
conjunto = new Set( {"a", "b", "c"} )
// Añadimos dos elementos nuevos
conjunto.add("x","y")
Añadir los elementos de una lista: método addAll(colección)
El método addAll() añade todos los elementos especificados en la colección (conjunto o lista) como parámetro. El funcionamiento interno consiste en recorrerse todos los elementos de la colección a añadir y llamar por cada uno de ellos al método add().También se puede utilizar los métodos update() o merge().
conjunto = new Set( {"a", "b", "c"} )
otra = {"x","y"}
// Ahora el conjunto tendrá 5 elementos
conjunto.addAll(otra)
Borrar elementos: método remove(valor,...)
Existe otra manera de eliminar elementos, equivalente a su asignación con false. En este sentido, eliminar elementos en un conjunto es igual que en las listas. Aunque es más cómodo utilizar los corchetes o el acceso directo en caso de claves de texto. La ventaja del método remove() es que permite eliminar varios elementos a la vez.
conjunto = new Set( {"a", "b", "c"} )
// Eliminamos dos elementos
conjunto.remove("a","b")
Elimina las claves de una lista: método removeAll(coleccion)
Este método recibe como parámetro una colección (lista o conjunto) y se encarga de buscar y borrar los elementos de esta en el conjunto. 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().
conjunto = new Set( {"a", "b", "c"} )
otra = {"a","b"}
// Elimina del conjunto los elementos de la lista, el conjunto se queda solo con "c"
conjunto.removeAll(otra)
Obtener el tamaño del conjunto: método size()
El método size() devuelve el tamaño del conjunto. Devuelve 0 si está vacío. También se puede utilizar el método length()
conjunto = new Set( {"a", "b", "c"} )
// Imprime 3
println conjunto.size()
¿Conjunto vacío? método isEmpty()
El método isEmpty() devuelve true si el conjunto está vacío (es decir, si size() == 0). También se puede utilizar el método empty()
conjunto = new Set( {"a", "b", "c"} )
// Imprime false, pues no esta vacio
println conjunto.isEmpty()
Vaciar el mapa: método clear()
El método clear() vacía todos los elementos, dejando su tamaño a 0.
conjunto = new Set( {"a", "b", "c"} )
conjunto.clear()
// Imprime 0, pues esta vacio
println conjunto.size()
¿Existe todos los elemento de una lista? método containsAll(coleccion)
El método containsAll() devuelve true si todos los elementos de la colección (lista o conjunto) pasada como parámetro existen en el conjunto. Es decir, devuelve true si la lista es un conjunto igual o subconjunto del conjunto actual. El funcionamiento interno consiste en recorrerse todos los elementos de la colección y llamar por cada uno de ellos al método contains(). También se puede utilizar el método hasAll()
lista = {"hola", "como", "estas"}
otra = {"como", "estas"}
// Imprime true, pues todos los elementos existen
println mapa.containsAll(otra)
Crear una lista a partir de un conjunto: método createList()
El método createList() devuelve una lista cuyos elementos serán los del conjunto actual. Las listas son coleciones indexadas, donde la búsqueda de elementos es secuencial y por tanto, más lenta en caso de que tenga muchos elementos (métodos indexOf(), contains(), containsAll(), remove(), removeAll()). Sin embargo, el acceso aleatorio es inmediato, pues se accede a sus elementos por su indice o posición, que es un valor numérico e indica en que lugar exacto de la lisa se encuentra el valor buscado.
conjunto = new Set({"a","b","c","c","c","d"})
// devuelve {"a","b","c","c","c","d"}
lista = conjunto.createList()
Más información
Los conjuntos en OgnlScript se corresponden con la implementación de LinkedHashSet de Java. La ventaja de esta clase con respecto a un HashSet, es que LinkedHashSet guarda sus elementos ordenados por orden de entrada, mientras que HashSet los guarda en orden aleatorio.
- Sobre la construcción de Sets en OGNL: http://www.ognl.org/2.6.9/Documentation/html/LanguageGuide/collectionConstruction.html
- java.util.Set: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Set.html
- java.util.LinkedHashSet http://java.sun.com/j2se/1.4.2/docs/api/java/util/LinkedHashSet.html