Ejercicios de Tipos de datos y colecciones

2.1.Trabajando con wrappers

Utiliza la clase sesion02.Ej1 que se proporciona en la plantilla para construir un programa que tome como parámetro (en el main) dos valores reales (doubles), y muestre por pantalla el producto del primero y el segundo.

AYUDAS: utiliza la clase Double, y mira entre sus métodos cuáles pueden servirte para convertir los parámetros a números reales.

2.2.Aprovechando los elementos de Object

Echa un vistazo a la clase sesion02.Ej2 de la plantilla. Verás que hay una clase interna llamada MiObject que contiene un valor entero y una cadena. Tiene un constructor para poder asignar valor a cada campo. Después, desde la clase principal Ej2 se crean varios objetos de este tipo, cada uno con un valor entero y una cadena. Después se utiliza el método equals para compararlos entre sí, e indicar si son iguales o no. Finalmente, se imprime por pantalla cada uno de los objetos creados.

Asumimos que dos objetos de tipo MiObject son iguales si sus campos enteros son iguales, y si sus cadenas también son iguales. Teniendo en cuenta todo esto:

• Ejecuta el programa. ¿Funcionan bien las comparaciones? ¿Qué resultados obtienes con ellas?
• ¿Qué texto aparece cuando imprimes los objetos m1, m2 y m3? ¿Te resultan entendibles?

Probablemente habrás descubierto que las comparaciones no funcionan del todo bien: m1 y m2 son aparentemente iguales, y sin embargo dice que son diferentes. También habrás visto que a la hora de imprimir el objeto saca una ristra de caracteres que no se entienden. Vamos a corregir todo esto por separado.

• Para poder comparar bien los objetos MiObject entre sí necesitamos definir en esta clase su propio método equals, que redefina el que viene heredado de Object. Así que coloca un método equals en esta clase:

public boolean equals(Object o)
{
	...
}

y rellénalo de forma adecuada para que devuelva true si el objeto o es igual al actual (this), es decir, si tiene su campo entero y su campo cadena igual al actual.

AYUDA: observa que tendrás que convertir el objeto o a tipo MiObject para poder comparar. El método equals exige que el objeto que se le pasa como parámetro sea SIEMPRE de tipo Object, para poder hacer bien la herencia y sobreescritura del método equals original. Después, en el código, deberemos convertir este objeto al tipo concreto con que trabajemos:

MiObject mo = (MiObject) o;

• Para poder imprimir algo entendible al indicar que se imprima el objeto, debemos redefinir su método toString. Añade un método toString al código de MiObject:

public String toString()
{
	...
}

y haz que devuelva una cadena conteniendo el número entero, una coma, y la cadena del objeto MiObject.

• Ejecuta de nuevo el programa, y comprueba que funciona correctamente.

2.3.Recorrido de vectores y listas

La clase sesion02.Ej3 de la plantilla tiene un método main, donde hemos creado un objeto de tipo Vector, y le hemos añadido 10 cadenas: Hola0, Hola1, Hola2...Hola9. Con este vector deberás hacer lo siguiente:

• Primero, recorrerlo mediante el objeto Enumeration que puedes obtener del propio vector. Si observas la API de Vector, verás que tiene un método:

Enumeration elements();

que devuelve un Enumeration para poder recorrer los elementos del vector. Se trata de que obtengas esa enumeración, y formes un bucle como se ha explicado en los apuntes, para recorrerla de principio a fin. Para cada elemento, saca su valor por pantalla (imprime la cadena).

• A continuación de lo anterior, haz otro recorrido del vector, pero esta vez utilizando su Iterator. Verás también en la API que el objeto Vector tiene un método:

Iterator iterator();

que devuelve un Iterator para poder recorrer los elementos del vector. Haz ahora otro bucle como el que se explica en los apuntes, para recorrer los elementos del vector, esta vez con el Iterator. Para cada elemento, vuelve a imprimir su valor por pantalla.

• Finalmente, tras los dos bucles anteriores, añade un tercer bucle, donde a mano vayas recorriendo todo el vector, accediendo a sus elementos, y sacándolos por pantalla. En este caso, ya no podrás utilizar los métodos nextElement, hasNext, ni similares que has utilizado en los bucles anteriores. Deberás ir posición por posición, accediendo al valor de esa posición del vector (puedes utilizar el método que prefieras: get o elementAt), y sacando el valor obtenido por pantalla.

Una vez tengas los tres bucles hechos, ejecuta el programa, y observa lo que saca cada uno de los bucles por pantalla. ¿Encuentras alguna diferencia en el comportamiento de cada uno? ¿Qué forma de recorrer el vector te resulta más cómoda de programar y por qué?

NOTA: algunas de las técnicas que has utilizado para recorrer el vector se pueden utilizar de la misma forma para recorrer otros tipos de listas. Por ejemplo, puedes obtener el Iterator de un ArrayList y recorrerlo, o ir elemento por elemento...

2.4.Ventajas de los mapas

Trabajar con mapas es la forma más eficiente y cómoda de almacenar pares clave=valor. La clase sesion02.Ej4 contiene una subclase llamada Parametro, que utilizamos para guardar ciertos parámetros de configuración, y sus valores. Verás que esta clase tiene un campo nombre donde pondremos el nombre del parámetro, y otro valor con su valor.

La clase principal Ej4 crea muchos parámetros de este tipo, y los almacena en un ArrayList. Finalmente, busca en dicho ArrayList el valor del parámetro cuya clave se le pasa en el main. Saca un mensaje indicando en qué posición lo encontró, y luego imprime todos los Parametros por pantalla, sacando su nombre y su valor.

• Haz una clase sesion02.Ej4Hash que haga lo mismo, pero utilizando una Hashtable en lugar de un ArrayList. Debes tener en cuenta lo siguiente:
  • En esta clase no tendrás que usar la subclase Parametro, ya que podrás almacenar el nombre por un lado y el valor por el otro dentro de la tabla hash. Es decir, donde antes hacías:

  ArrayList al = new ArrayList();
  ...
  al.add(new Parametro("Clave1", "Valor1"));

  ahora harás:

  Hashtable ht = new Hashtable();
  ...
  ht.put("Clave1", "Valor1");

  • A la hora de buscar el elemento en la hash ya no necesitas ningún bucle. El método get de la Hashtable te permite obtener un valor si le das el nombre con que lo guardaste. Te devolverá el objeto asociado a ese nombre (como un Object que deberás convertir al tipo adecuado), o null si no lo encontró.

  String valor = (String)(ht.get(nombre));
  if (valor == null) ... else ...

  En este caso no hace falta que indiques en qué posición encontraste al elemento, puesto que, como verás después, las tablas hash no mantienen las posiciones como te esperas.

  • A la hora de imprimir todos los elementos por pantalla, una opción es obtener todo el listado de claves, y luego para cada una ir sacando su valor, e imprimir ambos. Para obtener un listado de todas las claves, tienes el siguiente método en Hashtable:

    Enumeration keys();

    te devuelve una enumeración de las claves. Luego utilízala para recorrerlas, y con cada una sacar su valor e imprimirlo:

    Enumeration en = ht.keys();
    while (en.hasMoreElements())
    {
    	String clave = (String)(en.nextElement());
    	String valor = (String)(ht.get(clave));
    	... // Imprimir clave y valor por pantalla
    }

• Comenta las conclusiones que obtienes tras haber hecho este ejercicio, y qué ventajas e inconvenientes encuentras a la hora de añadir elementos en la hash, y de recuperarlos.
• Observa cómo se imprimen los valores de la hash al sacarlos por pantalla. ¿Conservan el orden en que se introdujeron? ¿A qué crees que puede deberse?
• Si en lugar de trabajar con listas o tablas hash de 10 elementos fuesen de 1.000.000 de elementos, ¿quién se comportaría más eficientemente (ArrayList o Hashtable) y por qué? No hace falta que lo pruebes, haz una estimación basándote en lo que has visto hasta ahora.

2.5. Ordenar tus propios datos

La clase datos.Persona de la plantilla almacena los datos generales de una persona, como son su nombre, primer apellido, segundo apellido, dirección y teléfono. Tiene un constructor que se encarga de asignar todos esos campos, y métodos get y set para obtener sus valores o cambiarlos, respectivamente.

Además, al final tiene un método main que crea varios objetos de tipo Persona, los coloca en un ArrayList, y luego intenta ordenarlos llamando al método Collections.sort. Sin embargo, de momento el método no funciona (probablemente salte una excepción, porque no sabe cómo comparar los elementos de la lista).

Haz las modificaciones necesarias en la clase para que el método ordene correctamente. Queremos que se siga el siguiente criterio de ordenación:

• Ordenar de menor a mayor, según el primer apellido
• Si el primer apellido coincide, ordenar de menor a mayor según el segundo apellido
• Si también coincide, ordenar de menor a mayor por el nombre. Si también coinciden, se considerará que los nombres son iguales en orden.

Comprueba, una vez lo tengas hecho, que la secuencia que saca el programa tras ordenar es la correcta:

Elemento 1: "Bravo Murillo, Manuel, C/La Huerta - 22, 965123456"
Elemento 2: "García Hernández, Marta, C/Aloma - 22, 634253456"
Elemento 3: "García Hernández, Rafael, C/Aloma - 1, 601123546"
Elemento 4: "García Rodríguez, Carolina, Avda. Doctor Rico - 25, 661228844"
Elemento 5: "Simón Mas, Eva, Camino del Prado - 30, 966124627"  

Imagina que queremos cambiar el criterio de ordenación, y ahora queremos ordenar de mayor a menor por el nombre. ¿Qué cambios tendríamos que hacer? No los hagas, simplemente déjalos indicados en la respuesta a esta pregunta.