PRÁCTICAS 15 Y 16: FACTORÍAS E ITERABLES Versión: 1.0.0

Transcripción

1 OBJETIVOS FUNDAMENTOS DE PROGRAMACIÓN Curso: 2010/11 PRÁCTICAS 15 Y 16: FACTORÍAS E ITERABLES Versión: Crear factorías para las listas y los conjuntos de Java. Conocer las diferencias que existen entre las distintas implementaciones de List y Set realizando un test de rendimiento. Crear iterables de tipos simples y tipos complejos Tener una primera toma de contacto con los archivos en Java. CONTENIDO EJERCICIO 1: Factoría de listas... 2 EJERCICIO 2: Análisis de rendimiento de listas... 3 EJERCICIO 3: Factoría de conjuntos (para hacer en casa)... 4 EJERCICIO 4: Análisis de rendimiento de conjuntos (para hacer en casa)... 5 EJERCICIO 5: Ejemplo práctico de Factoría... 5 EJERCICIO 6: Testear todas las implementaciones posibles (para hacer en casa)... 6 EJERCICIO 7: Secuencia aritmética creciente y decreciente... 6 EJERCICIO 8: Secuencia de números primos (para hacer en casa)... 7 EJERCICIO 9: Secuencia de Captchas... 8 EJERCICIO 10: Clase de utilidad Iterables PREPARACIÓN DE LA PRÁCTICA Importe el proyecto Practicas1516Alumno que se proporciona junto a este enunciado. Dicho proyecto contiene el código necesario para realizar ambas prácticas.

2 Prácticas 15 y 16: Factorías e Iterables 2 EJERCICIO 1: Factoría de listas Cree el siguiente tipo enumerado en el paquete types: class types «enumeration» ListType ARRAY_LIST LINKED_LIST VECTOR_LIST A continuación vamos a crear en el paquete utils una factoría de objetos del tipo List a la que llamaremos Lists. Como sabemos, en Java, el interface List tiene distintas clases que lo implementan: haciendo uso de arrays (clase ArrayList), utilizando vectores (clase Vector) o haciendo uso de listas enlazadas (clase LinkedList). Con el enumerado ListType vamos a controlar qué implementación vamos a usar para crear los objetos de nuestra factoría. Además, vamos a sobrecargar la factoría para que también se puedan crear listas con elementos que provengan de distintas fuentes como puedes ser otras colecciones o arrays. Resuelva los siguientes ejercicios: a) Cree un método estático create() que tome como parámetro una variable de tipo ListType y vuelva un objeto de tipo List implementado con ArrayList, LinkedList o Vector. Utilice una sentencia switch-case. b) Cree otro método estático create() que tome como parámetros, además del tipo de la lista, una colección con los objetos que se quieren insertar en la lista cuando ésta se crea. Tenga en cuenta que los objetos de la colección pueden ser de cualquier tipo. c) Otro método estático create() que tome como parámetros, además del tipo de la lista, un array con los objetos que se quieren insertar en la lista cuando ésta se crea. Tenga en cuenta que los objetos del array pueden ser de cualquier tipo. d) Utilice la clase ListsTest que se proporciona para comprobar que ha realizado bien el ejercicio. La salida que debe obtener es la siguiente: l1(array): [1, 2] l2(linked): [1, 2] l3(vector): [5, 6] l1 == l2: true l2 == l3: false l1+l2+l3: [1, 2, 1, 2, 5, 6]

3 Prácticas 15 y 16: Factorías e Iterables 3 EJERCICIO 2: Análisis de rendimiento de listas Como hemos visto en clase, las factorías son un patrón creacional que se suele usar para crear objetos de un tipo definido a través de su interface que tiene más de una implementación. Ahora bien, por qué existen distintas implementaciones de un mismo tipo? Esta pregunta tiene dos posibles respuestas no excluyentes: a) Porque las distintas implementaciones añaden algún aspecto extra al tipo de dato. Este es el caso de tipo Racional visto en clase, que tiene una implementación RacionalImpl en la que no se simplifica el número racional y otra implementación (RacionalImpl2) que sí simplifica. b) Porque las implementaciones tienen un comportamiento en cuanto a tiempo de ejecución y/o consumo de memoria distinto. Este es el caso, por ejemplo, de las implementaciones de los tipos List y Set. En este ejercicio vamos a realizar un test para ver cómo se comportan las distintas implementaciones del tipo List cuando se añaden, se buscan, se eliminan o simplemente se accede a sus elementos. Para ello lleve a cabo los siguientes pasos: a) En la clase PerformanceListsTest cree las siguiente constantes: private static final int NUM_INSERTS = ; private static final int NUM_SEARCHES = 5000; private static final int NUM_DELETES = 5000; private static final int NUM_ACCESSES = 5000; private static final int MAX_VALUE = ; b) Usando la factoría cree tres listas llamadas arraylist, vector y linkedlist. c) Termine de implementar el método inserttest(l) para que ejecute un bucle que inserte en la lista l tantos números enteros aleatorios entre 0 y MAX_VALUE como indique la constante NUM_INSERTS. Para generar un número entero aleatorio entre 0 y MAX_VALUE utilice el siguiente código. Random r = new Random(); //Crea un objeto de la clase Random Integer x = r.nextint(max_value); //Asigna a x un valor aleatorio Mida el tiempo que tarda en ejecutarse dicho bucle y muéstrelo por pantalla. Para ello utilice el siguiente patrón de código: long tbefore, tafter; tbefore = System.currentTimeMillis(); for ( ) { //hacemos aquí lo que queramos medir } tafter = System.currentTimeMillis(); show("tiempo de ejecución: " + (tafter - tbefore) + " milisegundos"); d) Termine de implementar el método searchtest(list<integer> l) para que muestre el tiempo que tarda en ejecutarse un bucle en el que se buscan (con el método contains()) tantos elementos como indique la constante NUM_SEARCHES. e) Termine de implementar el método accesstest(list<integer> l) para que muestre el tiempo que tarda en ejecutarse un bucle en el que se acceden (con el

4 Prácticas 15 y 16: Factorías e Iterables 4 método get()) a tantos elementos aleatorios entre 0 y NUM_INSERTS como indique la constante NUM_ACCESSES. f) Termine de implementar el método deletetest(list<integer> l) para que muestre el tiempo que tarda en ejecutarse un bucle en el que se eliminan (con el método remove()) los NUM_DELETES primeros elementos de la lista. Una vez que ejecute el test debe obtener una salida parecida a esta: TEST DE INSERCIÓN============================= Vamos a insertar elementos... java.util.arraylist: 170 milisegundos java.util.vector: 237 milisegundos java.util.linkedlist: 266 milisegundos TEST DE BÚSQUEDA============================== Vamos a buscar 5000 elementos... java.util.arraylist: 4021 milisegundos java.util.vector: 4154 milisegundos java.util.linkedlist: 8274 milisegundos TEST DE ACCESO================================ Vamos a acceder a 5000 elementos... java.util.arraylist: 2 milisegundos java.util.vector: 1 milisegundos java.util.linkedlist: milisegundos TEST DE BORRADO=============================== Vamos a borrar 5000 elementos... java.util.arraylist: 3631 milisegundos java.util.vector: 3678 milisegundos java.util.linkedlist: 57 milisegundos Aunque no se trata de un experimento realizado con rigor estadístico, sí que podemos adelantar algunas conclusiones: La implementación más rápida a la hora de insertar elementos es ArrayList, la más lenta es LinkedList. Las implementaciones ArrayLitst/Vector emplean un tiempo parecido en realizar una búsqueda. LinkedList emplea casi el doble de tiempo. El tiempo de acceso a un elemento concreto de una lista es mucho mejor en las implementaciones ArrayList/Vector que en LinkedList. El tiempo de borrado de un elemento de una lista es mucho mejor en un LinkedList que en ArrayList/Vector. EJERCICIO 3: Factoría de conjuntos (para hacer en casa) Siguiendo la misma filosofía cree una factoría de conjuntos para desacoplar el interface Set de las distintas clases que lo implementan (HashSet, LinkedHashSet, TreeSet). Cuando ejecute SetsTest debe obtener una salida como esta: s1(hash): [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] s2(linked): [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] s3(tree): [5, 6, 8, 9, 10] s1 == s2: true s2 == s3: false s1+s2+s3: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

5 Prácticas 15 y 16: Factorías e Iterables 5 EJERCICIO 4: Análisis de rendimiento de conjuntos (para hacer en casa) Realice también un test de rendimiento como en el ejercicio anterior añadiendo un test para las operaciones containsall() y retainsall() para comprobar cómo funcionan las distintas implementaciones y saque sus propias conclusiones. La salida del test debe tener el siguiente aspecto: TEST DE INSERCIÓN============================= Vamos a insertar elementos... java.util.hashset: 1432 milisegundos java.util.linkedhashset: 1616 milisegundos java.util.treeset: 3629 milisegundos TEST DE BÚSQUEDA============================== Vamos a buscar elementos... java.util.hashset: 1279 milisegundos java.util.linkedhashset: 1448 milisegundos java.util.treeset: 3501 milisegundos TEST DE BORRADO=============================== Vamos a borrar elementos... java.util.hashset: 412 milisegundos java.util.linkedhashset: 469 milisegundos java.util.treeset: 189 milisegundos TEST DE RETAINS============================== Vamos a hacer 1000 retains de dos conjuntos de elementos... java.util.hashset: 6633 milisegundos java.util.linkedhashset: milisegundos java.util.treeset: milisegundos TEST DE CONTAINS============================== Vamos a hacer 1000 contains de dos conjuntos de elementos... java.util.hashset: 6769 milisegundos java.util.linkedhashset: milisegundos java.util.treeset: milisegundos EJERCICIO 5: Ejemplo práctico de Factoría En este ejercicio se presenta una de las utilidades que tienen las factorías de objetos. En el siguiente test se definen las contantes MY_LIST y MY_SET que son de tipo ListType y SetType respectivamente. Estas constantes puede ser usadas a la hora de crear lo objetos de tipo lista y conjunto que se usaran en el programa. De forma que para cambiar la implementación de las mismas bastaría con cambiar el valor de esta constante: // Sólo tengo que cambiar esta constante para cambiar las implementaciones private static final ListType MY_LIST = ListType.LINKED_LIST; private static final SetType MY_SET = SetType.LINKED_HASHSET; private static long tbefore, tafter; public static void main(string[] args) { } List<Integer> l = Lists.create(MY_LIST); Set<Integer> s = Sets.create(MY_SET); tbefore = System.currentTimeMillis(); doanything(l,s); tafter = System.currentTimeMillis(); show("tiempo de ejecución:" + (tafter - tbefore) + " milisegundos"); Fíjese que el test se usa para medir el tiempo que tarda en ejecutarse un programa encapsulado en el método doanything(), y que basta con cambiar el valor de las contantes para probar con otra implementación distinta.

6 Prácticas 15 y 16: Factorías e Iterables 6 En este ejercicio se proporciona todo el código, simplemente se pide que lo ejecute cambiando el valor de las constantes y observe el resultado. EJERCICIO 6: Testear todas las implementaciones posibles (para hacer en casa) Modifique el código anterior para que mida el tiempo que tarda en ejecutarse un programa para todas las combinaciones posibles de implementación de los tipos List y Set. Para ello utilice un par de for extendidos sobre los tipos enumerados de la siguiente forma: for (ListType lt : ListType.values()) { for (SetType st : SetType.values()) { //ejecutar el programa con lt y st } } Debe obtener una salida parecida a esta: Tiempo de ejecución con ARRAY_LIST y HASH_SET: Tiempo de ejecución con ARRAY_LIST y LINKED_HASHSET: Tiempo de ejecución con ARRAY_LIST y TREE_SET: Tiempo de ejecución con LINKED_LIST y HASH_SET: Tiempo de ejecución con LINKED_LIST y LINKED_HASHSET: Tiempo de ejecución con LINKED_LIST y TREE_SET: Tiempo de ejecución con VECTOR_LIST y HASH_SET: Tiempo de ejecución con VECTOR_LIST y LINKED_HASHSET: Tiempo de ejecución con VECTOR_LIST y TREE_SET: 9927 ms 9907 ms ms ms ms ms ms 9981 ms ms EJERCICIO 7: Secuencia aritmética creciente y decreciente En este ejercicio vamos a implementar un Iterable que genera una secuencia aritmética de números enteros que puede ser creciente o decreciente. Debe implementar la secuencia y el iterable teniendo en cuenta el siguiente diagrama: class sequences ArithmeticSeq - bound: Integer - first: Integer - increment: Integer Iterable + ArithmeticSeq(Integer, Integer, Integer) - getbound() : Integer - getfirst() : Integer - getincrement() : Integer + iterator() : Iterator<Integer> - setbound(integer) : void - setfirst(integer) : void - setincrement(integer) : void + tostring() : String ArithmeticSeq:: ArithmeticSeqIterator Iterator - current: Integer = getfirst() + hasnext() : boolean + next() : Integer - nextarithmetic() : Integer + remove() : void Fíjese que el acceso a las variables privadas también se hace a través de métodos get y set, aunque estos son privados (van precedidos de un - en el diagrama anterior). Esta estrategia de diseño se usa normalmente para encapsular en los métodos set el manejo de excepciones. Por ejemplo, en el método setincrement() debemos comprobar que el valor no es cero. Fíjese también que se ha incorporado un método nextarithmetic() que sirve para calcular cuál es el siguiente elemento de la secuencia aritmética. Aunque parezca poco útil, ya que se trata de sumar al valor actual el incremento, también se trata de una

7 Prácticas 15 y 16: Factorías e Iterables 7 estrategia para encapsular el problema de implementar un iterador a calcular cuál es el siguiente elemento de la secuencia. Ejecute ArithmeticSeqTest y obtendrá la siguiente salida: Secuencia creciente: Secuencia decreciente: Secuencia creciente: sequences.arithmeticseq@42e816 Secuencia decreciente: sequences.arithmeticseq@9304b1 Fíjese que cuando mostramos las secuencias generadas, no se muestran los elementos que contiene la secuencia. Para solucionar este problema debe implementar el método tostring() de la clase ArithmeticSeq(), hágalo para que se muestren los números entre corchetes y separados por comas. Ahora, cuando ejecute el test debe obtener la siguiente salida: Secuencia creciente: [-3, -1, 1, 3] Secuencia decreciente: [3, 1, -1, -3] EJERCICIO 8: Secuencia de números primos (para hacer en casa) Siguiendo la misma filosofía implemente una secuencia de números primos. Fíjese que todo el proceso de implementación es bastante metódico, y el problema se reduce a calcular cuál es el siguiente número primo mayor que el primo actual en el método nextprime() e implementar el método hasnext(). class sequences PrimeSeq - bound: Integer Iterable - getbound() : Integer + iterator() : Iterator<Integer> + PrimeSeq(Integer) - setbound(integer) : void + tostring() : String Iterator PrimeSeq:: PrimeSeqIterator - current: Integer = 1 + hasnext() : boolean + next() : Integer - nextprime() : Integer + remove() : void Realice un test para calcular cuántos números primos (no cuáles) hay en la secuencia aritmética que comienza en 100, termina en 1000 y se incrementa de 100 en 100. Debe obtener la siguiente salida: Existen 26 números primos entre 1 y 100 (26.0%) Existen 47 números primos entre 1 y 200 (23.5%) Existen 63 números primos entre 1 y 300 (21.0%) Existen 79 números primos entre 1 y 400 (19.75%) Existen 96 números primos entre 1 y 500 (19.2%) Existen 110 números primos entre 1 y 600 ( %) Existen 126 números primos entre 1 y 700 (18.0%) Existen 140 números primos entre 1 y 800 (17.5%) Existen 155 números primos entre 1 y 900 ( %) Existen 169 números primos entre 1 y 1000 ( %)

8 Prácticas 15 y 16: Factorías e Iterables 8 EJERCICIO 9: Secuencia de Captchas En este ejercicio vamos a implementar una secuencia de Captchas. Un Captcha es una prueba o test que se utiliza para determinar cuándo un usuario es humano o no. Una forma de implementar un Captcha es a través de una imagen que contiene un texto con algún tipo de ruido de forma que puede ser leído por un humano pero no por un ordenador (OCR, Reconocimiento Óptico de Caracteres). Por ejemplo, en la siguiente imagen se puede leer la cadena bxdcha : En el proyecto se proporciona la siguiente clase para implementar un captcha: class types Captcha + Captcha(String) + Captcha(String, String) + Captcha(String, String, Integer, Integer) + createjpg() : void + getfilename() : String + getheight() : Integer + getwidth() : Integer Esta clase tiene varios atributos (todos ellos de lectura), a saber: Value: almacena la cadena del captcha. Filename: almacena el nombre del archivo en el que se guarda el captcha. Width: almacena el ancho en pixeles que tiene el captcha. Height: almacena el alto en pixeles que tiene el captcha. Para crear objetos de tipo Captcha se dispone de tres constructores, al primero se le pasa como parámetro el valor de la cadena, al segundo se le pasa también el nombre del fichero, por último, al tercero también se le pasan las dimensiones. Por ejemplo para crear el captcha anterior bastaría con hacer Captcha c = new Captcha( bxdcha ). Para almacenar el captcha en un archivo JPG basta con invocar el método c.createjpg(). Este método genera una imagen JPG con las dimensiones indicadas en los atributos height y width, con el valor del captcha, y con el nombre de archivo indicado en filename.

9 Prácticas 15 y 16: Factorías e Iterables 9 Para crear la secuencia de Captchas vamos a seguir la misma técnica que en los ejercicios anteriores, el diagrama de clases es el siguiente: class sequences CaptchaSeq - numcaptchas: Integer - numchar: Integer Iterable + CaptchaSeq(Integer, Integer) - getnumcaptchas() : Integer - getnumchar() : Integer + iterator() : Iterator<String> - setnumcaptchas(integer) : void - setnumchar(integer) : void CaptchaSeq:: IteradorSecuenciaCaptcha Iterator - current: String = nextcaptcha() - numcurrentcapchas: Integer = 0 + hasnext() : boolean + next() : String - nextcaptcha() : String + remove() : void Fíjese que al constructor del iterable se le pasa el número de captchas que se quieren generar (numcaptchas) y el tamaño que tiene la cadena (numchar). Además, tenga en cuenta que el iterador debe crear la cadena con el valor del Captcha, no los archivos que almacenarán las imágenes. Ejecute un test que cree una secuencia de 10 captchas con un tamaño de 6 caracteres y los guarde en disco (en el directorio./res ). Esto son algunos ejemplos:

10 Prácticas 15 y 16: Factorías e Iterables 10 EJERCICIO 10: Clase de utilidad Iterables2 En el paquete utils se proporciona una clase utilidad llamada Iterables2. En dicha clase utilidad sólo se implementa el método from(), que está sobrecargado y sirve para crear iterables cuya fuente puede ser un iterable nativo como un array, un iterable creado por el programador como la secuencia aritmética, o incluso un iterable que lee de un archivo de texto los elementos de la secuencia línea a línea. A continuación detallamos dicho métodos: Apartado a) public static Iterable<Integer> from(integer first, Integer bound, Integer increment): Devuelve un iterable de enteros que se corresponde con la secuencia aritmética implementada en el ejercicio 5. public static Iterable<Integer> from(integer first, Integer bound): Devuelve un iterable de enteros que se corresponde con la secuencia aritmética implementada en el ejercicio 5 en el que el incremento vale 1. public static <T> Iterable<T> from(t[] array): Devuelve un iterable de tipos <T> a partir de los elementos que se le pasan como parámetro en el array. public static Iterable<String> from(string filename): Devuelve un iterable de cadenas que lee del fichero filename línea a línea. Realice un test en el que usando dicha clase utilidad muestre: 1. La secuencia aritmética i1 entre 1 y 100 con incremento de La secuencia aritmética i2 entre 1 y 100 con incremento de Cree un archivo llamado NAMES y escriba algunos nombres. Cree la secuencia i3 de cadenas creada a partir de dicho archivo. 4. Cree un array de caracteres que contenga las vocales. Cree la secuencia i4 creada a partir de dicho array. 5. Recorra la secuencia i3 y cree un Captcha para cada nombre contenido en el archivo NAMES. Cuando ejecute el test debe obtener una salida parecida a esta: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,, 100] [1, 11, 21, 31, 41, 51, 61, 71, 81, 91] [Bea, Carlos, Cristina, Daniel, David, Fermín, Isabel, Jorge, Luisa, Mariano, Miguel, Pepe, Rafael, Toñi] [Ljava.lang.Character;@a90653 [a, e, i, o, u] Por último, recorra la secuencia de nombres y cree un captcha para cada uno.

11 Prácticas 15 y 16: Factorías e Iterables 11 Apartado b) Vamos a crear una secuencia de cadenas leídas de un archivo RATIONALS y vamos a crear objetos de tipo Racional (el mismo que el de prácticas anteriores) a partir de la cadena. Una vez que creemos la secuencia la recorremos para calcular la suma de todos sus números racionales. De esta forma habremos sumado todos los números racionales del archivo RATIONALS. Siga los siguientes pasos: 1. Añada un nuevo constructor a RacionalImpl para crear un número racional a partir de su representación como cadena. Para ello recuerde que, por ejemplo, la representación como cadena de tres cuartos es 3/4. Utilice el método Split de la clase String para dividir la cadena. A dicho método le se invoca de la siguiente forma: String arraycadenas[] = s.split(separador); El resultado es un array de cadenas en el que elemento i-ésimo se corresponde la el token i-ésimo de la cadena. Por ejemplo si s es Manolo;Pedro;Juan y hacemos arraycadenas = s.split( ; ) en arraycadenas[1] se almacenará la cadena Pedro. 2. Cree la secuencia de cadenas a partir del archivo RATIONALS y recórrala con un for extendido para calcular la suma. Muestre el resultado por la consola.