¡Descarga Estructura de Colecciones de Java y más Apuntes en PDF de Programación Lineal solo en Docsity!
Tema 6.Estructura de Colecciones de Java (Java
Collections Framework).
6.1 Introducción.
En este tema vamos a estudiar un conjunto de clases e interfaces de Java que forman el Java Collections Framework y que constituyen un conjunto de herramientas que aumentan las capacidades del lenguaje a la hora de trabajar con estructuras de datos.
En la siguiente imagen se muestra la jerarquía de interfaces (y clases que las implementan en cursiva) del JCF.
En el diseño de la JCF las interfaces son muy importantes porque son ellas las que determinan las capacidades de las clases que las implementan. Dos clases que implementan la misma interfaz se pueden utilizar exactamente de la misma forma. Por ejemplo, las clases ArrayList y LinkedList disponen exactamente de los mismos métodos y se pueden utilizar de la misma forma. La diferencia está en la implementación: mientras que ArrayList almacena los objetos en un array, la clase LinkedList los almacena en una lista enlazada. La primera será más eficiente para acceder a un elemento arbitrario, mientras que la segunda será más flexible si se desea borrar e insertar elementos.
Interfaces de la JCF : Constituyen el elemento central de la JCF.
Collection : define métodos para tratar una colección genérica de elementos Set : colección que no admite elementos repetidos SortedSet : set cuyos elementos se mantienen ordenados según el criterio establecido List : admite elementos repetidos y mantiene un orden inicial Map : conjunto de pares clave/valor, sin repetición de claves
SortedMap : map cuyos elementos se mantienen ordenados según el criterio establecido
Interfaces de soporte :
Iterator : Dispone de métodos para recorrer una colección y para borrar elementos. ListIterator : deriva de Iterator y permite recorrer lists en ambos sentidos. Comparable : declara el método compareTo(). La clase que implemente dicho interfaz definirá el llamado orden natural para sus objetos el cual será utilizado en las estructuras de datos. Comparator : declara el método compare(). Proporciona una forma más flexible de tener distintas formas de comparar objetos pero es mas costoso en tiempo de codificación. Podemos crear distintas clases que implementen este interfaz y tener distintos metodos compare() para una clase. Después, a la hora de crear la estructura de datos, se le dice que comparador queremos utilizar.
Clases de propósito general : Son las implementaciones de las interfaces de la JFC.
HashSet : Interfaz Set implementada mediante una hash table.
Nota : Una Tabla Hash es un tipo de colección formado por pares de clave y valor, que se almacenan dentro de una tabla. La clave se utiliza para obtener el índice de ubicación del valor dentro de la tabla, utilizando para ello una función denominada función hash. Así pues, una estructura hash está formada por tres elementos básicos:
una tabla o array de tamaño N donde se almacenan los elementos.
una función hash que, dada una clave, nos da el índice de la tabla donde se encuentra almacenado el dato asociado a esa clave.
una función de resolución de colisiones, que determina qué hacer cuando para dos claves distintas se obtiene el mismo índice en la tabla.
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. TreeMap : Interfaz SortedMap implementada mediante un árbol binario
6.2 Clases envoltura
Los tipos primitivos tienen una representación como objetos mediante las clases envoltura que facilitan su uso en los métodos que necesitan un tipo Object y permiten ubicar de forma adecuada constantes y métodos de utilidad en el manejo de los tipos primitivos.
Jerarquia de las clases envoltura para tipos primitivos:
Æ Métodos miembro más representativos:
- Método para devolver el valor envuelto:
public tipo tipoValue():
char c=cEnvoltura.charValue(); boolean b=bEnvoltura.booleanValue(); int i=dEnvoltura.intValue(); double d=iEnvoltura.doubleValue();
Las clases envoltura numéricas tienen la posibilidad de devolver su valor como cualquier tipo numérico: byte, short, int, long, double y float.
Redefine el método toString de Object para obtener una cadena de texto con la representación del valor contenido.
System.out.println(cEnvoltura.toString()); System.out.println(bEnvoltura.toString()); System.out.println(iEnvoltura.toString()); System.out.println(dEnvoltura.toString());
- public int compareTo(TipoEnvoltura E); public int compareTo(Object o);
Compara los valores de los objetos envoltura. Devuelve un valor mayor, igual o menor a cero en el caso de que nuestro objeto sea mayor, igual o menor que el otro objeto, respectivamente. En el segundo caso, si el objeto con el cual comparamos no es de la clase Envoltura del objeto que invoca, se eleva la excepción ClassCastException. No se aplica a Boolean.
- public boolean equals(Object obj)
Devuelve true cuando los objetos son del mismo tipo y envuelven el mismo valor. Double dEnvoltura=new Double("89.8"); Double dEnvoltura2=new Double("54");
System.out.println(dEnvoltura.equals(dEnvoltura2)); Æ false
Las clases envoltura no tiene CLONE();
6.2 Interfaz Collection.
La interfaz Collection es implementada por los conjuntos ( sets ) y las listas ( lists ). Esta interfaz declara una serie de métodos generales utilizables con Sets y Lists.
Para los ejemplos vamos a utilizar dicho interfaz con la clase HashSet. Esta clase representa a un conjunto de objetos no repetidos, en el cual no hay ningún orden establecido. Esta clase tiene los siguientes tres constructores:
HashSet () Constructs a new, empty set; the backing HashMap instance has default initial capacity (16) and load factor (0.75).
HashSet (Collection c) Constructs a new set containing the elements in the specified collection.
HashSet (int initialCapacity) Constructs a new, empty set; the backing HashMap instance has the specified initial capacity and default load factor, which is 0.75.
HashSet (int initialCapacity,float loadFactor) Constructs a new, empty set; the backing HashMap instance has the specified initial capacity and the specified load factor.
Vamos a crear nuestro conjunto de elementos para utilizar en los ejemplos:
Collection co = new HashSet(); Boolean bEnvoltura=new Boolean("TrUe"); Character cEnvoltura=new Character('a'); Integer iEnvoltura=new Integer("5"); Double dEnvoltura=new Double("89.8"); Double dEnvoltura2=dEnvoltura;
public interfaz java.util.Collection { public abstract boolean add(Object); // opcional public abstract boolean addAll(java.util.Collection); // opcional public abstract void clear(); // opcional public abstract boolean contains(Object); public abstract boolean containsAll(java.util.Collection); public abstract boolean equals(Object); public abstract int hashCode(); public abstract boolean isEmpty(); public abstract java.util.Iterator iterator(); public abstract boolean remove(Object); // opcional public abstract boolean removeAll(java.util.Collection); // opcional public abstract boolean retainAll(java.util.Collection); // opcional
Métodos para recorrer todos los elementos o Iterator iterator (). Devuelve una referencia Iterator que permite recorrer una colección con los métodos next() y hasNext(). Permite también borrar el elemento actual con remove().
Iterator it=co.iterator();
Más adelante estudiaremos el interfaz ITERATOR.
Métodos para realizar varias operaciones simultáneamente
o boolean containsAll (Collection collection). Igual que contains() , pero con un conjunto de elementos.
Collection nuevo=new HashSet();
- caso1:
Caramelo sugus=new Caramelo(); nuevo.add(sugus); System.out.println(co.containsAll(nuevo)); Æ false
- caso2:
Collection nuevo= new HashSet(co); System.out.println(co.containsAll(nuevo)); Æ true
- caso3:
Collection nuevo=new TreeSet(); System.out.println(co.containsAll(nuevo)); Æ false
En este último caso no da ningún tipo de error.
o boolean addAll (Collection collection). Igual a add() , pero añade un conjunto de datos si es posible.
Collection nuevo=new HashSet(); Caramelo sugus=new Caramelo(); nuevo.add(sugus); co.addAll(nuevo);
System.out.println(co.size()); Æ 5
Collection nuevo=new HashSet(); Caramelo sugus=new Caramelo(); nuevo.add(sugus); nuevo.add(sugus); co.addAll(nuevo);
ERROR: debido a que la coleccion TREESET tiene dos objetos repetidos que no pueden formar parte del mismo conjunto.
o void clear (). Elimina todos los elementos. o void removeAll (Collection collection). Igual que remove() , pero elimina el conjunto de elementos que se pasa como parámetro. o void retainAll (Collection collection). Elimina todos los elementos menos los especificados por la colección pasada como parámetro.
Otros Métodos
o boolean equals (Object). Implementa la igualdad o equivalencia. Retorna true si el objeto que llama al método es equivalente al que se pasa como parámetro: son los dos un conjunto, tienen el mismo tamaño y contienen los mismos elementos.
o int hashCode (). A la hora de acceder, añadir, o eliminar un objeto contenido en un hashtable, la implementación de dicha estructura invocará este método sobre el objeto para obtener un int que pueda ser utilizado en la elaboración del indice en el hashtable. Durante la ejecución de un programa este método 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 implementación no es requerida, el método devuelve la dirección física del objeto en memoria.
o Object toArray (). Permiten convertir una colección en un array.
Object [] array= co.toArray();
6.3 Interfaz Comparable y Comparator.
Æ 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 método compareTo() de la siguiente forma:
public int compareTo(Object obj)
que compara su argumento implícito con el que se le pasa por ventana. Este método devuelve un entero negativo , cero o positivo según el argumento implícito ( this ) sea anterior , igual o posterior al objeto obj.
Las estructuras cuyos objetos tengan implementado el interfaz Comparable podrán ejecutar ciertos métodos basados en el orden tales como: sort o binarySearch.
Si queremos programar el método compareTo debemos hacerlo con cuidado: ha de ser coherente con el método equals y ha de cumplir la propiedad transitiva.
¿Cómo se crea un comparador?
import java.util.Comparator;
public class ComparaCaramelo implements Comparator {
public int compare(Object arg0, Object arg1) {
Caramelo c1=(Caramelo)arg0; Caramelo c2=(Caramelo)arg1;
return (c1.duracion/c1.velConsumo-c2.duracion/c2.velConsumo); }
}
import java.util.*;
public class Prueba {
public static void main(String[] args) {
ComparaCaramelo comparator=new ComparaCaramelo(); Collection c= new TreeSet(comparator);
Caramelo c1=new Caramelo("rojo","fresa",true,100,5); Caramelo c2=new Caramelo("verde","menta",true,120,8);
c.add(c1); c.add(c2);
Iterator it=c.iterator(); while (it.hasNext()) { System.out.println((Caramelo)it.next()); }
} }
Color: verde Sabor: menta Tiene azucar: true Esta acabado?: false Color: rojo Sabor: fresa Tiene azucar: true Esta acabado?: false
¿Cuándo usar cada uno?
En una colección de objetos, éstos pueden ser ordenados por diferentes criterios. Dependiendo de la clase que realiza la comparación, se implementará la interfaz Comparator o Comparable.
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 (C 1 … Cn) que extiendan el interfaz Comparator por cada ordenación nueva que necesitemos distinta a la natural para la clase C. Así tendremos una “librería de comparadores” (C 1 … Cn) para la clase C.
6.4 Interfaz Iterator.
Los iteradores permiten recorrer colecciones. Disponen de un conjunto de métodos que permiten avanzar sobre la colección y obtener los objetos de ésta durante un recorrido para su tratamiento. Existen dos interfaces declarados en el JCF, que son java.util.Iterator (dispone de métodos para recorrer una colección y para borrar elementos) y java.util.ListIterator (permite recorrer una lista en ambos sentidos) siendo el segundo descendiente del primero. Veamos con más detalle cada uno de ellos.
Æ Interfaz Iterator.
public interfaz java.util.Iterator { public abstract boolean hasNext(); public abstract Object next(); public abstract void remove(); }
hasNext () devuelve un cierto si el elemento actual tiene siguiente en la colección, es decir, mientras existan elementos no tratados mediante el método next.
next () devuelve una referencia al siguiente elemento en la colección, es decir, coloca el iterador en el elemento siguiente y lo devuelve (Object). Es el método utilizado para acceder a los elementos de una colección. Lanza
public abstract void add(Object); public abstract boolean hasNext(); public abstract boolean hasPrevious(); public abstract Object next(); public abstract int nextIndex(); public abstract Object previous(); public abstract int previousIndex(); public abstract void remove(); public abstract void set(Object); }
Caramelo c1=new Caramelo("rojo","fresa",true,100,5); Caramelo c2=new Caramelo("verde","menta",true,120,8); Caramelo c3=new Caramelo("amarillo","limón",true,134,2);
List l = new ArrayList(); l.add(c1); l.add(c2); l.add(c3);
Como vemos, además de los métodos del interfaz padre Iterator , el interfaz ListIterator implementa otros. La descripción de todos ellos es:
hasNext () devuelve un cierto si el elemento actual tiene siguiente en la colección, es decir, devuelve verdadero mientras existan elementos no tratados mediante el método next ().
next() devuelve el siguiente elemento y aumenta en una unidad el índice. La primera vez que se invoca sobre el objeto retornado por el método 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 tamaño de la lista lanzaría la excepción NoSuchElementException. También lanza la excepción NoSuchElementException si la iteración ha alcanzado el final de la lista.
Ejemplo de recorrido normal:
ListIterator li2=l.listIterator();
while (li2.hasNext()){ System.out.println("Indice:" + li2.nextIndex()); Caramelo aux=(Caramelo)li2.next(); System.out.println("Caramelo: "+aux.color);
}
Indice: Caramelo: rojo Indice: Caramelo: verde
Indice: Caramelo: amarillo
hasPrevious () devuelve un cierto si el elemento actual tiene anterior en la colección.
previous() devuelve el elemento situado inmediatamente antes de la posición actual del puntero y resta uno a su valor. Cuando es invocado sobre el objeto devuelto por ListIterator() lanza NoSuchElementException. Si se llama sobre el objeto devuelto por ListIterator( int ) devuelve el objeto situado en el indice int-1. Lanza NoSuchElementException si la iteración ha alcanzado el principio de la lista.
Ejemplo recorrido inverso:
ListIterator li=l.listIterator(l.size());
while (li.hasPrevious()){ System.out.println("Indice:" + li.previousIndex()); Caramelo aux=(Caramelo)li.previous(); System.out.println("Caramelo: "+aux.color);
}
Indice: Caramelo: amarillo Indice: Caramelo: verde Indice: Caramelo: rojo
nextIndex() devuelve el índice del elemento que sería retornado por la próxima llamada a next(). Si el puntero se encuentra al final de la colección devuelve su tamaño.
previousIndex() devuelve el índice del elemento que sería retornado por la próxima llamada a previous() , es decir la posición 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(). Sólo puede ser llamado una vez por cada llamada a next() o previous() , y sólo si no se invocó add() después. Los índices de los elementos posteriores son decrementados en uno. Lanza las siguientes excepciones:
o UnsupportedOperationException. Si la implementación de este interfaz no incorporó este método. o IllegalStateException. Si next o previous no fueron llamados, o bien se invocó add o remove tras la última llamada a next() o previous().
- Modificar el primer elemento de la lista:
ListIterator lie1=l.listIterator(); if (lie1.hasNext()) { lie1.next(); lie1.set(nuevo); }
- Modificar el segundo elemento de la lista:
ListIterator lie2=l.listIterator(2); if (lie2.hasNext()) { lie2.next(); lie2.set(nuevo); }
- Modificar el último elemento de la lista:
ListIterator lie3=l.listIterator(l.size()); if (lie3.hasNext()) { lie3.next(); lie3.set(nuevo); }
6.5 Utilidades de Colecciones.
Æ java.util.Collections
Ordenación: sort(List) y sort(List, Comparator)
public static void sort(List l); public static void sort(List l, Comparator c);
Ordenan la lista, bien de forma ascendente según el orden natural (establecido por el interfaz Comparable ), o bien de la forma especificada por Comparator. Tal ordenación es estable, es decir, los elementos iguales no son desplazados. Lanzan las siguiente excepciones:
• ClassCastException. Si la lista contiene elementos que no son mutuamente
comparables.
- UnsupportedOperationException. Si la lista no es modificable (su iterator no soporta la operación set ).
Inversión del Orden: reverse(List) y reverseOrder()
public static void reverse(List l); public static Comparator reverseOrder();
El métodos reverse(List) invierte en la lista la posición actual de sus elementos (independiente del valor de los elementos). No realiza una ordenación descendente.
El método reverseOrder() devuelve un Comparator que introduce una ordenación inversa a la impuesta por el orden natural de una colección de objetos que implementan el interfaz Comparable. El Comparator devuelto implementa el método compare() de forma que devuelve negado el resultado de compareTo() pasándole sus dos argumentos. Puede utilizarse donde se espere un Comparator , por ejemplo “ Arrays.sort(list, Collections.reverseOrder()) ”.
Ejemplo
List list = ...; Comparator comp = Collections.reverseOrder(); Collections.sort(list, comp)
Búsqueda: binarySearch(List, Object) y binarySearch(List, Object, Comparator)
public static int binarySearch(List l, Object o); public static int binarySearch(List l, Object o, Comparator c);
Buscan el objeto en la lista y devuelven la posición ( int ) de tal objeto. Dicha lista debe estar ordenada de forma ascendente. Esto puede lograrse con un orden natural para el primer método, como por ejemplo sort(List) ; o bien usando un Comparator para el segundo método: sort(List,Comparator). Los resultados no son especificados si la lista esta desordenada. No se asegura cual será el elemento devuelto si existen duplicados.
Devuelven la posición del elemento en la lista (resultado 0 o positivo). Si no está en la lista devuelve ( -(pos_mayor)-1 ); donde pos_mayor es la posición del primer elemento en la lista mayor que el buscado, o el tamaño de la lista si el elemento buscado es el mayor de todos.
Lanzan la excepción ClassCastException si algún elemento en la lista tiene un tipo que impide su comparación con el resto los interfaces Comparable o Comparator. El argumento Object también ha de implementar uno de estos interfaces y por lo tanto también puede lanzarlo.
Sobre el sentido de la ordenación impuesto por sort y el sentido en que esta ordenada la lista o matriz que binarySearch examina, la API especifica que en estos dos métodos, tanto en la clase Arrays como en la
Existen tres constantes (campos estáticos finales) de tipo List , Map y Set que son inicializados para contener un objeto vacío del tipo correspondiente. Sus nombres son EMPTY_LIST, EMPTY_MAP y EMPTY_SET. Sirven para representar contenedores vacíos.
6.6 Interfaz LIST.
Æ Introducción.
Podemos definir una lista como un conjunto de elementos los cuales ocupan una determinada posición de tal forma que cada elemento tendrá un único sucesor y un único antecesor, menos el primero y el último.
p.e: la cola del cine, o del autobús.
El tamaño de estas estructuras es dinámico y va cambiando a lo largo del programa: se añaden elementos al final de la lista, se insertan en una determinada posición, se eliminan elementos, etc..
Las operaciones generales que se llevan a cabo en las listas son las siguientes:
Insertar, eliminar o localizar un elemento. Determinar su tamaño : número de sus elementos. Recorrer la lista en ambos sentidos : para localizar un elemento. Clasificar sus elementos : en orden ascendente o descendente. Unir: dos o más listas en una sola. Dividir : una lista en varias sublistas. Copiar, la lista. Borrar, la lista.
Para utilizar una estructura de este tipo Java dispone de un interfaz llamado LIST , que deriva de COLLECTION. Este interfaz está ya implementado en Java de distintas formas. Escogeremos la que más se adecue a nuestras necesidades, a saber:
Como array de elementos:
o Acceso directo a los elementos. o Necesidad de desplazamiento de información en borrado e inserción. o Problemas de tamaño de las listas. Como array de elementos y array de índices (enlaces) :
o Problemas de acceso directo. o No hay necesidad de desplazamiento en inserción y borrado. o Problema de tamaño de las listas. Como lista (dinámica) de nodos enlazados :
o Problemas de acceso directo. o No hay necesidad de desplazamiento en inserción y borrado.
o No hay problemas de tamaño de las listas.
Æ Interfaz LIST
Sabido es que dos clases que implementan la misma interfaz se pueden utilizar de similar forma. Las clases ArrayList y LinkedList disponen de casi los mismos métodos y ambas implementan a nuestra interfaz. Pero mientras que ArrayList almacena los objetos en una tabla, la clase LinkedList los almacena en una lista enlazada. La primera será más eficiente para acceder a un elemento arbitrario, mientras que la segunda lo será para borrar e insertar elementos.
Hay que observar que los elementos que van a contener nuestras listas han de ser objetos, por tanto pueden ser String, pero no los tipos básicos (int, float,..). Por ello para usar una lista de enteros, por ejemplo, hay que usar las clases envoltorio (wrappers) o construir una.
a ) Clase ArrayList
public class ArrayList extiende AbstractList e implementa List, Cloneable.
Implementa todas las operaciones opcionales de las listas, y permite todos los elementos, incluido null. Además de la implementación de List, proporciona métodos para manipular el tamaño de la tabla que se usa internamente como almacenamiento de la lista.
Cada instancia de ArrayList tiene una capacidad. Dicha capacidad es el tamaño de la tabla que se usa para almacenar los elementos en la lista. Es siempre, al menos tan grande, como el tamaño de la lista. Al añadir elementos a la tabla, su capacidad crece automáticamente.
Constructores
ArrayList() Construye una lista vacía.
ArrayList(collection c) Construye una lista que contiene los elementos de la colección, en el orden en que son devueltos por el iterator de la colección.
ArrayList(int capacidadInicial) Construye una lista vacía con la capacidad inicial dada.
Métodos mas usuales
o boolean add(Object o)****. Añade un elemento al final de la lista. (LinkedList).
