U9 API Collections y Generics

Transcripción

1 U9 API Collections y Generics En esta unidad vamos a estudiar las múltiples maneras que ofrece el lenguaje Java para tratar con conjuntos de elementos, colecciones o listados. Veremos cuando es conveniente utilizar cada uno, y como obtener valores de estos conjuntos. Al finalizar el estudio de estas lecciones serás capaz de: Conocer las implementaciones de Collections. Utilizar la interfaz Map. Manejar las colecciones tradicionales. Utilizar el Comparable y Comparator para ordenar resultados. Refactorizar código no genérico. Examinar el bucle loop mejorado. Escribir un programa que permita la iteración de un listado. 1

2 L1 Implementaciones del interface Collections El propio lenguaje Java proporciona un conjunto de clases e interfaces que nos facilitan el uso de colecciones de datos. La clase más general es el Interface collections que mediante el uso del polimorfismo nos proporciona multitud de implementaciones diferentes. Estas clases se encuentran dentro del paquete java.util y recientemente se puede hacer uso genérico de ellas. El uso de Collections nos proporciona ciertas ventajas frente al uso tradicional de Arrays: Cambiar el tamaño dinámicamente Permite ordenación Permite la inserción y eliminación de datos Qué es el uso genérico? Este término en java es bastante reciente (desde la versión 1.5, actualmente 1.6) Antes cuando introducíamos objetos en una colección independientemente de que tipo fueran se almacenaban en la colección como Object. Al recuperarlo debíamos realizar un casting al tipo de objeto que era antes de entrar en la colección. Actualmente se permite el uso de Colecciones Tipadas o generics en las que podemos especificar qué tipo de objeto compondrá la colección. Esta característica le permite al compilador lanzar un error en tiempo de compilación si intentamos introducir un objeto de un tipo incompatible, evitando errores en la ejecución del programa. Recuerde El interfaz Collections y sus implementaciones genéricas permitirán tratar conjuntos de elementos siempre del mismo tipo. 2

3 Un esquema general del interface Collections es: Interface Collection Es la interface más básica o genérica de la que todos implementan. Las características de Collection en Java son: Lo elementos que componen la colección se pueden iterar o recorrer Se puede conocer el tamaño de la colección El resto de colecciones irán añadiendo más características a estas definidas. Recuerde Dado que Collection es un interface no podremos crear objetos de este tipo, sino que todas las colecciones de una clase tienen las operaciones que ofrece el interface Collection. 3

4 Las operaciones principales que ofrece este interface son: add(objeto) Añade un elemento. iterator() Permite recorrer los elementos de uno en no obteniendo sus propiedades size() Muestra la cantidad de elementos de la colección. contains(objeto) Obtiene si un elemento está ya dentro de la colección. Interface List Este interface es una implementación de Collection por lo que además de sus propias características añade: El orden de los elementos es arbitrario Permite acceder a los elementos por orden. Los métodos que añade son: get(int i) Obtiene el elemento en la posición determinada. set(int i, Object t) Coloca el objeto en una posición determinada. Interface Set El interface set, tiene las mismas características que Collections pero añade la restricción de que no pueden aparecer elementos duplicados. 4

5 Interface Queue Este interface está creado para utilizar las características de las colas de datos. Las colas siguen el patrón FIFO ( First In - First Out - lo que entra primero, sale primero ). La característica principal de este interface es que mantiene el orden de acuerdo con el orden de inserción FIFO. 5

6 L2 Analizar la interfaz Map La interface Map es un diccionario de valores definidos por clave-valor. Las principales características son: La clave debe ser única El valor es el objeto de un tipo de nuestra colección. A cada valor debemos acceder a través de su clave. Un Map no implementa de Collection dado que es bidimensional al incluir la estructura Clave-Valor Los principales métodos para tratar este interface Map son: get(object valorclave) Obtiene el objeto asociado a una clave. put(clave clave, Valor valor) Añade un par clave-valor al map keyset() Devuelve todas las claves del Map values() Devuelve todos los valores entryset() Devuelve todos los pares clave-valor La estructura del interface Map es: 6

7 Nota Un Map admite valores duplicados pero no claves duplicadas. HashMap Es el Map más sencillo y más usado. Permite asociar pares de claves y valores sin orden. No admite claves duplicadas, pero si utilizar null como clave. Un ejemplo en código Java de la declaración e inserción de valores es: import java.util.hashmap; public class UsoHashMap { public static void main(string argas[]){ HashMap<Integer,String> hashmap = new HashMap<Integer,String>(); hashmap.put(1,"primer Valor"); hashmap.put(2,"segundo Valor"); hashmap.put(null,"valor Nulo"); Hemos indicado que la clave va a ser un valor de tipo Integer y que admite en la colección valores de tipo String, si intentamos introducir otro tipo de valores el compilador nos avisará del error. 7

8 HashTable Idéntico a HashMap pero no admite el valor null como clave. Un ejemplo en código Java de la declaración e inserción de valores es: import java.util.hashtable; public class UsoHashTable { public static void main(string args[]){ Hashtable<Integer,String> hashtable = new Hashtable<Integer,String>(); hashtable.put(1,"primer Valor"); hashtable.put(2,"segundo Valor"); Si intentamos poner como clave un valor nulo lo mostrara en tiempo de ejecución, es decir, cuando el programa se esté utilizando. Este error el compilador no es capaz de detectarlo y avisarlo mientras se desarrolla. LinkedHashMap Es una clase que extiende HashMap, por lo que posee todas sus funcionalidades. Permite iterar o recorrer los elementos en el orden en el que se introdujeron debido a que utiliza una clase doblemente enlazada. Es más rápido a la hora de recorrer los datos pero más lento al insertarlos. Un ejemplo en código Java de la declaración e inserción de valores es: import java.util.linkedhashmap; public class UsoLinkedHashMap { public static void main(string args[]){ LinkedHashMap<Integer,String> linkedhash = new LinkedHashMap<Integer,String>(); linkedhash.put(1,"primer Valor"); linkedhash.put(2,"segundo Valor"); La inserción de valores es idéntica a HashMap pero cuando queramos iterar estos valores lo hará siempre en el mismo orden que los hemos insertado. 8

9 TreeMap Es una clase que almacena en un árbol ordenado los pares Clave-Valor ordenados por los valores de las claves. Es más lenta tanto para recorrer como para insertar nuevos datos. Un ejemplo en código Java de la declaración e inserción de valores es: import java.util.treemap; public class UsoTreeMap { public static void main(string args[]){ TreeMap<Integer,String> treemap = new TreeMap<Integer,String>(); treemap.put(2,"segundo Valor"); treemap.put(1,"primer Valor"); En este caso a pesar del orden de inserción, al recorrerlos los devolverá ordenados por el campo clave. Nota La manera de insertar valores en las diferentes implementaciones de Map es idéntica lo que hay que pensar es que uso va a tener la colección y utilizar la correspondiente según las características que poseen. 9

10 L3 Examinar las clases colección tradicionales Todas las colecciones en Java provienen de un interface Collection, de este implementaban otros 3 interfaces de los cuales salen todas las clases que permiten almacenar colecciones. SET Un set es una colección que no permite duplicados. Tiene 3 clases con diferente implementación: HashSet Un hashset posee las características principales de las colecciones Set, pero mejora la comprobación de si un objeto ya está contenido en una colección. Automáticamente al añadir un nuevo objeto a una colección se calcula el valor Hash. Este valor es un número entre y que lo almacena el propio lenguaje Java en una tabla en memoria. 10

11 A cada objeto le corresponde un único valor Hash, y dos objetos que sean iguales tendrán ese mismo valor. Así que cuando preguntamos si el objeto ya existe, no debe compararlo entero sino que comparará si el valor Hash producido ya existe. En estas colecciones el orden no se controla. LinkedHashSet Esta clase Hereda de hashset por lo que posee todas sus características, pero añade que los objetos están doblemente enlazados y se mantiene siempre el orden de inserción. Por lo que cuando iteremos siempre se mostrarán los elementos en el mismo orden en el que se insertaron. TreeSet Cuando utilizamos una colección TreeSet, automáticamente se construye un árbol con los objetos que se van agregando al conjunto. Esto permite mantener siempre el orden aunque se añadan nuevos valores. Los objetos que añadamos deben implementar Comparable para saber qué tipo de orden queremos mantener, aunque casi todas las clases propias del lenguaje Java ya lo incoporan (String, Integer).. El principal inconveniente es que debido al orden que debe mantener es menos eficiente que otras implementaciones de SET. Un ejemplo en código Java del uso e inicialización de estas colecciones es: import java.util.hashset; import java.util.linkedhashset; import java.util.treeset; public class UsoSet { public static void main (String args[]){ //Creación de un hashset de Strings HashSet<String> hashset = new HashSet<String>(); hashset.add("valor1"); 11

12 hashset.add("valor2"); hashset.add("valor3"); //Creación de un LinkedHashSet de Integer LinkedHashSet<Integer> linkedhashset = new LinkedHashSet<Integer>(); linkedhashset.add(1); linkedhashset.add(2); linkedhashset.add(3); //Creación de un treeset de Double TreeSet<Double> treeset = new TreeSet<Double>(); treeset.add(122.23); treeset.add(5.23); treeset.add(7.23); LIST Un List es una colección de elementos en los que se permiten duplicados y que mantiene el orden de inserción. 12

13 ArrayList Un ArrayList es una mejora del Array tradicional, ya que crece conforme se añaden elementos mientras que en un array hay que indicar desde la inicialización el tamaño. Ventajas El tiempo de acceso a un elemento es mínimo. Inconvenientes A la hora de eliminar es bastante lento porque una vez localizado el elemento y eliminado mueve una posición todos los elementos posteriores. Por defecto un ArrayList tiene una capacidad para 10 elementos, pero si este rango se completa lo amplia siguiendo la fórmula : (capacidad * 3) / LinkedList Su funcionamiento es idéntico a ArrayList pero con la mejora todos los elementos están unidos en una serie de nodos apuntando al valor anterior y al valor siguiente. Ventajas Eliminaciones muy rápidas ya que solo hay que indicar al elemento anterior y posterior su nueva posición. Inconvenientes Tiene muy poco rendimiento a la hora de recorrer los datos. Vector Su funcionamiento es similar al arraylist pero los datos están sincronizados, es decir, está protegido del acceso por otros hilos. Por defecto su capacidad son 10 elementos, pero al sobrepasar este rango se duplica su capacidad lo que puede hacer que sea más lento frente a un ArrayList. Un ejemplo en código Java es: import java.util.arraylist; import java.util.linkedlist; import java.util.list; import java.util.vector; 13

14 public class UsoList { public static void main (String args[]){ //Creación de un arraylist de Strings List<String> lista = new ArrayList<String>(); lista.add("valor1"); lista.add("valor2"); lista.add("valor3"); //Creación de un Vector de Integer List<Integer> vector = new Vector<Integer>(); vector.add(1); vector.add(2); vector.add(3); //Creación de un LinkedList de Double List<Double> linkedlist = new LinkedList<Double>(); linkedlist.add(122.23); linkedlist.add(5.23); linkedlist.add(7.23); Podemos observar que cuando hemos utilizado las listas en la creación del objeto hemos utilizado el interface genérico (gracias al polimorfismo): List<String> lista = new ArrayList<String>(); Esta forma de declaración es igual de válida que: ArrayList <String> lista = new ArrayList<String>(); Pero con el polimorfismo hace que el cambio de un tipo de lista sea más sencillo. 14

15 QUEUE Son conjuntos de datos FIFO (First in first out), es decir, el primer elemento en introducirse en la cola será el primero que se obtendrá al iterar la colección, y así sucesivamente. LinkedList La implementación es la propia del interface List, lo único que su característica de que mantiene los elementos enlazados con una referencia al anterior y otra al siguiente hace que para manejar conjuntos de datos FIFO sea útil. PriorityQueue Permite establecer prioridades en los elementos de una colección en funcion de una regla de comparación que se haya indicado. Se mantiene dentro de la interface Queue debido a que proporciona métodos muy útiles para mantener colas de elementos. offer() Añade Elementos peek() Devuelve el elemento de mayor prioridad pool() Devuelve el elemento de mayor prioridad y lo elimina de la colección. 15

16 Un ejemplo en código Java es: import java.util.priorityqueue; import java.util.queue; public class UsoQueue { public static void main (String args[]){ Queue<String> listaelementos = new PriorityQueue<String>(); listaelementos.offer("valor1"); listaelementos.offer("valor2"); listaelementos.offer("valor3"); Nota Es necesario conocer todas las ventajas e inconvenientes de las implementaciones de Collection para elegir la más adecuada (penalice menos rendimiento) a las necesidades concretas del programa. 16

17 L4 Orden con Comparable y Comparator Una de las principales características que diferencian los tipos de colecciones es si permiten ordenación. Además hay objetos que tienen predefinido unos métodos de ordenación como puede ser la clase String. En esos casos se puede invocar una característica del interface Collection denominada sort(). Un ejemplo en código Java de esta ordenación sería: import java.util.arraylist; import java.util.collections; import java.util.list; public class ordenacionsimple { public static void main(string[] args) { List<String> lista = new ArrayList<String>(); lista.add("maría"); lista.add("juan"); lista.add("pedro"); //Por defecto viene ordenada tal y como se ha insertado System.out.println("lista original:"+lista); Collections.sort(lista); //Pasa a estár ordenada alfabéticamente System.out.println("lista ordenada:"+lista); Nos hemos declarado una lista de String que por defecto aparecerá ordenada tal y como hemos insertado los elementos. Como la lista es de tipo String, este objeto Java por defecto implementa el interface Comparable que nos permitirá devolverla ordenada alfabéticamente si llamamos al método sort. Este método reordenará la lista en función de la implementación del interface comparable y nos devolverá la lista ordenada: Y si utilizamos nuestros propios objetos? Debemos hacer exactamente lo mismo que hace el lenguaje Java para sus clases propias, implementar el interface Comparable o Comparator en función de las necesidades. 17

18 Comparable Se utiliza si solo vamos a tener un único criterio de ordenación. Un ejemplo en código Java es: 1. Creamos una clase Persona e implementamos el interface Comparable, queremos que nuestra colección aparezca ordenada por apellidos. public class Persona implements Comparable<Persona> { private String nombre; private String apellidos; private int edad; public Persona(String nombre, String apellidos, int edad){ this.nombre= nombre; this.apellidos = apellidos; this.edad = public int compareto(persona o) { return this.apellidos.compareto(o.apellidos); public String getnombre() { return nombre; public void setnombre(string nombre) { this.nombre = nombre; public String getapellidos() { return apellidos; public void setapellidos(string apellidos) { this.apellidos = apellidos; public int getedad() { return edad; public void setedad(int edad) { this.edad = edad; Hemos creado la persona con sus propiedades y su constructor. Hemos implementado el interface Comparable y le indicamos que es de tipo persona. Nos obliga a implementar el método compareto que será el que utilicemos para la ordenación indicando la propiedad deseada. 18

19 2. Una vez definido el criterio podemos utilizar el método sort y nos devolverá la lista ordenada por el criterio definido. import java.util.arraylist; import java.util.collections; import java.util.list; public class UsoComparator { public static void main(string[] args) { List<Persona> lista = new ArrayList<Persona>(); lista.add(new Persona("Pedro", "Martinez",25)); lista.add(new Persona("Ana", "Lopez",12)); lista.add(new Persona("Marta", "Abidal",78)); //Por defecto viene ordenada tal y como se ha insertado System.out.println("Lista sin ordenar:"); for(int i=0;i<lista.size();i++) { System.out.println(lista.get(i).getNombre() + "- " + lista.get(i).getapellidos()); Collections.sort(lista); System.out.println("Lista ordenada por apellido:"); //Pasa a estár ordenada alfabéticamente for(int i=0;i<lista.size();i++) { System.out.println(lista.get(i).getNombre() + "- " + lista.get(i).getapellidos()); Como hemos definido el método comparteto, al llamar a la propiedad Collections.sort devuelve la lista ordenada por el parámetro definido. 19

20 Comparator Se utiliza este interface si queremos definir varios criterios de ordenación para una misma clase fuera de la definición de esta. Se deben crear tantas clases como métodos de ordenación que se deseen e implementar el interface Comparator. 1. Creamos una clase PersonasPorNombre que debe implementar de Comparator import java.util.comparator; public class PersonasPorNombre implements Comparator<Persona> public int compare(persona o1, Persona o2) { El propio compilador nos obliga a implementar el método compare que espera dos objetos del tipo que hayamos indicado en el Comparator. Dado que queremos ordenar por nombre realizamos la comparación por este campo. import java.util.comparator; public class PersonasPorNombre implements Comparator<Persona> public int compare(persona o1, Persona o2) { return o1.getnombre().compareto(o2.getnombre()); 2. Una vez que hemos creado la clase que compara podemos utilizarla en el método sort indicándole que la ordenación debe realizarse bajo ese criterio. import java.util.arraylist; import java.util.collections; import java.util.list; public class UsoComparator { public static void main(string[] args) { List<Persona> lista = new ArrayList<Persona>(); lista.add(new Persona("Pedro", "Martinez",25)); lista.add(new Persona("Ana", "Lopez",12)); lista.add(new Persona("Marta", "Abidal",78)); 20

21 //Por defecto viene ordenada tal y como se ha insertado System.out.println("Lista sin ordenar:"); for(int i=0;i<lista.size();i++) { System.out.println(lista.get(i).getNombre() + "- " + lista.get(i).getapellidos()); Collections.sort(lista); System.out.println("Lista ordenada por apellido:"); //Pasa a estár ordenada alfabéticamente for(int i=0;i<lista.size();i++) { System.out.println(lista.get(i).getNombre() + "- " + lista.get(i).getapellidos()); Collections.sort(lista,new PersonasPorNombre()); System.out.println("Lista ordenada por Nombre:"); //Pasa a estár ordenada alfabéticamente for(int i=0;i<lista.size();i++) { System.out.println(lista.get(i).getNombre() + "- " + lista.get(i).getapellidos()); Hemos llamado al método sort indicándole la lista y la clase donde está indicado el método de ordenación. Collections.sort(nombreListaOrdenar,new ClaseComparator()); El resultado son la lista ordenada de las 3 maneras: Por defecto en el mismo orden de inserción Apellido Orden definido en la propia clase del tipo que es la lista Nombre Clase que implementa un método de ordenación propio. 21

22 Nota Utilizaremos el interface Comparable para definir una ordenación por defecto en una clase, y el interface Comparator para definir otros métodos de ordenación. 22

23 L5 Utilizar colecciones genéricas Una colección en Java es un conjunto de valores que son almacenados como tipo Object. Una colección genérica es un conjunto de valores del mismo tipo y que se almacenan no como Object sino manteniendo el tipo que tenía el objeto antes de insertarse en la colección. Además garantizan que en una misma colección no haya objetos de varios tipos. Nota Las colecciones genéricas se denominan tipadas ya que están delimitadas al uso de un único tipo de objeto. Con estas colecciones se reducen los errores en tiempo de ejecución debido a colecciones con diferentes tipos de objetos. La declaración de una colección genérica es: NbClase<TipoDato> nombrevariable = new NbClase <TipoDato>(): Vamos a realizar un ejemplo en código Java que utilice colecciones genéricas y además muestre alguna de las propiedades que poseen estas colecciones. 1. Creamos la clase ColeccionesGenericas y le añadimos el método main. public class ColeccionesGenericas { public static void main(string[] args) { 2. Añadimos un ArrayList que solo admita datos de tipo String. import java.util.arraylist; import java.util.list; public class ColeccionesGenericas { public static void main(string[] args) { List<String> listagenerica = new ArrayList<String>(); 23

24 3. Añadimos valores llamando al método add de la colección import java.util.arraylist; import java.util.list; public class ColeccionesGenericas { public static void main(string[] args) { List<String> listagenerica = new ArrayList<String>(); listagenerica.add("coche"); listagenerica.add("ciclomotor"); listagenerica.add("camión"); 4. Comprobamos que si intentamos introducir un dato de tipo entero el compilador nos muestra el error 5. Utilizamos métodos propios de Collection que nos devuelven información referente a la colección. import java.util.arraylist; import java.util.list; public class ColeccionesGenericas { public static void main(string[] args) { List<String> listagenerica = new ArrayList<String>(); listagenerica.add("coche"); listagenerica.add("ciclomotor"); listagenerica.add("camión"); System.out.println(" La lista está vacia? " + listagenerica.isempty()); System.out.println(" Que valor hay en la posición 0? " + listagenerica.get(0)); System.out.println(" Que tamaño tiene la lista? " + listagenerica.size()); 24

25 isempty() Método que devuelve verdadero si la lista está vacia get(0) Método que devuelve el valor almacenado en la posición 0 de la lista size() Método que devuelve el tamaño que tiene la lista. Recuerde Cada colección posee gran cantidad de métodos que nos ayudan a desarrollar programas, todos estos se encuentran definidos en la API online de Java. 25

26 L6 Refactorizar código no genérico existente La refactorización es una técnica que sirve para reestructurar una zona de código alterando su estructura interna pero sin modificar el comportamiento externo. Con la refactorización se gana claridad en el código y se permite un mejor entendimiento de este de cara a futuros cambios. Los propios IDEs proporcionan herramientas de refactorización, en nuestro caso que utilizamos Netbeans proporciona las siguientes herramientas de refactorización: Las herramientas más importantes de refactorización son: Cambiar Nombre: Si queremos cambiar el nombre de una clase, también lo hace de todas sus referencias evitando errores. Encapsular Campos: Para generar los métodos get y set de las propiedades sin tener que escribirlas. Introducir Método: Seleccionando un conjunto de código lo convierte a un método e incluye la llamada a este para no perder funcionalidad. 26

27 L7 Escribir un programa para iterar una colección Una vez que sabemos cómo añadir elementos a una colección vamos a aprender como iterarla, para recuperar sus valores. Para iterar una colección se puede utilizar cualquiera de las estructuras de iteración que proporciona el lenguaje Java. Un ejemplo en código Java es: import java.util.arraylist; import java.util.list; public class IteracionSimple { public static void main(string[] args) { //Inicializamos la lista List<Persona> listapersonas= new ArrayList<Persona>(); listapersonas.add(new Persona("Pedro", "Martinez",25)); listapersonas.add(new Persona("Ana", "Lopez",12)); listapersonas.add(new Persona("Marta", "Abidal",78)); listapersonas.add(new Persona("Sonia", "Garcia",23)); //Iteramos la lista for (int i=0; i<=listapersonas.size() -1; i++){ System.out.println("La Datos de la persona son:" + listapersonas.get(i).getnombre() + " " + listapersonas.get(i).getapellidos() + " " + listapersonas.get(i).getedad()); Hemos utilizado un bucle for para recorrer la lista. Para saber el final de la iteración hemos invocado el método size() que nos devuelve el tamaño de la lista. Debemos tener especial cuidado al delimitar el inicio y el fin de la lista, ya que la primera posición es 0, y el método size nos devuelve el tamaño real (En este caso 4). Si no restásemos al método size una unidad provocaríamos un acceso ilegal en memoria intentando acceder a una posición inexistente. El resultado de la ejecución del programa será: 27

28 L8 Examinar el bucle loop mejorado A partir de la versión 5 de java introdujeron un bucle que mejoraba el acceso a colecciones llamada For-Each Esta estructura de iteración proporciona la gran ventaja de que no hay que trabajar con índices por lo que se evitan las excepciones de acceso ilegal a memoria. Su sintaxis en código Java es: for(tipodato nombrevariable : Coleccion){ El mismo ejemplo que el anterior pero utilizando este nuevo bucle es: import java.util.arraylist; import java.util.list; public class Iteracion { public static void main(string[] args) { //Inicializamos la lista List<Persona> listapersonas= new ArrayList<Persona>(); listapersonas.add(new Persona("Pedro", "Martinez",25)); listapersonas.add(new Persona("Ana", "Lopez",12)); listapersonas.add(new Persona("Marta", "Abidal",78)); listapersonas.add(new Persona("Sonia", "Garcia",23)); //Iteramos la lista for (Persona persona: listapersonas){ System.out.println("La Datos de la persona son:" + persona.getnombre() + " " + persona.getapellidos() + " " + persona.getedad()); En la primera parte hemos inicializado y añadido valores a la lista. Para iterarla utilizamos un bucle for each, en la en cada iteración se almacena el valor que tiene el objeto en la variable que hemos declarado interna al bucle persona, de esta manera se puede acceder a todos sus métodos y propiedades. El resultado de la ejecución muestra por consola los datos de la lista. 28

29 Recuerde Para iterar una colección se puede realizar mediante cualquier iterador de Java, aunque el más reciente For Each es el que proporciona más facilidades. 29