Genéricos y Colecciones en Java

PAV
 Java 1.0 vs Generics
class Stack { class Stack<A> {
void push(Object o) { ... } void push(A a) { ... }
Object pop() { ... } A pop() { ... }
...} ...}

String s = "Hello"; String s = "Hello";

Stack st = new Stack(); Stack<String> st =
... new Stack<String>();
st.push(s); st.push(s);
... ...
s = (String) st.pop(); s = st.pop();
Lista normal
class Nodo {
Object elt;
Nodo next;
Nodo(Object elt){elt = e; next = null;}
}

class LinkedList implements List {

Nodo h, t;
public LinkedList() {h = new Nodo(null); t = h;}

public void add(Object elt){

t.next = new Nodo(elt);
t = t.next;
}
….
}
Lista con genéricos
class LinkedList<E >implements List<E>
protected class Nodo {
E elt;
Nodo next;
Nodo(E elt){elt = e; next = null;} }

protected Nodo h, t;
public LinkedList() {h = new Nodo(null); t = h;}

public void add(E elt){

t.next = new Nodo(elt);
t = t.next;
}
// …
}
Colecciones en Java
• Una colección es un objeto que agrupa múltiples
elementos en una unidad única
 Colecciones que provee Java
Java provee los siguientes tipos (o interfaces) para trabajar con grupos de elementos.
 Colecciones de Java
Las principales implementaciones (clases) que provee Java de los tipos de
colecciones (interfaces) son las siguientes.

Interfaz Implementación

Hash Table Resizable Tree Linked List Has Table +

array Linked List
Set HashSet TreeSet LinkedHashSet

List ArrayList LinkedList

Queue

Map HashMap TreeMap LinkedHashMap

ArrayList
• Es una clase que “imita” o abstrae un arreglo
▫ Se auto-ajusta al tamaño necesario (no se necesita
definir su tamaño a priori)

import java.util.ArrayList;
Iniciación
…
ArrayList var;
var = new ArrayList();
ArrayList
• Provee varios métodos, por ahora
analizaremos tres:
– add(Object o)
Añade el objeto “o” a la colección
– get(int i)
retorna el objeto i-ésimo de la
colección
– size()
retorna el número de elementos que tiene la colección

En versiones de Java anteriores a 1.5, sólo se

pueden agregar objetos, no tipos nativos!
ArrayList
ArrayList var;
Se pueden agregar objetos
var = new ArrayList();
de distinto tipo
Los índices en ArrayList comienzan de 0
var.add(“Hola”);
Integer x = new Integer(3);
var.add(x);

String a = (String)var.get(0);
Integer b = (Integer)var.get(1);

Como pueden haber objetos de distinto tipo, a priori Java no

puede saber que tipo retornará. Es necesario entonces
hacer un “cast”
ArrayList
A partir de Java 1.5 se pueden “tipear” las colecciones

ArrayList<String> var;
var = new ArrayList<String>();

var.add(“Hola”); // OK
Integer x = new Integer(3);
var.add(x); // error!, no compila

String a = var.get(0); // OK sin casting

ArrayList
• Implemente una clase que utilice un ArrayList
para tener una lista de alumnos
▫ Método agregarAlumno
▫ Método que imprima la lista
ArrayList:Alumnos
public class Alumnos {
private ArrayList<String> alumnos;

public Alumnos() {
alumnos = new ArrayList<String>();
}
public void agregarAlumno(String alumno) {
alumnos.add(alumno);
}
public void imprimir() {
for (int i = 0; i < alumnos.size(); i++) {
String alum = alumnos.get(i);
System.out.println(alum);
}
}
ArrayList: Usando iteradores
import java.util.ArrayList;
import java.util.Iterator;
…
public class Alumnos {
…
public void imprimirIterator() {
for (Iterator<String> it = alumnos.iterator();it.hasNe
String alum = it.next();
System.out.println(alum);
}
}
}
Lista enlazada con librería
• La clase LinkedList proporciona una lista
doblemente enlazada ya programada.
• Debe ser usada junto con la clase Iterator.
• Para la librería no es necesario crear la clase
nodo. Simplemente se inserta un objeto que es el
dato que el nodo almacena dentro.
Lista enlazada. Uso de Iterator
import java.util.LinkedList;
import java.utill.Iterator;
…

List<String> staff = new LinkedList<String>();

staff.add(“Bruce Wayne”);
staff.add(“Dick Grayson”);
staff.add(“Barbara Gordon”);
Iterator iter = staff.iterator();
String primero = iter.next();
String segundo = iter.next();
iter.remove(); //elimina el último visitado = Dick Grayson
Iterator<E>
• java.util.Iterator<E>
• boolean hasNext() Devuelve verdadero si hay
otro elemento posible a visitar en la colección.
• E next() Devuelve el siguiente elemento a
visitar
• void remove() Elimina el último objeto
visitado. Este método debe seguir la visita a un
elemento
Lista enlazada. Uso de ListIterator
import java.util.LinkedList;
import java.utill.Iterator;
…
List<String> staff = new LinkedList<String>();
staff.add(“Bruce Wayne”);
staff.add(“Dick Grayson”);
staff.add(“Barbara Gordon”);

ListIterator iter = staff.ListIterator();

iter.next(); //salta el primer elemento
iter.next(); //al segundo
iter.previous(); //regresa al primero
iter.add(“Jason Todd”); //inserta el nuevo entre el
primero y el segundo
Interface ListIterator<E>
• void add(E e)

• boolean hasNext()

• boolean hasPrevious()

• E next()

• int nextIndex()

• E previous()

• int previousIndex()

• void remove()

• void set(E e)
Pilas con librerías
• En la librería de colecciones existe la clase Stack,
que tiene el siguiente comportamiento:
• java.util.Stack<E>
• boolean empty() Prueba si la pila está vacía.
• E peek() Devuelve el valor del objeto que va a salir
de la pila sin eliminarlo
• E pop() Devuelve el valor del objeto que va a salir
de la pila y lo elimina de la pila
• E push(E item) Inserta un elemento en la pila
• int search(Object o) Retorna la posición del
elemento dentro de la pila
Colas con librerías
• No existe en la librería de Java una clase que implemente
directamente una cola. Lo que existe es una interfaz con
los métodos propios de una cola
• java.util.Queue<E>
• E element() Devuelve pero no elimina la cabeza de la
cola
• boolean offer(E o) Inserta el elemento o al final de la
cola si es posible
• E peek() Devuelve pero no elimina la cabeza de la cola,
devolviendo null si la cola está vacía
• E poll() Devuelve y elimina la cabeza de la cola, o da
null si la cola está vacía
• E remove() Devuelve y elimina la cabeza de la cola
Colas con librerías
• Una manera de tener una cola es usar la clase
LinkedList<E>, la cual es una implementación
de la interfaz Queue<E>.
• Esta clase tiene muchos otros métodos, pero se
puede usar limitándose a ver los propios de la
interfaz y de esa manera se puede limitar a
comportarse como una cola. Ej:
• Queue<int> miCola = new LinkedList<int>();