Download double r = x / y

Algoritmos y Programación III
4. Colecciones,
excepciones
Carlos Fontela, 2006
Temario

Colecciones e iteradores

Excepciones

Tratamiento de problemas con un enfoque optimista

Desacoplar código de tratamiento de problemas
Algoritmos y Programación III
Carlos Fontela, 2006
Página 2
Colecciones



Agrupan objetos.

Cada elemento tiene un significado similar.

El valor depende de la posición.
Se puede operar sobre:

Un elemento en particular.

Algunos elementos elegidos mediante un filtro.

La colección como conjunto.

Se definen recorridos.
Tienen diferentes interfaces,
funcionalidades y eficiencias.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 3
Colecciones (II)

Arreglos


Listas encadenadas


vectores, matrices, multidimensionales
lineales, dobles, circulares, multilistas
Árboles

binarios, generales
Algoritmos y Programación III
Carlos Fontela, 2006
Página 4
Arreglos primitivos en Java


Única colección como tipo primitivo.
Tamaño se define en tiempo de ejecución.


Seguros:



Chequeo de rangos.
Tipo de los elementos definido estáticamente.
Muy veloces


Una vez definido, no puede variar.
Salvo por chequeo de rangos.
Biblioteca de funciones pobre en
comparación.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 5
Interfaces de apoyo
public interface Comparable {
public int compareTo (Object o);
}
public interface Comparator {
public int compare (Object o1, Object o2);
public boolean equals (Object o1, Object o2);
}
Algoritmos y Programación III
Carlos Fontela, 2006
Página 6
Clase Arrays
Clase utilitaria.
 Sus métodos son “de clase” o
“estáticos”.

equals(v1,v2)
 sort(v)
 sort (v, Comparator c)
 binarySearch(v, x)
 binarySearch(v, x, Comparator c)
 otros...

Algoritmos y Programación III
Carlos Fontela, 2006
Página 7
Arrays.sort e interfaces (I)

Arrays.sort(v1)

Funciona bien si el tipo base de v1
• Es primitivo
• Implementa Comparable
• Usa el compareTo definido


Si no, arroja una excepción.
Para otros tipos base:

Arrays.sort(v1,c)

Hay que implementar un Comparator
Algoritmos y Programación III
Carlos Fontela, 2006
Página 8
Arrays.sort e interfaces (II)

Para ordenar Fraccion(es):
public class ComparadorFracciones
implements java.util.Comparator {
public int compare(Object o1, Object o2) {
Fraccion f1 = (Fraccion)o1; Fraccion f2 = (Fraccion)o2;
if (f1.igual(f2)) return 0;
else if (f1.mayor(f2)) return 1;
else return -1; }
}
// luego...
Comparator comp = new ComparadorFracciones();
Arrays.sort(vecFracciones, comp);

Ídem para binarySearch
Algoritmos y Programación III
Carlos Fontela, 2006
Página 9
Colecciones de java.util (I)
Las más comunes de Java 1.4:
«uses»
Iterator
«uses»
Collection
Map
«uses»
ListIterator
List
ArrayList
Algoritmos y Programación III
Carlos Fontela, 2006
Set
LinkedList
HashSet
TreeMap
HashMap
TreeSet
Página 10
Colecciones de java.util (II)

Tienen elementos de tipo Object.

No se sabe qué hay dentro.

No admiten elementos primitivos.
• Pero hay clases envolventes: Integer,
Boolean, Double, Character, etc.

Colecciones heredadas:

Vector, Hashtable, Stack, BitSet,
Properties, etc.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 11
Clase Collections

Es la Arrays de las colecciones.


(una clase utilitaria de métodos estáticos)
Algunos métodos:


void sort(Collection c, Comparator comp)
int binarySearch(Collection c, Object x,
Comparator comp)

Object max(Collection c, Comparator comp)

Object min(Collection c, Comparator comp)


void reverse()
Collection unmodifiableCollection(Collection c)
Algoritmos y Programación III
Carlos Fontela, 2006
Página 12
Iteradores (I)


Para definir recorridos.
Interfaz:




Tomar el primer elemento.
Tomar el elemento siguiente.
Testear si se termina la colección.
Un ejemplo:
List v = new ArrayList();
for(int i = 0; i < 10; i++) v.add(new Integer(i));
Iterator it = v.iterator();
// pido un iterador para v
while(it.hasNext())
// recorro la colección
System.out.println((Integer)it.next());
Algoritmos y Programación III
Carlos Fontela, 2006
Página 13
Iteradores (II)

Toda clase que implemente Collection
puede generar un Iterator con el
método iterator
«interface»
Iterator
+next() : Object
+hasNext() : boolean

«uses»
«interface»
Collection
+iterator() : Iterator
Nótese que Iterator es una interfaz

Pero está implementada para las
colecciones definidas en java.util.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 14
Iteradores (III)

Llevan la abstracción a los recorridos
de colecciones.

Facilitan cambios de implementación.

No se necesita trabajar con el
número de elementos.

Convierten a las colecciones en
simples secuencias.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 15
Iteradores antiguos

Clase Enumeration
Collections.enumeration(c)
 hasMoreElements()
 nextElement()


Ejemplo
Enumeration it = Collections.enumeration(v);
while(it.hasMoreElements())
System.out.println((Integer)it.nextElement());

Se usan todavía
Algoritmos y Programación III
Carlos Fontela, 2006
Página 16
Definiendo iteradores (I)
public class Matriz2D extends AbstractCollection {
int cantFilas; int cantCol;
Object [ ] [ ] m2;
public Matriz2D(int filas, int columnas) {
m2 = new Object[filas][columnas];
cantFilas = filas; cantCol = columnas;
}
public Iterator iterator() {
return new IteradorMatriz2D(this);
}
public int size() { return (cantFilas*cantCol); }
public Object get (int i, int j) { return m2[i][j]; }
// otros métodos ...
}
Algoritmos y Programación III
Carlos Fontela, 2006
Página 17
Definiendo iteradores (II)
public class IteradorMatriz2D implements Iterator {
int filaActual; int colActual; Matriz2D m2;
public IteradorMatriz2D (Matriz2D m) {
filaActual = 0; colActual = 0; m2 = m;
}
public Object next() {
if (!hasNext()) throw new NoSuchElementException();
Object o = m2.get(filaActual,colActual);
if (colActual < cantCol-1) colActual++;
else { filaActual++; colActual = 0;
}
return o;
}
public boolean hasNext() {
return !((filaActual == cantFilas-1) && (colActual == cantCol-1));
}}
Algoritmos y Programación III
Carlos Fontela, 2006
Página 18
Otras soluciones

Tipos genéricos


Ada
Clases parametrizadas

C++
• También hay iteradores, más ricos

Genericidad restringida

Eiffel

Java 5
Algoritmos y Programación III
Carlos Fontela, 2006
Página 19
Lanzamiento de excepciones
public class eDivisionPorCero extends Exception { }
----------------------------------------------------------------------------------------------------------------public static void dividir (double x, double y )
throws eDivisionPorCero {
if (y == 0)
throw new eDivisionPorCero();
else return x/y;
}
Captura de excepciones

Manejador (puede haber varios):
try {
c = dividir(a,b);
}
catch (eDivisionPorCero e) {
// hago algo...
}
finally {
// hago algo...
}
Clases de excepciones

Deben heredar de Exception o una
derivada.

Pueden tener atributos y métodos:


Para usar en la captura.

En general no se usan.
Las jerarquías influyen en la captura:

Se captura cualquier clase derivada.

Ojo con el orden de captura.
Excepciones seguras (I)

Cláusula throws es obligatoria
public static void dividir (double x, double y )
throws eDivisionPorCero {
if (y == 0) throw new eDivisionPorCero();
else return x/y;
}


A lo sumo se puede declarar un ancestro
En redefiniciones, mantener y no agregar

Para mantener el polimorfismo: muy molesto
Excepciones seguras (II)

Obligación de capturar (I)
public double suma (double[ ] x, double[ ] y) {
double s = 0;
try {
for (int i = 0; i < 10; i++)
s += dividir(x[i],y[i]);
} catch (eDivisionPorCero e) {
System.err.println(“División por cero”);
return 0;
}
return s;
}

El chequeo se hace en tiempo de compilación
Excepciones seguras (III)

Obligación de capturar (II)
public double suma (double[ ] x, double[ ] y)
throws eDivisionPorCero {
double s = 0;
for (int i = 0; i < 10; i++) s += dividir(x[i],y[i]);
return s;
}

Obligación de capturar (III)
public double suma (double[ ] x, double[ ] y) {
double s = 0;
try {
for (int i = 0; i < 10; i++) s += dividir(x[i],y[i]);
} catch (eDivisionPorCero e) { }
return s;
}
Jerarquías de excepciones
Throwable
Error
Exception
RuntimeException
Más de 29 clases y sus derivadas...
Más de 55 clases y sus derivadas...
Aserciones

Buenas para depuración
assert (b == 0): "la variable b no debe valer cero";

Respuesta:
Exception in thread "main" java.lang.AssertionError: la variable
b no debe valer cero at
PruebaAserciones.main(PruebaAserciones.java:3)

Y buenas como documentación
Comprobación de estados

Enfrentar problemas en tiempo de
ejecución:
double r = x / y;
• ¡y puede ser 0!
Matriz a = b.inversa();
• ¡b puede ser no invertible!

¿Cómo enfrentamos los problemas?
Algoritmos y Programación III
Carlos Fontela, 2006
Página 28
Enfoques conservadores (I)
if (y != 0)
double r = x / y;
else System.out.println (“Valor de y inválido”);


Estoy suponiendo que el resultado no era importante.
Y que el mensaje tiene sentido para el usuario final.
boolean error; double r;
if (y != 0)
{
r = x / y;
error = false;
} else error = true;

Supongo que el programador cliente sabrá qué hacer
con “error”.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 29
Enfoques conservadores (II)
while (y == 0) {
System.out.println(“Valor y inválido, ingrese otro”);
leer(y);
}
double r = x / y;

Supongo que el usuario final sabe de qué le estoy
hablando.
do { }
while (y != 0); // espera que el estado cambie
double r = x / y;

Supongo que otro hilo vendrá en mi ayuda.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 30
Enfoques conservadores (III)

Los más simples son ingenuos

Los parámetros de error:

Envían el problema a un contexto que tal vez
no los pueda resolver.

Son tediosos de verificar y en general no se
verifican.

Acoplan mucho el código “bueno” con el de
tratamiento de problemas.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 31
Enfoques optimistas

El conservador dice:


El optimista:


“Compruebo primero y luego actúo”.
“Pruebo actuar y resuelvo en el caso de
hallar problemas”.
¿Cómo encaro el enfoque optimista?

Excepciones.
Algoritmos y Programación III
Carlos Fontela, 2006
Página 32
Qué sigue

Modelo de datos
Clonación
 Recolección de basura

Reflexión y RTTI
 Paramos con la programación

Desarrollo orientado a objetos
 Pruebas
 Documentación
 Arquitecturas

Algoritmos y Programación III
Carlos Fontela, 2006
Página 33
Muchas Gracias.
Carlos Fontela, 2006