Estructuras de Datos Ingeniera Informtica en Sistemas de Informacin

Enseanza Bsica

TEMA 1: Introduccin al Java Collections Framework

CONTENIDO
1 INTRODUCCIN.............................................................................................................................................................2 1.1. ELEMENTOS DEL JCF..................................................................................................................................................2 2 INTERFAZ COLLECTION............................................................................................................................................3 3 ITERADORES...................................................................................................................................................................7 3.1. INTERFAZ ITERATOR...................................................................................................................................................7 3.2. INTERFAZ LISTITERATOR..........................................................................................................................................10 4 INTERFACES COMPARABLE Y COMPARATOR.................................................................................................16 4.1. INTERFAZ COMPARABLE...........................................................................................................................................16 4.2. INTERFAZ COMPARATOR..........................................................................................................................................19 4.3. CUNDO USAR COMPARABLE Y COMPARATOR?....................................................................................................23 5 UTILIDADES PARA OBJETOS CONTENEDORES: CLASE JAVA.UTIL.COLLECTIONS...........................23 5.1. 5.2. 5.3. 5.4. 5.5. 5.6. 5.7. ORDENACIN............................................................................................................................................................24 INVERSIN DEL ORDEN.............................................................................................................................................25 BSQUEDA................................................................................................................................................................25 COPIAR LISTA...........................................................................................................................................................25 RELLENAR UNA LISTA..............................................................................................................................................26 MXIMOS Y MNIMOS...............................................................................................................................................27 CONSTANTES.............................................................................................................................................................27

6 CLASE ARRAYS (AMPLIACIN)..............................................................................................................................28 6.1. TRATAR MATRIZ COMO LISTA..................................................................................................................................28 6.2. MTODOS SIMILARES A LOS DE COLLECTIONS.........................................................................................................28 7 CLASE JAVA.LANG.MATH........................................................................................................................................28 8 BIBLIOGRAFA.............................................................................................................................................................30

Estructuras de Datos

Pgina 1 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

1 Introduccin
En la versin 1.2 del JDK se introdujo el Java Collections Framework o estructura de colecciones de Java (en adelante JCF). Se trata de un conjunto de clases e interfaces que mejoran notablemente las capacidades del lenguaje respecto a estructuras de datos. Adems, constituyen un excelente ejemplo de aplicacin de los conceptos propios de la programacin orientada a objetos.

1.1. Elementos del JCF

Jerarqua de Interfaces del JCF Interfaces de la JCF: Constituyen el elemento central de la JCF. Collection: define mtodos para tratar una coleccin genrica de elementos Set: coleccin que no admite elementos repetidos SortedSet: set cuyos elementos se mantienen ordenados segn el criterio establecido List: admite elementos repetidos y mantiene un orden inicial Map: conjunto de pares clave/valor, sin repeticin de claves SortedMap: map cuyos elementos se mantienen ordenados segn el criterio establecido Interfaces de soporte: Iterator: sustituye a la interfaz Enumeration. Dispone de mtodos para recorrer una coleccin y para borrar elementos. ListIterator: deriva de Iterator y permite recorrer lists en ambos sentidos. Comparable: declara el mtodo compareTo() que permite ordenar las distintas colecciones segn un orden natural (String, Date, Integer, Double, ). Comparator: declara el mtodo compare() y se utiliza en lugar de Comparable cuando se desea ordenar objetos no estndar o sustituir a dicha interfaz. Clases de propsito general: Son las implementaciones de las interfaces de la JFC. HashSet: Interfaz Set implementada mediante una hash table. TreeSet: Interfaz SortedSet implementada mediante un rbol binario ordenado. ArrayList: Interfaz List implementada mediante un array. LinkedList: Interfaz List implementada mediante una lista vinculada. HashMap: Interfaz Map implementada mediante una hash table.
Estructuras de Datos Pgina 2 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

TreeMap: Interfaz SortedMap implementada mediante un rbol binario

Clases histricas: Son las clases Vector y Hashtable presentes desde las primeras versiones de Java. En las versiones actuales, implementan respectivamente las interfaces List y Map, aunque conservan tambin los mtodos anteriores. Algoritmos: La clase Collections dispone de mtodos static para ordenar, desordenar, invertir orden, realizar bsquedas, llenar, copiar, hallar el mnimo y hallar el mximo. Clase Arrays: Es una clase de utilidad introducida en el JDK 1.2 que contiene mtodos static para ordenar, llenar, realizar bsquedas y comparar los arrays clsicos del lenguaje. Permite tambin ver los arrays como lists.

2 Interfaz Collection
La interfaz Collection es implementada por los conjuntos (sets) y las listas (lists). Esta interfaz, declarada en el paquete java.util, declara una serie de mtodos generales utilizables con Set y List.
public interfaz java.util.Collection { public boolean add(Object); // opcional public boolean addAll(Collection); // opcional public void clear(); // opcional public boolean contains(Object); public boolean containsAll(Collection); public boolean equals(Object); public int hashCode(); public boolean isEmpty(); public Iterator iterator(); public boolean remove(Object); // opcional public boolean removeAll(Collection); // opcional public boolean retainAll(Collection); // opcional public int size(); public Object[] toArray(); public Object[] toArray(Object[]); }

Los mtodos indicados como // opcional pueden no estar disponibles en algunas implementaciones, como por ejemplo en las clases que no permiten modificar sus objetos. Por supuesto dichos mtodos deben ser definidos, pero lo que hacen al ser llamados es lanzar una UnsupportedOperationException. Mtodos para agregar y eliminar elementos boolean add(Object element). Aade un elemento a la coleccin, devolviendo true si fue posible aadirlo y false en caso contrario (por ejemplo, un set que ya contenga el elemento). boolean remove(Object element). Elimina un nico elemento (si lo encuentra), y devuelve true si la coleccin ha sido modificada. Mtodos para realizar consultas int size(). Devuelve el nmero de elementos disponibles. boolean isEmpty(). Devuelve true si la coleccin es vaca.

Estructuras de Datos

Pgina 3 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

boolean contains(Object element). Devuelve true si el elemento pertenece a la coleccin.

Mtodos para recorrer todos los elementos Iterator iterator(). Devuelve una referencia Iterator que permite recorrer una coleccin con los mtodos next() y hasNext(). Permite tambin borrar el elemento actual con remove(). Mtodos para realizar varias operaciones simultneamente boolean containsAll(Collection collection). Igual que contains(), pero con un conjunto de elementos. boolean addAll(Collection collection). Igual a add(), pero aade un conjunto de datos si es posible. void clear(). Elimina todos los elementos. void removeAll(Collection collection). Igual que remove(), pero elimina el conjunto de elementos que se pasa como parmetro. void retainAll(Collection collection). Elimina todos los elementos menos los especificados por la coleccin pasada como parmetro. Otros Mtodos boolean equals(Object). Implementa la igualdad o equivalencia. Retorna true si el objeto que llama al mtodo es equivalente al que se pasa como parmetro. Devuelve false si el argumento es nulo. int hashCode(). A la hora de acceder, aadir, o eliminar un objeto contenido en un hashtable, la implementacin de dicha estructura invocar este mtodo sobre el objeto para obtener un int que pueda ser utilizado en la elaboracin del ndice en el hashtable. Durante la ejecucin de un programa este mtodo ha de retornar el mismo int siempre que sea invocado sobre el mismo objeto. Siempre y cuando sea factible ha de ser nico para cada objeto. Por ello, aunque esta implementacin no es requerida, el mtodo devuelve la direccin fsica del objeto en memoria. Object[] toArray(). Permiten convertir una coleccin en un array. Un aspecto importante es que las colecciones slo pueden contener objetos. Por ello, en versiones anteriores, Java no permita que a una coleccin se pudieran aadir elementos que no fueran objetos, es decir, de tipos bsicos o primitivos, es decir, que una instruccin como c.add(20) era incorrecta, y se tena que sustituir por c.add(new Integer(20)), en la que se usa la envoltura Integer. A partir de la versin Java 5 fueron integrados los mecanismos de autoboxing y auto-unboxing para permitir la conversin de valores primitivos hacia sus respectivos objetos (envolturas) de manera directa y sin mayores complicaciones. Es decir, que ya s se permiten instrucciones del tipo c.add(20). Ejemplo:
import java.util.*; // Para usar los elementos del JCF public class Ppal { public static void main(String[] args) { int i; // Coleccin c1 Collection c1 = new ArrayList(); c1.add(10); // Es equivalente a c1.add(new Integer(10)); c1.add(20); c1.add(30); Estructuras de Datos Pgina 4 de 24

ED - Enseanza Bsica c1.add(40); c1.add(50); c1.add(60); // Coleccin c2 como una lista List c2 = new ArrayList(); for (i=1; i<=6; i++) c2.add(new Integer(i*10));

Tema 1: Introduccin al JCF

// Es equivalente a c2.add(i*10);

// Recorrido de colecciones como tablas NO ES LO RECOMENDADO System.out.println("La coleccin 1 tiene " + c1.size() + " elementos"); Object [] t = c1.toArray(); for (i=0; i<t.length; i++) System.out.println("Elem " + i + ": " + (Integer)t[i]); System.out.println("La coleccin 2 tiene " + c2.size() + " elementos"); Object [] t2 = c2.toArray(); for (i=0; i<t2.length; i++) System.out.println("Elem " + i + ": " + (Integer)t2[i]); c2.remove(new Integer(20)); // Comparacin de colecciones if (c1.equals(c2)) System.out.println("Son iguales"); else System.out.println("Son distintas"); if (c1.containsAll(c2)) System.out.println("c2 contenida en c1"); else System.out.println("c2 no contenida en c1"); } }

NOTA: Aunque la interfaz Collection se puede usar para instanciar objetos, su principal cometido es definir los mtodos comunes a todas las colecciones. Por ello, lo normal es usar algunas de sus interfaces hijas (List, Set o SortedSet). As pues, a partir de ahora usaremos el interfaz List como ejemplo de coleccin, ya que es ms apropiado.

Estructuras de Datos

Pgina 5 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

3 Iteradores
Los objetos de tipo iterador permiten recorrer colecciones. Disponen de un conjunto de mtodos que permiten avanzar sobre la coleccin y obtener los objetos de sta durante un recorrido para su tratamiento. Existen dos interfaces declarados en el JCF: java.util.Iterator, que dispone de mtodos para recorrer una coleccin y para borrar elementos; y java.util.ListIterator, que permite recorrer una lista en ambos sentidos, siendo ste segundo descendiente del primero.

3.1. Interfaz Iterator

El interfaz Iterator sustituye a Enumeration, utilizada en versiones anteriores (JDK 1.1). Podemos ver un iterador como un puntero que seala un elemento de una coleccin, que denominamos elemento actual, y es capaz de pasar al siguiente elemento para as recorrer dicha coleccin. El interfaz Iterator proporciona slo tres mtodos:
public interfaz java.util.Iterator { public boolean hasNext(); public Object next(); public void remove(); //opcional }

hasNext(): devuelve cierto si el elemento actual tiene siguiente en la coleccin, es decir, mientras existan elementos no tratados mediante el mtodo next. next(): devuelve una referencia al siguiente elemento en la coleccin, es decir, coloca el iterador en el elemento siguiente y lo devuelve (como Object). Es el mtodo utilizado para acceder a los elementos de una coleccin. Lanza NoSuchElementException si se invoca un nmero de veces superior al nmero de elementos existentes en la coleccin. remove(): Elimina de la coleccin el ltimo elemento retornado por next. Solo puede ser llamado una vez por cada llamada a next, y siempre despus de ste. Es la nica forma segura de eliminar un elemento mientras se est recorriendo una coleccin. Eleva IllegalEstateException si no se cumplen las condiciones expuestas para la llamada; y UnsupportedOperationException si la implementacin de este interfaz no incluy este mtodo (ya que es opcional).

Como vimos en apartados anteriores, la interfaz Collection dispone de un mtodo denominado iterator(), que devuelve un Iterator situado antes del primer elemento de la coleccin, (es decir, si it es un iterador, it.next() devolver el primer elemento). El mtodo iterator() es utilizado para inicializar los iteradores antes de comenzar el recorrido de la coleccin. As, el recorrido bsico de una coleccin es el siguiente:
Iterator it = coleccin.iterator(); while (it.hasNext()) { Tipo obj = (<Casting>)it.next(); TRATAR obj }

Estructuras de Datos

Pgina 6 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

Para los siguientes ejemplos, usaremos la clase Persona y la interfaz Empleado, definidos de la siguiente forma:
public interface Empleado{ public String getNombre(); public String getApellidos(); public int getEdad(); } public class Persona implements Comparable, Empleado{ private String nombre, apellidos; private int edad; public Persona(String n, String a, int e){ ... } < Aqu iran el resto de mtodos > }

Ejemplo: Recorrido de una coleccin de Personas.

public class TestIterator{ public static void main(String args[]){ List c = new ArrayList(); // Inicializa la lista c c.add(new c.add(new c.add(new c.add(new c.add(new Persona("Pepe", "Lopez Perez", 25)); Persona("Lola", "Lopez Aguilar", 23)); Persona("Pepe", "Lopez Perez", 21)); Persona("Antonio", "Lopez Perez", 25)); Persona("Alicia", "Sanchez Olmo", 21));

// Recorrido: Imprime la lista elemento a elemento Iterator it = c.iterator(); while(it.hasNext()) System.out.println((Persona)it.next()); // Recorrido: Incrementa en 1 la edad de todas las personas System.out.println("Incrementar en 1 la edad de todas las personas------"); it=c.iterator(); while(it.hasNext()) { Persona p = (Persona) it.next(); p.setEdad(p.getEdad()+1); } // Recorrido: Vuelve a imprimir la lista elemento a elemento it = c.iterator(); while(it.hasNext()) System.out.println((Persona)it.next()); } }

La salida de este programa es:

Lopez Perez, Pepe (25) Lopez Aguilar, Lola (23) Lopez Perez, Pepe (21) Lopez Perez, Antonio (25) Sanchez Olmo, Alicia (21) Incrementar en 1 la edad de todas las personas-----Lopez Perez, Pepe (26) Lopez Aguilar, Lola (24) Lopez Perez, Pepe (22) Estructuras de Datos Pgina 7 de 24

ED - Enseanza Bsica Lopez Perez, Antonio (26) Sanchez Olmo, Alicia (22) Process Exit...

Tema 1: Introduccin al JCF

Ejemplo: Eliminar elementos de una coleccin de Empleados. Este ejemplo es realizado usando la interfaz Empleado en vez de la clase Persona para rellenar la coleccin. En este caso, pretendemos borrar todos los empleados de la coleccin cuya edad sea superior a 24 aos.
public class TestIterator2{ public static void main(String args[]){ List c = new ArrayList(); // Inicializa la lista c Empleado e1 = new Persona("Pepe", "Lopez Perez", 25); Empleado e2 = new Persona("Lola", "Lopez Aguilar", 23); Empleado e3 = new Persona("Pepe", "Lopez Perez", 21); Empleado e4 = new Persona("Antonio", "lopez Perez", 25); Empleado e5 = new Persona("Alicia", "Sanchez Olmo", 21); c.add(e1); c.add(e2); c.add(e3); c.add(e4); c.add(e5); // Recorrido: Imprime la lista elemento a elemento Iterator it = c.iterator(); while(it.hasNext()) System.out.println((Empleado)it.next()); // Recorrido: Elimina los mayores de 24 aos System.out.println("Quitar los Empleados mayores de 24 aos------"); it=c.iterator(); while(it.hasNext()) { Empleado e = (Empleado) it.next(); if(e.getEdad()>24) it.remove(); } // Recorrido: Vuelve a imprimir la lista elemento a elemento it = c.iterator(); while(it.hasNext()) System.out.println((Persona)it.next()); } }

La salida de este programa es:

Lopez Perez, Pepe (25) Lopez Aguilar, Lola (23) Lopez Perez, Pepe (21) lopez Perez, Antonio (25) Sanchez Olmo, Alicia (21) Quitar los Empleados mayores de 24 aos-----Lopez Aguilar, Lola (23) Lopez Perez, Pepe (21) Sanchez Olmo, Alicia (21) Process Exit...

Estructuras de Datos

Pgina 8 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

3.2. Interfaz ListIterator

Este tipo especial de iterador (deriva de la interfaz Iterator) slo es vlido para recorrer listas (List), nunca Collection, Set o SortedSet. Aade mtodos a Iterator para iterar hacia atrs, para insertar o remplazar durante la iteracin y para obtener la posicin del puntero interno. Entre cada par de elementos, y tambin antes del primero y despus del ltimo existe una posible posicin del iterados. Los elementos se numeran desde 0 a n-1, pero los valores vlidos para el ndice son de 0 a n. Puede suponerse que el ndice i est en la frontera entre los elementos i-1 e i. Por ejemplo: (0) ele0 (1) ele1 (2) ele2 (3) ele3 (4) El interfaz List incorpora dos mtodos para asignar o inicializar un ListIterator, en concreto, el mtodo ListIterator() de una lista devuelve un ListIterator cuyo puntero es cero. El mtodo ListIterator(int) posiciona el puntero en el ndice int. Los mtodos del interfaz ListIterator son los siguientes:
public interfaz ListIterator extends Iterator { public void add(Object); public boolean hasNext(); public boolean hasPrevious(); public Object next(); public int nextIndex(); public Object previous(); public int previousIndex(); public void remove(); public void set(Object); }

Como vemos, adems de los mtodos del interfaz padre Iterator, el interfaz ListIterator implementa otros. La descripcin de todos ellos es: hasNext(): devuelve un cierto si el elemento actual tiene siguiente en la coleccin, es decir, devuelve verdadero mientras existan elementos no tratados mediante el mtodo next. hasPrevious(): devuelve un cierto si el elemento actual tiene anterior en la lista, es decir, devuelve verdadero mientras existan elementos no tratados mediante el mtodo previous. next(): devuelve el elemento en cuyo ndice se halla el puntero y avanza una posicin el valor del mismo. La primera vez que se invoca sobre el objeto retornado por el mtodo ListIterator() devuelve el primer elemento de la lista. Cuando se invoca sobre el objeto retornado por ListIterator(int) devuelve el elemento de ndice int. Si int fuera el tamao de la lista o si la iteracin ha alcanzado el final de la lista, lanzara la excepcin NoSuchElementException. previous(): devuelve el elemento situado inmediatamente antes de la posicin actual del iterador y resta uno a su valor (retrocede en la lista). Cuando es invocado sobre el objeto devuelto por ListIterator() lanza NoSuchElementException. Si se llama sobre el

Estructuras de Datos

Pgina 9 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

objeto devuelto por ListIterator(int) devuelve el objeto situado en el ndice int-1. Tambin lanza NoSuchMethodException si la iteracin ha alcanzado el principio de la lista. nextIndex(): devuelve el ndice del elemento que sera retornado por la prxima llamada a next(), es decir la posicin actual del puntero. Si el puntero se encuentra al final de la coleccin devuelve su tamao. previousIndex(): devuelve el ndice del elemento que sera retornado por la prxima llamada a previous(), es decir la posicin actual del puntero menos uno. Devuelve -1 si el puntero se encuentra al comienzo de la lista. remove(): elimina de la lista el ltimo elemento retornado por next() o previous(). Slo puede ser llamado una vez por cada llamada a next() o previous(), y slo si no se invoc add() o remove() despus. Los ndices de los elementos posteriores son decrementados en uno. Lanza UnsupportedOperationException si la implementacin de este interfaz no incorpor este mtodo; e IllegalStateException si next o previous no fueron llamados, o bien se invoc add o remove tras la ltima llamada a next o previous. add(Object): inserta el objeto en la lista en la posicin actual del puntero y aumenta en uno su valor. La siguiente llamada a next() quedara sin afectar, pero previous() devolvera el elemento recin insertado. Los valores de los ndices de elementos posteriores son incrementados en uno. No es necesario haber invocado a next o previous con anterioridad. Lanza las siguientes excepciones: UnsupportedOperationException, si la implementacin de este interfaz no incorpor este mtodo; ClassCastException, si el tipo de este objeto impidi su adicin a una lista; IllegalStateException, si este objeto infringe alguna restriccin al ser aadido a una Collection. set(Object) remplaza el ltimo elemento producido por next o previous por el objeto especificado. Puede ser invocado varias veces sin necesidad de llamar nuevamente a next o previous, siempre y cuando no aparezcan add o remove entre dichas llamadas. Lanza las siguientes excepciones: UnsupportedOperationException, si la implementacin de este interfaz no incorpor este mtodo; ClassCastException, si el tipo de este objeto impidi su adicin a una lista, IllegalStateException, si este objeto infringe alguna restriccin que impida su adiccin a la lista, o bien, next o previous no fueron llamados, o lo fueron pero despus de la invocacin a add o remove.

El recorrido bsico ascendente de una lista mediante un ListIterator es el idntico al de Iterator, mientras que el recorrido descendente es el siguiente:

ListIterator it = lista.listIterator(<posicin de inicio>); while (it.hasPrevious()) { Tipo obj = (<Casting>)it.previous(); TRATAR obj }

Estructuras de Datos

Pgina 10 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

Ejemplo:
import java.util.*; public class TestListIterator{ public static void main(String args[]){ List c = Empleado Empleado Empleado Empleado Empleado new ArrayList(); e1 = new Persona("Pepe", "Lopez Perez", 25); e2 = new Persona("Lola", "Lopez Aguilar", 23); e3 = new Persona("Pepe", "Lopez Perez", 21); e4 = new Persona("Antonio", "lopez Perez", 25); e5 = new Persona("Alicia", "Sanchez Olmo", 21);

c.add(e1); c.add(e2); c.add(e3); c.add(e4); c.add(e5); //Recorrido hacia delante System.out.println("----- Recorrido hacia delante: "); ListIterator it = c.listIterator(); while(it.hasNext()) { System.out.print("ndice " + it.nextIndex() + ": "); System.out.println((Empleado)it.next()); } //Recorrido hacia atras System.out.println("----- Recorrido hacia atrs: "); it = c.listIterator(c.size()); while(it.hasPrevious()){ System.out.print("ndice " + it.previousIndex() + ": "); System.out.println((Empleado)it.previous()); } //Recorrido hacia delante desde la posicin 2 System.out.println("----- Recorrido hacia delante desde la posicin 2 : "); it = c.listIterator(2); while(it.hasNext()){ System.out.print("ndice " + it.nextIndex() + ": "); System.out.println((Empleado)it.next()); } //Recorrido hacia atrs desde la posicin 2 System.out.println("----- Recorrido hacia atrs desde la posicin 2 : "); it = c.listIterator(2); while(it.hasPrevious()){ System.out.print("ndice " + it.previousIndex() + ": "); System.out.println((Empleado)it.previous()); } //Inserta un empleado en la posicin 2 (tercer empledo) System.out.println("----- Inserta un empleado en la posicin 2 (tercer empleado): "); Empleado eAux = new Persona("Teresa", "Gmez Gmez", 32); it = c.listIterator(2); it.add(eAux); // deja it apuntando al que acaba de insertar //Modifica el empleado en la posicin 1 (segundo empledo) System.out.println("----- Modifica el empleado en la posicin 1 (segundo empledo): "); eAux = new Persona("DOLORES", "Lopez Aguilar", 40); it = c.listIterator(1); if(it.hasNext()) { it.next(); Estructuras de Datos Pgina 11 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

it.set(eAux); //Modifica el ltimo Objeto devuelto por next }

//Recorrido hacia delante System.out.println("----- Lista final: "); it = c.listIterator(); while(it.hasNext()) { System.out.print("ndice " + it.nextIndex() + ": "); System.out.println((Empleado)it.next()); } } }

La salida de este programa es:

----- Recorrido hacia delante: ndice 0: Lopez Perez, Pepe (25) ndice 1: Lopez Aguilar, Lola (23) ndice 2: Lopez Perez, Pepe (21) ndice 3: lopez Perez, Antonio (25) ndice 4: Sanchez Olmo, Alicia (21) ----- Recorrido hacia atrs: ndice 4: Sanchez Olmo, Alicia (21) ndice 3: lopez Perez, Antonio (25) ndice 2: Lopez Perez, Pepe (21) ndice 1: Lopez Aguilar, Lola (23) ndice 0: Lopez Perez, Pepe (25) ----- Recorrido hacia delante desde la posicin 2 : ndice 2: Lopez Perez, Pepe (21) ndice 3: lopez Perez, Antonio (25) ndice 4: Sanchez Olmo, Alicia (21) ----- Recorrido hacia atrs desde la posicin 2 : ndice 1: Lopez Aguilar, Lola (23) ndice 0: Lopez Perez, Pepe (25) ----- Inserta un empleado en la posicin 2 (tercer empleado): ----- Modifica el empleado en la posicin 1 (segundo empledo): ----- Lista final: ndice 0: Lopez Perez, Pepe (25) ndice 1: Lopez Aguilar, DOLORES (40) ndice 2: Gmez Gmez, Teresa (32) ndice 3: Lopez Perez, Pepe (21) ndice 4: lopez Perez, Antonio (25) ndice 5: Sanchez Olmo, Alicia (21) BUILD SUCCESSFUL (total time: 0 seconds)

Estructuras de Datos

Pgina 12 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

4 Interfaces Comparable y Comparator

Estas interfaces estn orientadas a mantener ordenadas las colecciones (listas, sets y maps) que deben mantener un orden. Para ello se dispone de las interfaces java.lang.Comparable y java.util.Comparator (obsrvese que pertenecen a packages diferentes).

4.1. Interfaz Comparable

Se dice que las clases que implementan esta interfaz cuentan con un orden natural. Este orden es total, es decir, que siempre han de poder ordenarse dos objetos cualesquiera del la clase que implementa este interfaz. La interfaz Comparable declara el mtodo compareTo() de la siguiente forma:
public int compareTo(Object obj)

que compara su argumento implcito con el que se le pasa por ventana. Este mtodo devuelve un entero negativo, cero o positivo segn el argumento implcito (this) sea anterior, igual o posterior al objeto obj., respectivamente. Si se redefine, el mtodo compareTo() debe ser programado con cuidado: es muy conveniente que sea coherente con el mtodo equals() y que cumpla la propiedad transitiva.(Si X<Y y Y<Z => X<Z) Las listas y las tablas cuyos elementos implementan Comparable pueden ser ordenadas con los mtodos Collections.sort() y Arrays.sort(). Por ejemplo, si una clase implementa Comparable, se puede utilizar en las siguientes acciones sin necesidad de un Comparator: Si ObjArray es una matriz, puede ser ordenada mediante Arrays.sort(ObjArray). Si ObjList es una Lista, puede ser ordenada mediante Collections.sort(ObjList), o se puede buscar un objeto obj mediante Collections.binarySearch(ObjList, obj). Se puede usar como un elemento dentro de un TreeSet.

Ejemplo (Ordenacin de una Lista usando Comparable). El interfaz Empleado es implementado por la clase Persona, que a su vez implementa el interfaz Comparable (redefiniendo compareTo). As, compareTo() define la ordenacin natural de las personas, siendo sta por apellidos, nombre y edad.
// Empleado.java public interfaz Empleado{ public String getNombre(); public String getApellidos(); public int getEdad(); // No se aade compareTo, ya que est declarado en la interfaz Comparable } // Persona.java public class Persona implements Comparable, Empleado{ private String nombre, apellidos; private int edad;

Estructuras de Datos

Pgina 13 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

public Persona(String n, String a, int e){ nombre = n; apellidos = a; edad = e;} public String getNombre(){return nombre;} public String getApellidos(){return apellidos;} public int getEdad(){return edad;} public boolean equals(Object o) { if(!(o instanceof Persona)) return false; else{ Persona p = (Persona)o; return p.nombre.equals(nombre) && p.apellidos.equals(apellidos) && p.edad==edad; //son enteros int } } public String toString(){ return apellidos + ", " + nombre + " (" + edad +")" ; } public int compareTo(Object o){ Persona p = (Persona)o; //Eleva ClassCastException //si o no es una Persona int cmp = apellidos.compareTo(p.apellidos); //Primero por apellidos if (cmp == 0) { cmp = nombre.compareTo(p.nombre); //Segundo por nombre if (cmp == 0) { cmp = edad - p.edad; // Finalmente por edad } } return cmp; } }

//TestEmpleado.java import java.util.*; public class TestEmpleado{ public static void main(String args[]){ List c = new ArrayList(); Empleado e1 = new Persona("Pepe", "Lopez Perez", 25); Empleado e2 = new Persona("Lola", "Lopez Aguilar", 23); Empleado e3 = new Persona("Pepe", "Lopez Perez", 21); Empleado e4 = new Persona("Antonio", "lopez Perez", 25); Empleado e5 = new Persona("Alicia", "Sanchez Olmo", 21); c.add(e1); c.add(e2); c.add(e3); c.add(e4); c.add(e5);

Estructuras de Datos

Pgina 14 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

//Compara dos Empleados if(((Persona)e1).compareTo((e2))>0){ // MUY IMPORTANTE EL CASTING System.out.println(e1 + " es mayor que " + e2); } else{ System.out.println(e1 + " es menor o igual que " + e2); } //Imprime la lista original System.out.println("Lista Original:"); System.out.println(c); //Ordena e imprime la lista ordenada segn la ordenacin natural de Persona System.out.println("Ordenacin:"); Collections.sort(c); //Ordena System.out.println(c); } }

La salida de este programa es:

Lopez Perez, Pepe (25) es mayor que Lopez Aguilar, Lola (23) Lista Original: [Lopez Perez, Pepe (25), Lopez Aguilar, Lola (23), Lopez Perez, Pepe (21), lopez Perez, Antonio (25), Sanchez Olmo, Alicia (21)] Ordenacin: [Lopez Aguilar, Lola (23), Lopez Perez, Pepe (21), Lopez Perez, Pepe (25), Sanchez Olmo, Alicia (21), lopez Perez, Antonio (25)]

Ntese que tras la ordenacin, la persona lopez Perez, Antonio (25) es la ltima al comenzar su apellido por minscula.

4.2. Interfaz Comparator

Si una clase ya tiene un criterio de ordenacin natural (interfaz Comparable) y se desea tener un criterio de ordenacin diferente, por ejemplo descendente o dependiente de otros campos, es necesario crear una clase que implemente dicho criterio. Esta clase, que se denomina comparador, es independiente de la clase objeto de la ordenacin y deber implementar la interfaz Comparator del paquete java.util. Un comparador es por tanto una clase que define un criterio de ordenacin de otras clases. La interfaz Comparator declara el mtodo compare en la forma:
public int compare(Object o1, Object o2);

As, la clase comparadora deber implementar la interfaz Comparator, y por tanto el mtodo compare, de la siguiente forma:
public class MiComparador implements Comparator{ public int compare(Object o1, Object o2){ <implementacin del criterio de comparacin> } }

Estructuras de Datos

Pgina 15 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

El mtodo compare() devuelve un entero negativo, cero o positivo segn su primer argumento sea anterior, igual o posterior al segundo (as asegura un orden ascendente). La implementacin debe asegurar que: signo(compare(x,y) debe ser igual a - signo(compare(y,x)) para todas las x, y. Esto implica que compare(x, y) lanzar una excepcin solo si compare(y, x) la lanza. La relacin es transitiva: compare(x,y) > 0 && compare(y,z) > 0 implican compare(x z) > 0. compare(x,y)==0 implica signo(compare(x,z)==sgn(compare(y,z)) para todo z. Este mtodo lanzar la excepcin ClassCastException si el tipo de los argumentos impide la comparacin por este Comparator.

Es muy importante que compare() sea compatible con el mtodo equals() de los objetos que hay que mantener ordenados. Su implementacin debe cumplir unas condiciones similares a las de compareTo(). Los objetos que implementa la interfaz Comparator pueden ser utilizados en las siguientes situaciones (especificando un orden distinto al natural): Como argumento a un constructor TreeSet o TreeMap (con la idea de que las mantengan ordenadas de acuerdo con dicho comparador). En los mtodos de ordenacin Collections.sort(List, Comparator) y Arrays.sort(Object[], Comparator). En los mtodos de bsqueda Collections.binarySearch(List, Object, Comparator) y Arrays.binarySearch(List, Object, Comparator).

Ejemplo (Ordenacin de una lista usando Comparator). Este ejemplo es similar al anterior. De hecho, usa la interfaz Empleado definida en el ejemplo anterior. Se aaden dos comparadores para hacer diferentes ordenaciones, en concreto: ComparadorIgnoraMayMin, cuyo mtodo compare() compara dos Personas con el mismo criterio que compareTo() del ejemplo anterior, slo que en este caso no se distinguen maysculas y minsculas; el otro comparador es ComparadorEdad, que usa la edad como criterio de comparacin entre personas (si son de la misma edad, compara por apellidos y nombre).

//ComparadorIgnoraMayMin import java.util.*; class ComparadorIgnoraMayMin implements Comparator { public int compare(Object o1, Object o2) { Persona p1 = (Persona)o1; //Eleva ClassCastException si o1 no es Persona Persona p2 = (Persona)o2; //Eleva ClassCastException si o2 no es Persona //Es igual que compareTo de Persona pero usando compareToIgnoreCase() int cmp = p1.getApellidos().compareToIgnoreCase(p2.getApellidos()); if (cmp == 0){ cmp = p1.getNombre().compareToIgnoreCase(p2.getNombre()); if (cmp == 0){ cmp = p1.getEdad() - p2.getEdad(); } } return cmp; } } // ComparadorEdad.java import java.util.*; Estructuras de Datos Pgina 16 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

class ComparadorEdad implements Comparator { public int compare(Object o1, Object o2) { Persona p1 = (Persona)o1; //Eleva ClassCastException si o1 no es Persona Persona p2 = (Persona)o2; //Eleva ClassCastException si o2 no es Persona int cmp = p1.getEdad() - p2.getEdad(); //Primero por edad if (cmp == 0) { cmp = p1.getApellidos().compareTo(p2.getApellidos());//Luego por apellidos if (cmp == 0) { cmp = p1.getNombre().compareTo(p2.getNombre()); //finalmente por nombre } } return cmp; } } // TestEmpleadoComparators.java import java.util.*; public class TestEmpleadoComparators{ public static void main(String args[]){ List c = new ArrayList(); Empleado e1 = new Persona("Pepe", "Lopez Perez", 25); Empleado e2 = new Persona("Lola", "lopez Aguilar", 23); Empleado e3 = new Persona("Pepe", "Lopez Perez", 21); Empleado e4 = new Persona("Antonio", "Lopez Perez", 25); Empleado e5 = new Persona("Alicia", "Sanchez Olmo", 21); c.add(e1); c.add(e2); c.add(e3); c.add(e4); c.add(e5); //Imprime Lista Original System.out.println("Lista Original:"); System.out.println(c); //Ordenacin natural (Comparable de Persona) System.out.println("Ordenacin Natural (Comparable):"); Collections.sort(c); System.out.println(c); //Ordenacin sin diferenciar entre Maysculas y Minsculas (Comparator) System.out.println("Ordenacin Natural sin MayMin (Comparator):"); Collections.sort(c, new ComparadorIgnoraMayMin()); System.out.println(c); //Ordenacin por Edad (Comparator) System.out.println("Ordenacin por edad(Comparator):"); Collections.sort(c, new ComparadorEdad()); System.out.println(c); } }

La salida de este programa es:

Lista Original: [Lopez Perez, Pepe (25), lopez Aguilar, Lola (23), Lopez Perez, Pepe (21), Lopez Perez, Antonio (25), Sanchez Olmo, Alicia (21)] Ordenacin Natural (Comparable): [Lopez Perez, Antonio (25), Lopez Perez, Pepe (21), Lopez Perez, Pepe (25), Sanchez Olmo, Alicia (21), lopez Aguilar, Lola (23)]

Estructuras de Datos

Pgina 17 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

Ordenacin Natural sin MayMin (Comparator): [lopez Aguilar, Lola (23), Lopez Perez, Antonio (25), Lopez Perez, Pepe (21), Lopez Perez, Pepe (25), Sanchez Olmo, Alicia (21)] Ordenacin por edad(Comparator): [Lopez Perez, Pepe (21), Sanchez Olmo, Alicia (21), lopez Aguilar, Lola (23), Lopez Perez, Antonio (25), Lopez Perez, Pepe (25)] Process Exit...

4.3. Cundo usar Comparable y Comparator?

Usaremos Comparable para definir el orden natural de una clase C, entendiendo por orden natural aquel que se utilizar normalmente o simplemente por convenio. As, diremos que los objetos de clase C son comparables. Por otro lado, implementaremos nuevas clases (C1 Cn) que extiendan el interfaz Comparator por cada ordenacin nueva que necesitemos distinta a la natural para la clase C. As tendremos una librera de comparadores (C1 Cn) para la clase C.

Estructuras de Datos

Pgina 18 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

5 Utilidades para objetos contenedores: Clase java.util.Collections

La clase Collections (no confundir con la interfaz Collection, en singular) es una clase que define un buen nmero de mtodos static con diversas finalidades. Dado que son estticos, la llamada a dichos mtodos es: Collections.metodo(<argumentos>) Los ms interesantes son los siguientes (todos los mtodos aqu expuestos retornan o toman como argumentos una List, excepto max y min que toman como argumento una Collection):

5.1. Ordenacin
public static void sort(List); public static void sort(List, Comparator);

Ordenan la lista, bien de forma ascendente segn el orden natural (establecido por el interfaz Comparable), o bien de la forma especificada por Comparator. Tal ordenacin es estable, es decir, los elementos iguales no son desplazados. Lanzan las siguientes excepciones: ClassCastException, si un elemento en la lista tiene un tipo que impide su comparacin con el resto los interfaces Comparable o Comparator; UnsupportedOperationException, si la lista no es modificable (su iterator no soporta la operacin set).

5.2. Inversin del Orden

public static void reverse(List); public static Comparator reverseOrder();

El mtodos reverse(List) ordena la lista en el sentido inverso de la posicin actual de sus elementos (independiente del valor de los elementos). No realiza una ordenacin descendente. El mtodo reverseOrder() devuelve un Comparator que introduce una ordenacin inversa a la impuesta por el orden natural de un contenedor de objetos que implementan el interfaz Comparable. El Comparator devuelto implementa el mtodo compare() de forma que devuelve el resultado de compareTo()cambiado de signo. Puede utilizarse donde se espere un Comparator, por ejemplo: Arrays.sort(list, Collections.reverseOrder()).

5.3. Bsqueda
public static int binarySearch(List, Object); public static int binarySearch(List, Object, Comparator);

Buscan el objeto en la lista y devuelven la posicin (int) de tal objeto (resultado 0 o positivo). Si no est en la lista devuelve (-(pos_mayor)-1); donde pos_mayor es la posicin del primer elemento en la lista mayor que el buscado, o el tamao de la lista si el elemento buscado es el mayor de todos. La lista debe estar ordenada de forma ascendente. Esto puede lograrse con un orden natural para el primer mtodo, como por ejemplo sort(List); o bien usando un Comparator para el segundo mtodo: sort(List,Comparator). Los resultados no son especificados si la lista esta desordenada. No se asegura cul ser el elemento devuelto si existen duplicados. Lanzan la excepcin ClassCastException si algn elemento en la lista tiene un tipo que impide su comparacin.
Estructuras de Datos Pgina 19 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

NOTA: Sobre el sentido de la ordenacin impuesto por sort y el sentido en que esta ordenada la lista o matriz que binarySearch examina, la API especifica que en estos dos mtodos, tanto en la clase Arrays como en la clase Collections, el sentido de la ordenacin sea ascendente. Esto es debido a que las clases que implementan Comparable o Comparator lo hacen en la forma descrita en la API. Siguiendo estas recomendaciones los comparadores que cresemos seran siempre ascendentes. Para lograr una ordenacin inversa utilizaramos el mtodo reverseOrder de la clase Collection. Alternativamente puede implementarse un Comparator o Comparable descendente y utilizarse en ambos mtodos. Luego, lo realmente importante es mantener el sentido con el que se ha ordenado un contenedor a la hora de buscar en l. Es conveniente tambin recordar que los tipos primitivos y sus envolturas implementan Comparable en sentido ascendente.

5.4. Copiar Lista

public static void copy(List, List);

Copia los elementos residentes en el segundo argumento en el primero. Si el tamao del destino es mayor que el de la fuente, los restantes elementos no se ven afectados. Lanza IndexOutOfBoundsException si el tamao del destino es menor que el de la fuente, y UnsupportedOperationException si el iterator de la lista no soporta la operacin set.

5.5. Rellenar una Lista

public static void fill(java.util.List, Object);

Remplaza todos los elementos de la lista por el objeto especificado. No modifica el tamao de la lista. Se ejecuta en un tiempo lineal. Lanza UnsupportedOperationException si el iterator de la lista no soporta la operacin set.

5.6. Mximos y Mnimos

public public public public static static static static Object Object Object Object max(Collection); max(Collection, Comparator); min(Collection); min(Collection, Comparator);

Devuelven el objeto que en la coleccin especificada sea el menor, o el mayor de todos, de acuerdo al orden natural (establecido por Comparable) de tales objetos, o segn el Comparator especificado.

5.7. Constantes
public static final java.util.List EMPTY_LIST; public static final java.util.Set EMPTY_SET;

Existen tres constantes (campos estticos finales) de tipo List y Set que son inicializados para contener un objeto vaco del tipo correspondiente. Sus nombres son EMPTY_LIST y EMPTY_SET. Sirven para representar contenedores vacos.

Estructuras de Datos

Pgina 20 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

Ejemplo:

import java.util.*; public class TestCollections{ public static void main(String args[]){ List c = new ArrayList(); int pos; Empleado e1 = new Persona("Pepe", "Lopez Perez", 25); Empleado e2 = new Persona("Lola", "lopez Aguilar", 23); Empleado e3 = new Persona("Pepe", "Lopez Perez", 21); Empleado e4 = new Persona("Antonio", "Lopez Perez", 25); Empleado e5 = new Persona("Alicia", "Sanchez Olmo", 21); c.add(e1); c.add(e2); c.add(e3); c.add(e4); c.add(e5); //Imprime Lista Original System.out.println("Lista Original:"); System.out.println(c); //Ordenacin natural (Comparable de Persona) y Bsqueda System.out.println("Ordenacin Natural (Comparable) y Bsqueda:"); Collections.sort(c); //Ordenacin natural usando Comparable System.out.println(c); pos=Collections.binarySearch(c, e4); System.out.println("Bsqueda: La posicin de <" + e4 + "> es " + pos); //Ordenacin por Edad (Comparator) y Bsqueda System.out.println("Ordenacin por edad y bsqueda:"); Collections.sort(c, new ComparadorEdad());//Ordenacin usando ComparadorEdad System.out.println(c); pos=Collections.binarySearch(c, e4, new ComparadorEdad()); System.out.println("Bsqueda: La posicin de <" + e4 + "> es " + pos); //Mximo y mnimo Empleado eMax = (Empleado) Collections.max(c, new ComparadorEdad()); Empleado eMin = (Empleado) Collections.min(c, new ComparadorEdad()); System.out.println("Empleado ms viejo: " + eMax); System.out.println("Empleado ms joven: " + eMin); } }

Estructuras de Datos

Pgina 21 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

6 Clase Arrays (ampliacin)

Esta clase es muy parecida a la case Collections vista anteriormente, por lo que sus mtodos los veremos con menor nivel de detalle. La invocacin a tales mtodos tambin es similar: Arrays.metodo(<argumentos>)

6.1. Tratar Matriz como Lista

public static List asList(Object[]);

Retorna una vista (no una copia) de la matriz pasada como argumento implcito, que puede ser manipulada como si fuera una lista. Como dicha lista es respaldada por una matriz no pueden agregarse o eliminarse elementos a ella. Cualquier modificacin estructural (del nmero de elementos) provoca UnsupportedOperationException debido a la no implementacin de los mtodos opcionales del interfaz List en la lista retornada. El resto de cambios en la lista son reflejados en la matriz y viceversa.

6.2. Mtodos similares a los de Collections

public public public public static static static static void void void void sort(tipoPrimitivo[]); sort(tipoPrimitivo[], Comparator); sort(Object[]); sort(Object[], Comparator);

public static int binarySearch(tipoPrimitivo[], unPrimitivo); public static int binarySearch(Object[], Object); public static int binarySearch(Object[], Object, Comparator); public static void fill(tipoPrimitivo[], unPrimitivo); public static void void fill(tipoprimitivo[], int fromIndex, int toIndex, unPrimitivo); public static void void fill(Object[], Object); public static void void fill( Object[], int fromIndex, int toIndex, Object);

7 Clase java.lang.Math
La case Math del paquete estndar java.lang contiene mtodos estticos para realizar operaciones matemticas bsicas como exponencial, logaritmos, raiz cuadrada, funciones trigonomtricas, etc. La invocacin a tales mtodos o constantes es similar a los de Collections y Arrays: Math.metodo(<argumentos>) Los miembros ms interesantes de esta clase son:
public final class java.lang.Math { // Constantes public static final double E; public static final double PI; // Funciones trigonomtricas double sin(double); double cos(double); double tan(double); double asin(double); double acos(double); Estructuras de Datos Pgina 22 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

double atan(double); double toRadians(double); double toDegrees(double); // Funciones bsicas double exp(double); double log(double); double log10(double); double sqrt(double); double ceil(double); double floor(double); double pow(double, double); <int/long/float/double> abs(<int/long/float/double>); <int/long/float/double> max(<int/long/float/double>, <int/long/float/double>); <int/long/float/double> max(<int/long/float/double>, <int/long/float/double>); < . . . > }

Estructuras de Datos

Pgina 23 de 24

ED - Enseanza Bsica

Tema 1: Introduccin al JCF

8 Bibliografa
Documentacin de la API de Java: o o o o o o o o o Pgina principal de JCF: http://java.sun.com/j2se/1.5.0/docs/guide/collections/index.html Tutorial de JCF - Introduccin: http://java.sun.com/docs/books/tutorial/collections/intro/index.html Especificacin de la interfaz Comparable: http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Comparable.html Especificacin de la interfaz Comparator: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html Especificacin de la interfaz Iterator: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Iterator.html Especificacin de la interfaz ListIterator: http://java.sun.com/j2se/1.5.0/docs/api/java/util/ListIterator.html Especificacin de la clase Collections: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Collections.html Especificacin de la clase Arrays: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Arrays.html Especificacin de la clase Math: http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Math.html Bruce Eckel. Prentice Hall, 2002. Captulo Captulo 11. 4.

Thinking in Java, 3rd Edition. http://www.mindview.net/Books/TIJ/

Aprenda Java como si Estuviera en http://mat21.etsii.upm.es/ayudainf/aprendainf/Java/Java2.pdf

Primero.

Estructuras de Datos

Pgina 24 de 24