|
COLECCIONES
Las colecciones son una especie de arrays de tamaño dinámico. Para usarlas haremos uso del Java Collections Framework (JCF), el cual contiene un conjunto de clases e interfaces del paquete java.util para gestionar colecciones de objetos.
En Java las principales interfaces que disponemos para trabajar con colecciones son: Collection, Set, List, Queue y Map:
- Collection<E>: Un grupo de elementos individuales, frecuentemente con alguna regla aplicada a ellos.
- List<E>: Elementos en una secuencia particular que mantienen un orden y permite duplicados. La lista puede ser recorrida en ambas direcciones con un ListIterator. Hay 3 tipos de constructores:
- ArrayList<E>: Su ventaja es que el acceso a un elemento en particular es ínfimo. Su desventaja es que para eliminar un elemento, se ha de mover toda la lista para eliminar ese “hueco”.
- Vector<E>: Es igual que ArrayList, pero sincronizado. Es decir, que si usamos varios hilos, no tendremos de qué preocuparnos hasta cierto punto.
- LinkedList<E>: En esta, los elementos están conectados con el anterior y el posterior. La ventaja es que es fácil mover/eliminar elementos de la lista, simplemente moviendo/eliminando sus referencias hacia otros elementos. La desventaja es que para usar el elemento N de la lista, debemos realizar N movimientos a través de la lista.
Veamos un ejemplo de List:
- Set<E>: No puede haber duplicados. Cada elemento debe ser único, por lo que si existe uno duplicado, no se agrega. Por regla general, cuando se redefine equals(), se debe redefinir hashCode(). Es necesario redefinir hashCode() cuando la clase definida será colocada en un HashSet. Los métodos add(o) y addAll(o) devuelven false si o ya estaba en el conjunto.
- Queue<E>: Colección ordenada con extracción por el principio e inserción por el principio (LIFO – Last Input, First Output) o por el final (FIFO – First Input, First Output). Se permiten elementos duplicados. No da excepciones cuando la cola está vacía/llena, hay métodos para interrogar, que devuelven null. Los métodos put()/take() se bloquean hasta que hay espacio en la cola/haya elementos.
- Map<K,V>: Un grupo de pares objeto clave-valor, que no permite duplicados en sus claves. Es quizás el más sencillo, y no utiliza la interfaz Collection. Los principales métodos son: put(), get(), remove().
- HashMap<K,V>: Se basa en una tabla hash, pero no es sincronizado.
- HashTable<K,V>: Es sincronizado, aunque que no permite null como clave.
- LinkedHashMap<K,V>: Extiende de HashMap y utiliza una lista doblemente enlazada para recorrerla en el orden en que se añadieron. Es ligeramente más rápida a la hora de acceder a los elementos que su superclase, pero más lenta a la hora de añadirlos.
- TreeMap<K,V>: Se basa en una implementación de árboles en el que ordena los valores según las claves. Es la clase más lenta.
Ejemplo de Map:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
import java.util.*;
public class Ejemplo
{
public static void main(String args[])
{
HashMap global = new HashMap();
global.put("Laura", "667895789");
global.put("Pepe", "645895756");
global.put("Abelardo", "55895711");
global.put("Daniel", "667111788");
global.put("Arturo", "667598623");
for( Iterator it = global.keySet().iterator(); it.hasNext();) {
String s = (String)it.next();
String s1 = (String)global.get(s);
System.out.println("Alumno: "+s + " - " + "Telefono: "+s1);
}
}
}
|
- Otros tipos de colecciones: singleton(), singletonList(), singletonMap(). Devuelven conjunto, lista y mapa inmutables, con un único elemento. Útiles para pasar un elemento a un método que espera una colección.
- El siguiente código es un ejemplo de Colecciones:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
import java.util.*;
public class EjemploColecciones {
public static void main(String[] args) {
Collection<String> col1 = new HashSet<String>();
Collection<String> col2 = Arrays.asList("valor1", "valor2");
Collection<String> col3 = Collections.singleton("valor3");
if (col1.add("cero"))
System.out.println ("col1 modificada");
if (col1.addAll(col2))
System.out.println ("col1 modificada");
Collection<String> copia = new ArrayList<String>(col1);
col1.remove("cero");
col1.removeAll(col3);
col1.retainAll(col2);
col1.clear();
boolean b = col1.isEmpty();
int s = col1.size();
b = col1.addAll(copia);
b = col1.contains("cero");
b = col1.containsAll(col2);
Iterator<String> iterador = col1.iterator();
while(iterador.hasNext())
System.out.println(iterador.next());
for(Iterator<String> i = col1.iterator(); i.hasNext();)
System.out.println(i.next());
for(String word : col1) System.out.println(word);
System.out.println(col1);
Object[] elementos = col1.toArray();
String[] strings = col1.toArray(new String[col1.size()]);
strings = col1.toArray(new String[0]);
}
}
|
El resultado que produce este código es el siguiente:
Para poder iterar sobre ellos, es necesario un objeto Iterator como hemos visto en el ejemplo.
Para compararlos, es necesario un objeto comparable. Para ello, es necesario que nuestra clase implemente a la clasejava.lang.Comparable, y usar el método int compareTo(Object o). El método compareTo() devuelve un entero con las siguientes características:
- Negativo: Si thisObject < anotherObject
- Cero: Si thisObject == anotherObject
- Positivo: Si thisObject > anotherObject
En este ejemplo comparamos cadenas ignorando mayúsculas y minúsculas, e imprimiendo el resultado por orden alfabético:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
import java.util.*;
public class Principal {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new Comparacion ());
ts.add("Alonso");
ts.add("alonso");
ts.add("Conchi");
ts.add("Emilio");
ts.add("Gómez");
ts.add("manuela");
ts.add("Manuela");
System.out.println(ts);
}
}
import java.util.*;
class Comparacion implements Comparator {
public int compare(Object o1, Object o2) {
return ((String) o1).compareToIgnoreCase((String) o2);
}
}
|
El resultado es el siguiente: 
En este ejemplo utilizamos la interface Comparable para comprobar objetos iguales:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
import java.util.*;
public class Principal {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Persona("Pepe", "Perez"));
ts.add(new Persona("Pipi", "Perez"));
ts.add(new Persona("Manolito", "Cascos"));
ts.add(new Persona("Pipi", "Perez"));
ts.add(new Persona("Sara", "Alonso"));
System.out.println(ts);
}
}
import java.util.*;
public class Persona implements Comparable {
private String Nombre, apellido;
public String Nombre(){
return Nombre;
}
public String apellido() {
return apellido;
}
public Persona(String Nombre, String apellido) {
if (Nombre==null || apellido==null)
throw new NullPointerException();
this.Nombre = Nombre;
this.apellido = apellido;
}
public boolean equals(Object o) {
if (!(o instanceof Persona))
return false;
Persona n = (Persona)o;
return n.Nombre.equals(Nombre) &&
n.apellido.equals(apellido);
}
public int hashCode() {
return 31 * Nombre.hashCode() + apellido.hashCode();
}
public String toString() {
return Nombre + " " + apellido;
}
public int compareTo(Object o) {
Persona n = (Persona)o;
int lastCmp = apellido.compareTo(n.apellido);
return (lastCmp!=0 ? lastCmp : Nombre.compareTo(n.Nombre));
}
}
|
Y el resultado: 
TIPOS GENÉRICOS
Los tipos genéricos permiten forzar la seguridad de los tipos, en tiempo de compilación, en las colecciones (u otras clases y métodos que utilicen tipos parametrizados).
El problema que resuelven es que si al crear una colección de un tipo determinado, pongamos String, yo meto un elemento de tipo entero, entonces me dará una excepción. Los genéricos ayudaron a crear una comprobación de tipo en listas y mapas en tiempo de compilación, anteriormente esto no era posible. Otra cosa que podemos hacer en con los tipos parametrizados o genéricos es crear nuestras propias clases.
Veamos el problema y la solución con tipos genéricos:
Es decir, básicamente es un tipo “inventado” al cual le decimos de qué tipo queremos que nos pase los datos y él internamente, hace los diferentes castings que haya que hacerle a los dieferentes elementos de la colección, siendo los tipos de éstos transparentes para nosotros.
Las convenciones de declaración utilizan la letra T para tipos y E para elementos de una colección. Se puede utilizar más de un tipo parametrizado en una declaración. Por convención los tipos parametrizados son letras solitarias mayúsculas, sin esta convención sería difícil leer el código y decir la diferencia entre una variable parametrizada y una clase ordinaria o un nombre de una interface.
- E – Elemento (Usado extensivamente en las colecciones en java)
- K – Key
- N – Number
- T – Type
- V – Value
- S, U, V etc. – 2nd, 3rd, 4th types
|
