COLECCIONES

Las colecciones son una especie de arrays de tamao dinmico. 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:
1.

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.

2.

Vector<E>: Es igual que ArrayList, pero sincronizado. Es decir,

que si usamos varios hilos, no tendremos de qu preocuparnos hasta
cierto punto.

3.

LinkedList<E>: En esta, los elementos estn conectados con el

anterior y el posterior. La ventaja es que es fcil 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 travs de la lista.

Veamos un ejemplo de List:

1 import java.util.*;
2 public class Main {
3

public static void main(String[] args) {

// LinkedList

List lista1 = new LinkedList();

7
// Aadimos nodos y creamos un Iterator
8
lista1.add("Madrid");
9
lista1.add("Sevilla");
10
lista1.add("Valencia");
11
Iterator iterador = lista1.iterator();
12
13
// Recorremos y mostramos la lista
14
while (iterador.hasNext()) {
15
String elemento = (String) iterador.next();
16
System.out.print(elemento + " ");
17
}
18
System.out.println("--LinkedList--");
19
20
// ArrayList
21
List lista2 = new ArrayList();
22
23
// Aadimos nodos y creamos un Iterator
24
lista2.add("Madrid");
25
lista2.add("Sevilla");
26
lista2.add("Valencia");
27
Iterator iterador2 = lista2.iterator();
28
29
// Recorremos y mostramos la lista
30
while (iterador2.hasNext()) {
31
String elemento = (String) iterador2.next();
32
System.out.print(elemento + " ");
33
}
34
System.out.println("--ArrayList--");
35
}
36
}
37

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 mtodos add(o) y addAll(o) devuelven false si o ya estaba en el
conjunto.

Queue<E>: Coleccin ordenada con extraccin por el principio e

insercin 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 vaca/llena, hay mtodos para interrogar,
que devuelven null. Los mtodos 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 quizs el ms sencillo, y no utiliza la interfaz
Collection. Los principales mtodos son: put(), get(), remove().
1.

HashMap<K,V>: Se basa en una tabla hash, pero no es

sincronizado.

2.

HashTable<K,V>: Es sincronizado, aunque que no

permite null como clave.

3.

LinkedHashMap<K,V>: Extiende de HashMap y utiliza una lista

doblemente enlazada para recorrerla en el orden en que se aadieron.
Es ligeramente ms rpida a la hora de acceder a los elementos que su
superclase, pero ms lenta a la hora de aadirlos.

4.

TreeMap<K,V>: Se basa en una implementacin de rboles en el

que ordena los valores segn las claves. Es la clase ms lenta.

Ejemplo de Map:

1 import java.util.*;
2 public class Ejemplo
3 {
4

public static void main(String args[])

// Definir un HashMap

7
HashMap global = new HashMap();
8
9
// Insertar valores "key"-"value" al HashMap
10
global.put("Laura", "667895789");
11
global.put("Pepe", "645895756");
12
global.put("Abelardo", "55895711");
13
global.put("Daniel", "667111788");
14
global.put("Arturo", "667598623");
15
16
// Definir Iterator para extraer o imprimir valores
17
for( Iterator it = global.keySet().iterator(); it.hasNext();) {
18
String s = (String)it.next();
19
String s1 = (String)global.get(s);
20
System.out.println("Alumno: "+s + " - " + "Telefono: "+s1);
21
}
22
}
23
}
24

Otros tipos de
colecciones: singleton(), singletonList(), singletonMap(). Devuelven
conjunto, lista y mapa inmutables, con un nico elemento. tiles para pasar
un elemento a un mtodo que espera una coleccin.
El siguiente cdigo es un ejemplo de Colecciones:

import java.util.*;
public class EjemploColecciones {
public static void main(String[] args) {
Collection&lt;String&gt; col1 = new HashSet&lt;String&gt;();
Collection&lt;String&gt; col2 = Arrays.asList("valor1", "valor2");
Collection&lt;String&gt; col3 = Collections.singleton("valor3");
// add() y addAll() devuelven true si cambia la coleccin.

// Importa en conjuntos
if (col1.add("cero"))
System.out.println ("col1 modificada");
if (col1.addAll(col2))
System.out.println ("col1 modificada");
// Copiamos usando un copy constructor
Collection&lt;String&gt; copia = new ArrayList&lt;String&gt;(col1);
col1.remove("cero");
// eliminar un elemento
col1.removeAll(col3);
// eliminar los elementos en e de c
col1.retainAll(col2);
// elimina de c los que no estn en d
col1.clear();
// eliminar todos
boolean b = col1.isEmpty();
// b == true
int s = col1.size();
// s == 0
// Recuperamos en c la copia
b = col1.addAll(copia); // b == true
b = col1.contains("cero");
// b == true
b = col1.containsAll(col2);
// b == true;
// Recorremos col1
Iterator&lt;String&gt; iterador = col1.iterator();
while(iterador.hasNext())
System.out.println(iterador.next());
for(Iterator&lt;String&gt; i = col1.iterator(); i.hasNext();)
System.out.println(i.next());
// Recorremos de col1
for(String word : col1) System.out.println(word);
// Las colecciones tienen toString()
System.out.println(col1);
// Copia en un Array
Object[] elementos = col1.toArray();
// Obtenemos una copia
String[] strings = col1.toArray(new String[col1.size()]);
//Sin necesidad de saber el tamao
strings = col1.toArray(new String[0]);
}
}

El resultado que produce este cdigo 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 mtodo int compareTo(Object o). El mtodo compareTo() devuelve
un entero con las siguientes caractersticas:
1.

Negativo: Si thisObject < anotherObject

2.

Cero: Si thisObject == anotherObject

3.

Positivo: Si thisObject > anotherObject

En este ejemplo comparamos cadenas ignorando maysculas y minsculas,

e imprimiendo el resultado por orden alfabtico:

1 // --- Clase Principal --- /

2 import java.util.*;
3 public class Principal {
4

public static void main(String[] args) {

TreeSet ts = new TreeSet(new Comparacion ());

ts.add("Alonso");

ts.add("alonso");

ts.add("Conchi");

ts.add("Emilio");

10

ts.add("Gmez");

11

ts.add("manuela");

12

ts.add("Manuela");

13

System.out.println(ts);

14

15 }
16
17 // --- Clase Comparacion --- /
18 import java.util.*;
19 class Comparacion implements Comparator {

20

public int compare(Object o1, Object o2) {

21

//Compara cadenas ignorando las may/min

22

return ((String) o1).compareToIgnoreCase((String) o2);

23

24 }

El resultado es el siguiente:

En este ejemplo utilizamos la interface Comparable para comprobar objetos

iguales:

1 // --- Clase Principal --- /

2 import java.util.*;
3
4 public class Principal {
5

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"));

10

ts.add(new Persona("Pipi", "Perez"));

11

ts.add(new Persona("Sara", "Alonso"));

12
13
14

System.out.println(ts);
}

15 }
16
17 // --- Clase Persona --- /
18 import java.util.*;
19

20 public class Persona implements Comparable {

21

private String Nombre, apellido;

22
23

public String Nombre(){

24
25

return Nombre;
}

26
27

public String apellido() {

28
29

return apellido;
}

30
31

public Persona(String Nombre, String apellido) {

32

if (Nombre==null || apellido==null)

33

throw new NullPointerException();

34

this.Nombre = Nombre;

35

this.apellido = apellido;

36

//Comprobar los nulos

37
38

public boolean equals(Object o) {

39

if (!(o instanceof Persona))

40

return false;

41

Persona n = (Persona)o;

42

// mtodo equals retorna false si argumento

43

// no es del tipo adecuado o es nulo

44

return n.Nombre.equals(Nombre) &amp;&amp;

45

n.apellido.equals(apellido);

46

47
48

public int hashCode() {

49
50

return 31 * Nombre.hashCode() + apellido.hashCode();

}

// hashcode tiene en cuenta ambos campos

51
52

public String toString() {

53
54

return Nombre + " " + apellido;

}

55
56

public int compareTo(Object o) {

57

// arroja ClassCastException si argumento no es del tipo Name

58

Persona n = (Persona)o;

59

int lastCmp = apellido.compareTo(n.apellido);

60

return (lastCmp!=0 ? lastCmp : Nombre.compareTo(n.Nombre));

61

// primero comparamos los apellidos y si son iguales los nombres

62

63 }

Y el resultado:

TIPOS GENRICOS
Los tipos genricos permiten forzar la seguridad de los tipos, en tiempo de
compilacin, en las colecciones (u otras clases y mtodos que utilicen tipos
parametrizados).
El problema que resuelven es que si al crear una coleccin de un tipo
determinado, pongamos String, yo meto un elemento de tipo entero,
entonces me dar una excepcin. Los genricos ayudaron a crear una
comprobacin de tipo en listas y mapas en tiempo de compilacin,
anteriormente esto no era posible. Otra cosa que podemos hacer en con los
tipos parametrizados o genricos es crear nuestras propias clases.
Veamos el problema y la solucin con tipos genricos:

1 // --- Sin tipos genericos --- /

2 public class Box
3 {
4

private Object object;

5
6

public void add(Object object) {

7
8

this.object = object;
}

9
10

// A la hora de devolver un objeto, necesitamos hacer un casting

11

// y si hacemos un casting de varios tipos, nos generara una

12

// excepcion en tiempo de ejecucion

13

public object get()

14
15

return this.object;
}

16 }
17
18 // --- Con tipos genericos --- /
19 // Para solucionarlo, usaremos esto:
20 public class Box&lt;T&gt;
21 {
22

private T t;

23
24

public void add(T t) {

25
26

this.t = t;
}

27
28

public T get() {

29
30

return t;
}

31 }
32
33 // Debemos instanaciar la clase de la siguiente forma:
34 Box &lt;String&gt; boxes = new Box&lt;String&gt; ();
35 // Todos los tipos parametrizados se reemplazaran por la &lt;Clase&gt;

Es decir, bsicamente 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 coleccin,
siendo los tipos de stos transparentes para nosotros.
Las convenciones de declaracin utilizan la letra T para tipos y E para
elementos de una coleccin. Se puede utilizar ms de un tipo parametrizado

en una declaracin. Por convencin los tipos parametrizados son letras

solitarias maysculas, sin esta convencin sera difcil leer el cdigo y decir
la diferencia entre una variable parametrizada y una clase ordinaria o un
nombre de una interface.
4.

E Elemento (Usado extensivamente en las colecciones en java)

5.

K Key

6.

N Number

7.

T Type

8.

V Value

9.

S, U, V etc. 2nd, 3rd, 4th types