Programación II

Unidad 4: Estructuras de datos en Java

Autor: Programación II
DTE/ETSIST/UPM
 Índice

Colecciones de Java.
List (listas) Estudiaremos
principalmente
Stack
Queue
Set (Conjuntos)
Map (mapas –Estructuras asociativas)
Algoritmos de gestión de colecciones.

Programación 2 2
 Programación II

Unidad 4. Colecciones de Java.

Autor: Programación 2

Deitel&Deitel. Java: how to program (9th ed.) Capítulo 20. Generic Collections. Apartado 20.5. Interface Collection
and Class Collections y Apartado 20.7. Collections Methods -
 Colecciones de Java

¿Qué es una colección?

Es un objeto que agrupa otros objetos como una sola unidad. Las tablas
(arrays) son un ejemplo de "colección" básica.
El paquete java.util contiene las interfaces de las colecciones para la
manipulación de datos más habituales y algunas implementaciones de las
mismas.
En las últimas versiones de java las colecciones se han agrupado formando el
denominado " Collections Fram ew ork " – Arquitectura unificada para la
manipulación de estructuras de datos en java-
Documentación online de referencia:
The Collections Framework:
http://download.oracle.com/javase/7/docs/technotes/guides/collections/index.html
The Java Tutorial Collections:
http://download.oracle.com/javase/tutorial/collections/index.html

Programación 2 4
 Colecciones de Java

El núcleo del entorno Java Collections Fram ew ork está formado por
tres elementos:

Interfaces: permiten que las colecciones sean manipuladas de

forma independiente de los detalles de su representación.
Implementaciones: Estas son las implementaciones concretas
de las interfaces de colección. En esencia, son estructuras de datos
reutilizables.
Algoritmos: métodos polimórficos reutilizables que permiten
realizar cálculos útiles, tales como búsqueda y ordenación, en los
objetos que implementan interfaces de colección.

Programación 2 5
 Estructura de interfaces

Visión general de las interfaces e implementaciones.

«interface»
java.util Collection

«interface» «interface» «interface» «interface»

List Queue Set Map

«interface» «interface»
ArrayList Vector LinkedList PriorityQueue HashSet SortedSet LinkedHashSet HashMap SortedMap LinkedHashMap

Stack TreeSet TreeMap

Programación 2 6
 Estructura de interfaces

Programación 2 7
 Estructura de interfaces

Las interfaces están jerarquizadas:

Collection es la raíz común a un conjunto de otras más
especificas, como:
Set: Modela el concepto matemático de conjuntos. No hay elementos
duplicados. Si los elementos están ordenados es entonces SortedSet.
List: Lista de elementos ordenados posicionalmente y que pueden
estar duplicados.
Queue. Permite manejar elementos procesados por prioridades
(generalmente FIFO). Implementa las operaciones de inserción,
extracción e inspección.
M ap Tabla asociativa compuesta por pares clave-valor.
Por cada interface puede haber distintas clases que la implementan, por
ej. para la interface List hay tres posibilidades: ArrayList, Vector y
LinkedList.

Programación 2 8
 Métodos de Collection

Tipo Método y descripción

boolean add(E e) Añade el elemento “e” al objeto colección.
boolean addAll(Collection<? extends E> c) Añade la colección “c” al objeto colección.
void clear() Borra todos los elementos de la colección.
boolean contains(Object o) Devuelve verdadero si la colección contiene el objeto “o”.
boolean containsAll(Collection<?> c) Devuelve verdadero si la colección contiene la colección “c”
boolean equals(Object o) Compara la colección con el objeto “o”. Devuelve true si son iguales.
int hashCode() Devuelve el valor del código hash para la colección.
boolean isEmpty() Devuelve true si la colección está vacía.
Iterator<E> iterator() Devuelve un iterador para recorrer los elementos de la colección
boolean remove(Object o) Borra un sólo objeto “o” de la colección si existe.
removeAll(Collection<?> c) Borra de la colección, si existen, los objetos indicados en
boolean
la colección “c”.
retainAll(Collection<?> c) Retains only the elements in this collection that are
boolean
contained in the specified collection (optional operation).
int size() Devuelve el número de elementos de la colección.
Object[] toArray() Devuelve un array conteniendo los elementos de la colección.
toArray(T[] a) Devuelve un array con los elementos de la colección. El tipo del array
<T> T[]
que devuelve es el que se especifica en la referencia que se pasa como parámetro.

9
 Estructura de interfaces

Para la definición de las colecciones se usan interfaces genéricas: incluyen

parámetros en la definición.
public interface Collection <E> extends ...
<E> es el parámetro de la interfaz Collection. Cuando se
instancie Collection se dirá con qué clase se corresponde E.
Por ejemplo, para crear una lista (de clase ArrayList) que es
una colección de objetos de clase String se haría:
ArrayList <String> lista =new ArrayList<String>();
(Collection<?> c) indica que “c” puede ser una colección de
cualquier objeto (?).
(Collection<? extends E> c) indica que “c” es una colección
de cualquier objeto (?) que herede de la clase en el parámetro E.

Programación 2 10
 Operaciones de Collection

public interface Collection<E> extends Iterable <E>

{
// Basic operations
int size();

boolean isEmpty();

boolean contains (Object element);

boolean add( E element); //optional

boolean remove(Object element); //optional

Iterator <E> iterator(); permite añadir

este método

Programación 2 11
 operaciones con Colecciones

// Bulk operations
boolean containsAll (Collection<?> c);
boolean addAll (Collection<? extends E> c);//optional
boolean removeAll (Collection<?> c); //optional
boolean retainAll (Collection<?> c); //optional
void clear(); //optional
// Array operations
Object[] toArray();
<T> T[] toArray (T[] a);

Además se incluye un constructor que admite otra colección ("conversion

constructor"). Por ejemplo, si tenemos una colección como c:
Collection <String> c; (c puede ser una lista , un Set,..)
podemos construir otra colección a partir de ella:
List<String> list = new ArrayList <String> (c);

Programación 2 12
 Recorrer una colección Java.

Hay dos formas de recorrer una colección:

Uso del constructor for-each . Diseñado expresamente – y sólo - para
recorridos de colecciones y series. Es un tipo de for.

for (Object o : collection) Proceso sobre

System.out.println(o); la colección
de datos
Uso de iteradores.
Un iterator es un objeto que permite recorrer una colección y
borrar selectivamente elementos con métodos específicos ( siguiente,
anterior, etc.)
Sustituyen y complementan a las enumeraciones (Enumeration) en
las colecciones de java.
 Se usará iterator en lugar de for-each cuando:
Queramos filtrar la colección borrando elementos (for-each no puede)
Recorrer varias colecciones simultáneamente

Programación 2 13
 Iterator.Ejemplos.

La interface I terator se define:

public interface Iterator<E> {
boolean hasNext();
E next();
void remove(); // optional
}
Ejemplo:
public void filtro( Collection<String> c ) {
Iterator<String> i;
i = c.iterator();
while( i.hasNext() ){
if (i.next().charAt(0)==‘A’)
i.remove(); // borra los que empiecen por ‘A’
}
}
Programación 2 14
 Programación II

Unidad 4. Lista

Autor: Programación2

Deitel&Deitel. Java: how to program (9th ed.) Capítulo 20. Generic Collections. Apartado 20.. Lists

Programación 2
 Listas

Una lista es una colección de objetos ordenada por su posición (también

llamada secuencia) en la que pueden existir elementos repetidos.

Incluye operaciones para:

Manipular elementos basándose en su posición (índice). Por
ejemplo añadir un nuevo elemento en una posición.
Buscar objetos específicos de la lista y devolver su posición.
Obtener objetos de tipo iterador más sofisticados para recorrer la
colección.
Realizar operaciones sobre rangos de la lista.

Programación 2 16
 Listas: Interfaz

public interface List<E> extends Collection<E> {

// Positional access
E get (int index);
E set (int index, E element); //optional
void add (int index, E element); //optional
E remove (int index); //optional
boolean add (E element); //optional -> añade al final
boolean addAll(int index, Collection<? extends E> c); //optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
// Range-view
List<E> subList(int from, int to);
}
Programación 2 17
 Listas: Iteradores

La lista permite obtener objetos de tipo iterator más sofisticados que los de
las colecciones genéricas a través del método listIterator
ListI terator<E> es una interface que permiten recorrer una lista en ambas
direcciones, modificar la lista durante el recorrido y acceder en cada instante
a un elemento de la misma:

public interface ListIterator <E> extends Iterator <E>

{
boolean hasNext();
E next();
boolean hasPrevious();
E previous();
int nextIndex();
int previousIndex();
void remove(); //optional
void set (E e); //optional
void add (E e); //optional
}

Programación 2 18
 Listas

Clases Java de uso habitual que implementan la interfaz List

«interface»
List
Implementan
la interfaz

ArrayList LinkedList

ArrayList suele tener mejor LinkedList presenta mejor rendimiento

rendimiento cuando se accede
a elementos del array de forma
aleatoria. No se accede a un
elemento i-esimo y luego al siguiente,
etc.
Internamente usa un array cuyo
tamaño va variando dinámicamente.
si hay que añadir o borrar elementos al
principio de la lista o en el medio. También
cuando el número de elementos es elevado.
Internamente es una cadena de nodos
que contienen una referencia al siguiente
y al anterior.

Programación 2 19
 Ejemplo lista 1. Lectura de teclado y escritura orden inverso

/* guarda en una lista líneas leídas del teclado y muestra los

elementos en el orden en el que están almacenados en la lista y
luego en orden inverso. */

public void ambosSentidos(){

ArrayList <String> lineas; // ó List<String> lineas;
ListIterator<String> i;
lineas = new ArrayList<String>();
String aux;
Scanner sc = new Scanner(System.in);
aux = sc.nextLine();
while (aux.length()!= 0){
lineas.add(aux); aux = sc.nextLine();
}
i = lineas.listIterator();
while(i.hasNext())
System.out.println(i.next());
while(i.hasPrevious())
System.out.println(i.previous());
}
Programación 2 20
 Ejemplo listas 2. Sustitución de una palabra por otra
/**
* En una lista de palabras, sustituye una palabra por otra
* @param listaPalabras. lista de palabras
* @param antigua. palabra a sustituir
* @param nueva. palabra que la sustituye
*/

public void sustituye( List <String> listaPalabras,

String antigua, String nueva){
ListIterator <String> i;
String elem;
i= listaPalabras.listIterator();
while (i.hasNext()){
elem = i.next();
if (elem.equals(antigua) ) i.set(nueva);
}
}
¿Qué ventaja tiene utilizar List<String> en el parámetro?

Programación 2 21
 Ejemplo listas 3. Modifica la edad de una Persona

/**
* Modifica la edad de una persona de una lista.
* @param lista. Lista de personas.
* @param persona. Persona cuya edad se va a modificar.
* @param nuevaEdad. Nueva edad de la persona buscada.
*/

public void modEdad(List<Persona> lista,

Persona persona, int nuevaEdad){
int indice;
Persona aux;
// Persona debe tener equals codificado!
indice = lista.indexOf(persona);
if (indice !=-1){
aux = lista.get(indice);
// lista.get(indice).setEdad(nuevaEdad); alternativa al aux
aux.setEdad(nuevaEdad);
}
}
Programación 2 22
 Programación II

Unidad 4. Stack

Autor: Programación 2

Deitel&Deitel. Java: how to program (9th ed.) Capítulo 20. Generic Collections.
Apartado 20.8. Stack Class of Package java.util

Programación 2
 Stack

Una pila es una colección con comportaniento LIFO (Last Input-First

Output). Sólo se tiene acceso al último elemento guardado.

public class Stack<E> extends Vector <E> {

boolean empty();
E peek();
E pop();
E push( E item) ;
int search(Object o);
}

 Esta clase a través de Vector heredera métodos de la interfaz de lista (iterator y listIterator)

Programación 2 24
 Stack

Descripción de las operaciones:

boolean empty()
Devuelve true si la pila está vacía
E peek()
Obtiene el objeto en cabeza sin sacarlo.
E pop()
Devuelve el objeto en cabeza y lo saca de la pila
E push(E item)
Añade un objeto a la cabeza de la pila
int search(Object o)
Devuelve la posición donde se encuentra un objeto en la pila

En las operaciones pop y peek se lanza la excepción

Em ptyStack Ex ception
Programación 2 25
 Stack Ejemplo 1. Lectura desde el teclado y escritura inversa

/*Lee líneas de teclado y luego las imprime en orden inverso. */

public void alReves() {

Stack<String> pilaDeFrases = new Stack<String>();
Scanner teclado = new Scanner(System.in);
String linea;
System.out.println("Teclee líneas (vacía para terminar):");
linea = teclado.nextLine();
while (linea.length()!= 0){
pilaDeFrases.push(linea);
linea=teclado.nextLine();
}
System.out.println("Líneas tecleadas (en orden inverso):");
while (!pilaDeFrases.empty())
System.out.println(pilaDeFrases.pop() );
}

Programación 2 26
 Programación II

Unidad 4. Set

Autor: Programación2

Deitel&Deitel. Java: how to program (9th ed.) Capítulo 20. Generic Collections. Apartado 20.10. Sets

Programación 2
 Interfaz Set

Un set (conjunto) es una Collection que no puede contener elementos

repetidos. No se puede añadir un elemento a un conjunto que ya tenga
uno igual.
Modela la abstracción matemática de conjunto, por ejemplo, el
conjunto de las cartas de la baraja.
No añade ningún método nuevo a los heredados de la interfaz
Collection.
Implementa estos métodos para añadir las restricciones de unicidad
sobre los elementos de los conjuntos.

Programación 2 28
 Interfaz Set

public interface Set <E> extends Collection <E> {

// Basic operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element); //optional
boolean remove(Object element); //optional
Iterator <E> iterator();
// Bulk operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); //optional
boolean removeAll(Collection<?> c); //optional
boolean retainAll(Collection<?> c); //optional
void clear(); //optional
// Array Operations
Obsérvese que es la misma que
Object[] toArray(); la de collection
<T> T[] toArray(T[] a);
}
Programación 2 29
 Implementaciones Set

En la plataforma Java, para la interfaz Set, hay tres implementaciones

básicas :

Implementan la interfaz

HashSet – Implementa el conjunto de datos utilizando una tabla hash.

No se garantiza el orden de los elementos.
LinkedHashSet - Utiliza una lista enlazada y una tabla hash. Ordenado
según orden de inserción.
TreeSet implementa la interfaz SortedSet , utiliza un árbol binario.
Elementos ordenados según un criterio a elegir.

Programación 2 30
 HashSet/LinkedHashSet

Las clases HashSet/LinkedHashSet utilizan los siguientes métodos

de los objetos almacenados en el conjunto:
boolean equals(Object o ). Para que el Set pueda comprobar si
dos objetos son iguales y evitar así repetidos al insertar.
int hashCode(). Este método debe implementarse de forma que
genere el código hash asociado al objeto (que puede repetirse). Si
dos objetos son iguales (con equals) su código debe ser el mismo.
Deben codificarse en la clase que se corresponda con los
objetos del conjunto.
Las clases de los paquetes de Java ya tienen codificados estos
métodos correctamente.

Programación 2 31
Tabla hash

32
 Ejemplo Set 1: Elimina repetidas

import java.util.*;
public class BuscarDuplicados {
/** Dada una secuencia de palabras, guarda en un conjunto las que
no están repetidas y muestra las que están repetidas.
@param args Secuencia de palabras a analizar.
*/
public static void main(String args[])
{
Set<String> dup = new HashSet<String>();
Set<String> words = new HashSet<String>();
for (int i=0; i<args.length; i++)
if ( !words.add(args[i])) mejor así
dup.add(args[i]);
System.out.println("Repetidas: "+dup);
}
for (String e: dup){
}
System.out.println(e);
}
Resultado:
C:\java\pruebas>java BuscarDuplicados uno dos tres uno ¿Qué hacer para mostrar las no
repetidas?
Repetidas: [uno]

Programación 2 33
 Ejemplo Set 2: Conjunto de personas. Definición de Persona

/** Implementación de la clase persona con los métodos equals y

hashCode para su utilización en aplicaciones con conjuntos */
public class Persona {
private String nombre;
private int edad;
public Persona( String nombre, int edad ){ //constructor
this.nombre = nombre; this.edad = edad;}
public String getNombre (){ return nombre; }
public int getEdad (){ return edad; }
public String toString (){ return nombre+" ("+edad+")"; }
// el criterio de igualdad es decidido por el diseñador
public boolean equals (Object otro){
boolean res = false; Persona aux;
if ( (otro != null) && (otro instanceof Persona)) {
aux = (Persona) otro;
res = nombre.equals(aux.nombre) &&
this.edad == aux.edad;
}
return res;}
public int hashCode(){ return nombre.hashCode() + edad; }
}

Programación 2 34
 Ejemplo 2 : Conjunto de Personas. Lectura del conjunto

/* Método que lee de teclado los datos de varias personas y los

guarda en un conjunto en el orden de inserción
@return Conjunto de personas creado.*/

public Set<Persona> leerPersonas(){

Set<Persona> res = null;
String nombre; int edad;
Scanner teclado = new Scanner(System.in);
res = new LinkedHashSet<Persona>();
System.out.print("Nombre: "); nombre = teclado.nextLine();
while (nombre.length()!=0){
System.out.print("Edad: ");
edad = Integer.parseInt(teclado.nextLine());
if (!res.add (new Persona(nombre,edad)))
System.out.println("Ya existe la persona en el conjunto.");
System.out.print("Nombre: ");
nombre = teclado.nextLine();
}
return res;
}

Programación 2 35
 Ejemplo 3: Borrar una persona de un conjunto

/* Lee de teclado un conjunto de personas, y borra una de ellas.*/

public void borrar(){
Set<Persona> conjunto;
Persona p; String nombre; int edad;
Scanner teclado = new Scanner(System.in);
conjunto = leerPersonas();
System.out.println(conjunto); // Mostrar por pantalla el conjunto
// Pedir datos persona a borrar
System.out.print("Nombre de la persona: ");
nombre = teclado.nextLine(); mejor así
System.out.print("Edad de "+nombre+": ");
edad = Integer.parseInt(teclado.nextLine());
p= new Persona(nombre, edad); for (String e: dup){
if ( !conjunto.contains(p)) System.out.println(e);

System.out.println("No existe la persona."); }

else
if (conjunto.remove(p))
System.out.println("Persona borrada.");
else
System.out.println("No se ha podido borrar.");
System.out.println(conjunto); // Mostrar por pantalla el conjunto
}

Programación 2 36
 Programación II

Unidad 4. Mapas

Autor: Programación 2

Deitel&Deitel. Java: how to program (9th ed.) Capítulo 20. Generic Collections. Apartado 20.11. Maps

Programación 2
 Interface Map

Un Map es un objeto que permite "asociar" una clave y un valor.

Sustituye la funcionalidad de la clase abstracta Dictionary (versiones
anteriores de java).
Un mapa no puede contener objetos con clave duplicada.

Interface para la definición de mapas y manejo de los

elementos contenidos en ellos

public interface Map<K,V> { // Bulk operations

// Basic operations void putAll(Map<? extends K, ?
V put(K key, V value); extends V> m);
V get(Object key); void clear();
V remove(Object key); // Collection Views
boolean containsKey (Object key); public Set<K> keySet();
boolean containsValue(Object value); public Collection<V> values();
int size(); public Set<Map.Entry<K,V>> entrySet();
boolean isEmpty(); }

Programación 2 38
 Interface Map

La asociación entre clave-valor forma una entrada del mapa (Map.Entry).

La interfaz Map.Entry provee los mecanismos para interaccionar con cada
uno de los pares clave-valor del mapa
// Interface for entrySet elements
public interface Map.Entry {
K getKey();
V getValue();
V setValue(V value);
}
}
Hay tres implementaciones:
HashMap. Usa una tabla hash para implementar el mapa.
LinkedHashMap. Añade a la anterior una lista enlazada con el orden de
inserción para aumentar el rendimiento.
TreeMap. Implementa la interfaz SortedMap. Está basado en la
implementación de un árbol binario.
Su conducta y rendimiento son similares a las homónimas de Set.
Programación 2 39
HashMap

40
 Map. Vistas

Los métodos de la interfaz Collection permiten ver un mapa como una

Collection de tres formas distintas usando los métodos de la interfaz
Map:
Un Set con las claves usando el método:

public Set<K> keySet();

una Collection con los valores del mapa usando el método:

public Collection<V> values();

un conjunto con los pares clave-valor contenidos en el mapa
usando el método:

public Set<Map.Entry<K,V> > entrySet();

Programación 2 41
 Map. Ejemplos de Vistas

// Construimos un mapa de ejemplo con objetos de tipo persona

// clave: DNI de la persona; valor: nombre de la persona

Map <String ,Persona> mapa=new HashMap<String, Persona>();

mapa.put( "12345678R", new Persona ("pepe Redondo",12) );
mapa.put( "29876543E", new Persona ("Juan Malaparte",45) );

// procesa las entradas del mapa usando la interfaz Map.Entry

System.out.println("Muestra todas las entradas del mapa:");
for (Map.Entry <String, Persona> e : mapa.entrySet())
System.out.println("DNI: " +e.getKey() + " -> " +
"Persona: "+e.getValue());

// sólo procesa las claves del mapa

System.out.println("\nMuestra las claves del mapa:");
Set <String> llaves = mapa.keySet();
for (Iterator<String> it = llaves.iterator(); it.hasNext(); )
System.out.println(it.next());

Programación 2 42
 Map. Ejemplos de Vistas

// sólo procesa los valores del mapa

System.out.println("Muestra los valores(nombres)del mapa");
Collection <Persona> personas = mapa.values();
Iterator <Persona> i= personas.iterator();
while (i.hasNext()){
p = i.next();
System.out.println(p);
}
//…… resto de la aplicación

Programación 2 43
 Bibliografía

[1]
Paul Deitel - Deitel & Associates, Inc.; Harvey Deitel - Deitel &
Associates, Inc., Java™: ¿Cómo programar? Novena edición., Prentice
Hall, 2011.

[2]
K. Sierra y B. Bates, Head First Java, 2nd Edition, O'Reilly Media, Inc.,
2005.

Programación 2 44