Programación III (Java) - 05 Genericos y Colecciones - java6-7

Mejoras Java 5-7 (Java SE7)

Mejoras más importantes
•Mejoras menores
•Genericidad
•Bucle for-each
•Boxing
•Enumeraciones
•Parámetros variables
•Importación estática
•Metadatos
•Mejoras específicas del JDK 1.6
•Más información

Programación III Tema 5 - Java 6

Mejoras menores Java 6
– Mejoras en el garbage collector
– Nueva clase StringBuilder (buffer de
caracteres)
– Mejora significativa de Java 2D, gestión de
imágenes y OpenGL.
– Mejora de gestión de imágenes jpeg
– Mejoras en algunas clases de la API (lang, util,
comunicaciones, seguridad y criptografía,
sonido...)
– Opciones adicionales de compilación, javadoc...


Mejoras menores Java SE7
– Literales binarios (0b0010...)
– Subrayados entre dígitos en literales numéricos
(1234_5678_9012_3456L) (no vale 3_.14)
• Como si no estuvieran, para mejorar legibilidad
– Strings en sentencias switch (String.equals)
– Mejoras en gestión del heap
– Más de una excepción en cada catch
catch (IOException|SQLException e) {
– try con recursos
try (java.io.BufferedWriter writer = ...) {
// Hace un close al final (sin poner finally)
} // Deben implementar java.lang.AutoCloseable

Genericidad (generics) (1/3)

• Problema
– Al trabajar con contenedores (Collection)
estamos obligados a hacer casting continuo:
static void quitaVacios(Collection c) {
for (Iterator i = c.iterator();
i.hasNext(); )
if (((String) i.next()).length() == 0)
i.remove();
}
– Esto es incómodo y también inseguro (puede
generar un error en ejecución)


Genericidad (2/3)
– La genericidad permite informar al compilador
del tipo de la colección, de modo que puede ser
chequeado en compilación, y evita el cast:
static void quitaV(Collection<String> c) {
for (Iterator<String> i = c.iterator();
i.hasNext(); )
if ((i.next()).length() == 0)
i.remove();
}
– El uso de la genericidad obliga a que todos los
elementos de la colección sean ahora de la clase
indicada entre < y > (String en el ejemplo)
– Similar al “template” de C++


Genericidad (3/3)
– Las colecciones (las vemos después) no son el
único uso de la genericidad, se pueden usar en
otros puntos (aunque programar nuevas clases
genéricas es complejo)
– La genericidad en Java 1.5 afecta a todas las
clases contenedoras, como List, Vector, Tree...
– Una clase puede ser genérica sobre un tipo...
• Vector<E> (ej. Vector<Integer>)
• ArrayList<E> (ej. ArrayList<Persona>)
– O sobre varios...
• HashMap<K,V> (ej.
HashMap<Integer,Persona>)

Mejoras Java 7 Genericidad

• Inferencia de tipos genéricos
Map<String, List<String>> myMap
= new HashMap<String, List<String>>();
// En Java SE 7 se puede poner el "diamond" <>:
Map<String, List<String>> myMap = new
HashMap<>();


Bucle for-each (1/2)
– Relacionado con las colecciones, se permite un
nuevo tipo de bucle. Para evitar la pesada
construcción:
for (Iterator i = palos.iterator();
i.hasNext();) {
Palo palo = (Palo) i.next();
...
}

– Se puede utilizar un nuevo tipo de for:
for (Palo palo: palos) {
...
}


Bucle for-each (2/2)
– El símbolo “:” se lee “en”
– Pueden anidarse bucles sin problema:
for (Palo p : listaPalos)
for (Numero n : listaNumeros)
baraja.add( new Carta(p,n) );
– Y la construcción es aplicable a arrays:
int sumaArray(int[] a) {
int res = 0;
for (int i : a)
res += i;
return res;
}
– En general, for-each puede utilizarse siempre que no se
modifica la colección según se recorre (para ese caso
hay que volver al esquema tradicional)


“Boxing”
– Donde se espere un objeto no se puede poner un
valor primitivo (p. ej. lista de enteros)
– Solución: wrappers (Integer en vez de int)
– Problema: código muy “sucio”:
LinkedList l = new LinkedList();
l.add( new Integer(i) );
...
int j = ((Integer) l.get(0)).intValue();
– Java 1.5 incorpora autoboxing (convertir
primitivo al wrapper) y unboxing (convertir el
wrapper a primitivo) de forma transparente:
l.add( i );
...
int j = l.get(0);

Enumeraciones (1/3)
– Java 1.4 no permite enumeraciones, lo que obliga a
utilizar constantes:
public static final int PRIMAVERA = 0;
public static final int VERANO = 1;
public static final int OTOÑO = 2;
public static final int INVIERNO = 3;
– Esto presenta múltiples problemas:
• No hay un tipo diferenciado (podría pasarse cualquier otro
entero por error)
• No hay nombres diferenciados (podrían confundirse con otros
nombres)
• No hay información (cada valor es un número, sin relación con
su “significado”)
– Los lenguajes modernos mejoran esto con las
enumeraciones, y Java las incorpora en su versión 1.5.

Enumeraciones (2/3)
– En Java 1.5 esta enumeración se haría:
enum Estacion { PRIMAVERA, VERANO, OTOÑO,
INVIERNO }
– Esta declaración define una NUEVA CLASE
• Puede redefinir métodos de Object
• Puede añadir métodos propios
• Se visualiza como el string del nombre, no como un
entero
• Es Comparable y Serializable...
– Veamos un ejemplo


Enumeraciones (3/3)
public class Carta {
public enum Rango { DOS, TRES, CUATRO, CINCO, SEIS, SIETE,
SOTA, CABALLO, REY, AS }
public enum Palo { OROS, COPAS, ESPADAS, BASTOS }
Rango rango;
Palo palo;
public Carta(Rango r, Palo p) {
rango = r;
palo = p;
}

public String toString() { return rango + " de " + palo; }

public static List<Carta> baraja = new ArrayList<Carta>();

// Inicialización ...
public void static main (String s[]) {
for (Palo p : Palo.values())
for (Rango r : Rango.values())
baraja.add(new Carta(r,p));
}
}


Parámetros variables
(varargs)
– Java 1.4 no permite número de parámetros variable (lo que obliga a
no permitir construcciones como el println de C)
– Se puede simular pasando varios objetos dentro de un único array
de objetos
– Java 1.5 permite indicar parámetros múltiples con puntos susp.:
public static int suma( Integer... listaEnts ) {
int sum = 0;
for (Integer i : listaEnts) {
sum += i; //combinado con unboxing
}
return sum;
}
– Se comporta como un array de parámetros
– Con lo que podríamos hacer
int i = Arit.suma( 1, 2, 3 ); // autoboxing
int j = Arit.suma( 5, 10, 15, 20, 25, 30 );
...
– Se incorpora un nuevo método printf


Importación estática
– Los nombres estáticos (las antiguas variables y
funciones “globales”) obligan a abusar de los
prefijos de nombres de clase. Por ejemplo:
import java.lang.Math;
...
double r = Math.cos(Math.PI * alfa);
– Java 1.5 facilita este proceso permitiendo
importar también nombres de atributos y
métodos estáticos, para evitar el prefijo de
clase:
import static java.lang.Math.*;
// podría ser uno a uno:
// import static java.lang.Math.PI;
...
double r = cos(PI * alfa);

Metadatos (Anotaciones)
– Java, siguiendo la idea de .NET de MS, incorpora
en la versión 1.5 anotaciones
– Las anotaciones permiten añadir metadatos en el
propio programa, no como comentarios
• Veremos alguna más adelante


Mejoras del JDK 1.6
• Mayor facilidad en el desarrollo de Servicios
Web XML.
• Integración sencilla con otros lenguajes de
scripting como JavaScript, Python y Ruby.
• Mejora en el acceso a bases de datos
mediante JDBC4.0 así como la API Java DB.
• Mejoras en el desarrollo de aplicaciones de
escritorio (ventanas) mediante componentes
nuevos, gestores de hilos de interfaz, filtros
de ordenación y actualización, etc.


Mejoras del JDK 1.6
• Mayores utilidades para perfilar el rendimiento de
una aplicación y diagnóstico.
• Mayor acceso a funcionalidades del compilador
para compilación de código objeto bajo demanda
o para desarrollar herramientas para la plataforma.
• Mejor gestión de anotaciones así como posibilidad
de ejecutar los procesadores necesarios según las
mismas.
• Mejoras en la distribución de aplicaciones de
escritorio (ventana) mediante una mejor
integración con el sistema, plug-ins, webstart, etc.


Mejoras del JDK 1.6

• Más y mejores estructuras de seguridad en la
plataforma tanto para el desarrollo usando
tecnologías de autentificación como en la
administración de seguridad de la aplicación.
• Al haberse desarrollado multitud de
programas y líneas de testeo, la plataforma
Java cada vez está resultando más estable,
fiable y robusta. Solución a problemas del
pasado, bugs, problemas de compatibilidad
hacia atrás, etc…

Colecciones

• Colecciones = contenedores
– Objetos que sirven como grupo de objetos
– Se usan para almacenar, recoger, manipular
y comunicar datos
– Suelen representar grupos naturales (carpeta de
documentos, un directorio de contactos...)
– Son imprescindibles en todo lenguaje
• La colección más básica es el array (y el fichero en
memoria secundaria)
• En Java 1.2 estaban también Vector y Hashtable
• En Java 1.5 se incorpora todo el framework
Collections

Framework Java
Collections
• Es una arquitectura unificada para manejar
contenedores en Java (desde la 1.5)
– Interfaces (representaciones abstractas)
– Implementaciones (clases instanciables)
– Algoritmos (búsqueda, ordenación...)
• Estilo STL de C++ (más sencillo)
• De amplio espectro
– Se pueden usar en muchos casos concretos
– Modo seguro y contrastado de usar EEDD
– Aunque hay que conocerlas bien!

JC: Interfaces

• Semántica de agrupación
– Diferentes usos
– Interfaces abstractos
– Forman una jerarquía
• Todas las colecciones son genéricas
– Los tipos se controlan en compilación
– Pero también pueden hacerse polimórficas
conteniendo a su vez clases padre o interfaces
– Para simplificar, las variantes de implem. no
están incluidas en los interfaces


JC: Variantes en Interfaces

• Las variantes de implementación son 3:
• inmutables, tamaño fijo, append-only
• JC decide meter las diferencias como
métodos opcionales
– "optional" indicado en la documentación
– Cada clase puede o no soportarlos
– Si se llaman y no lo están, excepción
UnsupportedOperationException


JC: Descripción de los Interfaces

• Collection: Agrupación de elementos
– Set (conjunto): Colección sin duplicados
• SortedSet: Ordenado por valor (comparación)
– List (lista, secuencia): colección ordenada por
posición (estilo array). Puede tener duplicados
– Queue (cola): Almacén ordenado de elementos
hasta su proceso
• Map: Agrupación de emparejamientos
clave-elemento (sin duplicados)
– SortedMap: Ordenado por clave


JC: Ordenación

• Algunos tipos son ordenados y otros
permiten ordenar:
List l = ... Collections.sort( l );
– Imprescindible: implementar Comparable<T>
public int compareTo( T o );
– Hay clases básicas comparables:
• Boolean, Byte, Character
• Long, Integer, Short, Double, Float
• BigInteger, BigDecimal
• String, Date, File ...
– Y podemos definir las nuestras. Ejemplo:

JC: Ejemplo de Comparable
import java.util.*;
public class Nombre implements Comparable<Nombre> {
private final String nombre, apellidos;
public Nombre(String nombre, String apellidos) {
if (nombre == null || apellidos == null)
throw new NullPointerException();
this.nombre = nombre;
this.apellidos = apellidos;
}
public String nombre() { return nombre; }
public String apellidos() { return apellidos; }
public boolean equals(Object o) {
if (!(o instanceof Nombre)) return false;
Nombre n = (Nombre) o;
return n.nombre.equals(nombre) &&
n.apellidos.equals(apellidos);
}

Ejemplo de Comparable (2)
public int hashCode() {
// objetos iguales (equals) deben tener hash iguales
return 31*nombre.hashCode() + apellidos.hashCode();
}

public String toString() {
return nombre + " " + apellidos;
}

public int compareTo(Nombre n) {
int ultimaCmp = apellidos.compareTo(n.apellidos);
return (ultimaCmp != 0 ? ultimaCmp :
nombre.compareTo(n.nombre));
}
}


¿Cómo se ordena?
Algoritmo
Nombre n1, n2, n3, n4, n5;
// Uso 1: explícita (ALGORITMO) de Collections
ArrayList<Nombre> ln = new ArrayList<Nombre>();
ln.add( n1 = new Nombre( "Buzz", "Lightyear" ));
ln.add( n2 = new Nombre( "Woody", "Allen" ));
ln.add( n3 = new Nombre( "Tim", "Burton" ));
ln.add( n4 = new Nombre( "Richard", "Marx" ));
ln.add( n5 = new Nombre( "Groucho", "Marx" ));
Collections.sort( ln );
System.out.println( ln );

[Woody Allen, Tim Burton, Buzz Lightyear, Groucho Marx,
Richard Marx]


¿Cómo se ordena?
Estructura
// Uso 2 de ordenación: en estructura ordenada
TreeSet<Nombre> sn = new TreeSet<Nombre>();
sn.add( n1 );
sn.add( n2 );
sn.add( n3 );
sn.add( n4 );
sn.add( n5 );
System.out.println( sn );

[Woody Allen, Tim Burton, Buzz Lightyear, Groucho Marx,
Richard Marx]


¿Y más de un orden?
Comparator
• Tenemos un problema si necesitamos más de
un orden (sólo uno en Comparable)
– Solución: Comparator
static final Comparator<Nombre> ORDEN_DE_NOMBRE =
new Comparator<Nombre>() {
public int compare(Nombre n1, Nombre n2) {
return n1.nombre.compareTo(n2.nombre);
}
};
(...)
Collections.sort( ln, ORDEN_DE_NOMBRE );
System.out.println( ln );

[Buzz Lightyear, Groucho Marx, Richard Marx, Tim Burton,
Woody Allen]

JC: Implementaciones

• Las clases que permiten hacer todo esto son:

– Estas son las de propósito general
– Algunos interfaces tienen varias
implementaciones con EEDD distintas (set, map)

JC: Implementaciones
típicas
• Lo habitual será usar:
– Set: HashSet
• SortedSet: TreeSet
– List: ArrayList
– Map: HashMap
• SortedMap: TreeMap
– Queue: LinkedList (FIFO)
• Con prioridad (ord. por valores): PriorityQueue
• No están sincronizadas (ver threads)
– Para la mayor parte de usos no hace falta


JC: Otras implementaciones

• JC funciona con wrappers para cambios
– Se crea una segunda colección que "envuelve" a
la original con otras características
• Sincronización (threads)
List<Nombre> ln = Collections.synchronizedList(
new ArrayList<Nombre>() );

• No modificable (los objetos no cambian)
List<Nombre> ln = Collections.unmodifiableList(
new ArrayList<Nombre>() );

• Otras especializadas


JC: Otras utilidades

• Vista de un array como una List:
Nombre[] vNoms = new Nombre[100];
(...)
List<Nombre> lNoms = Arrays.asList( vNoms );
– No permite modificaciones (es sólo una vista)
• Constantes vacías
– Si se necesitan para paso de valor inicial vacío
• Collections.emptySet()
• Collections.emptyList()
• Collections.emptyMap()


JC: Algoritmos

• Todos están en la clase Collections
– Ordenar: sort( list ), sort( list, Comparator )
– Desordenar aleatoriamente: shuffle( list )
– Manipular datos:
• Invertir posición: reverse( list )
• Rellenar (sustituir) de un valor: fill( list )
• Copiar de una lista a otra: copy( list1, list2 )
• Intercambiar elementos: swap( list, ind1, ind2 )
• Añadir varios elementos: addAll ( list, elto... )


JC: Algoritmos (2)
– Buscar datos
• Búsqueda en lista ordenada: binarySearch( list, elem
)
• Búsqueda por orden específico:
binarySearch( list, elem, comparator )
• La búsqueda devuelve dos informaciones en una:
– Valor positivo o 0 si se encuentra elemento: su posición
– Valor negativo si no se encuentra: el punto donde se
insertaría = (-pos-1)
– Composición:
• Contar elementos: frequency( colección, elem )
• Comprobar que no hay elementos comunes:
disjoint( colección1, colección2 )
– Buscar valores extremos: min y max

JC: Mejoras en Java 6

• Nuevos interfaces:
– Deque - cola de doble dirección
– BlockingDeque - una Deque concurrente que
espera a la cola no vacía o no llena
– NavigableSet - un SortedSet mejorado con
métodos de navegación que buscan resultados
cercanos, y permiten recorrer en las dos
direcciones.
– NavigableMap - un SortedMap mejorado del
mismo modo.
– ConcurrentNavigableMap .

JC: Mejoras en Java 6 (2)

• Nuevas implementaciones:
– ArrayDeque - implementación de Deque.
– LinkedBlockingDeque - de BlockingDeque.
– ConcurrentSkipListSet - de NavigableSet.
– ConcurrentSkipListMap - de
ConcurrentNavigableMap.

• Mejoras en clases existentes:
– LinkedList - implementa Deque.
– TreeSet - implementa NavigableSet.
– TreeMap - implementa NavigableMap.
• Utilidad de Arrays copiar/truncar: copyOf

Otras mejoras importantes
de Java 7
• Nueva y mejorada E/S (NIO 2.0)
– Path mejorando a File
– Globs además de Patterns
– Mejoras de trabajo directo con ficheros
• Gestión de ZIP y JAR como sists. de ficheros
• Mejoras para la generación de aplicaciones
de internet (RIA, Rich Internet Applications)
• Integración de JavaFX
– Una plataforma nueva y avanzada para interfaz
de usuario

Programación III (Java) - 05 Genericos y Colecciones - java6-7

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Programación III (Java) - 05 Genericos y Colecciones - java6-7

Ähnlich wie Programación III (Java) - 05 Genericos y Colecciones - java6-7 (20)

Mehr von Andoni Eguíluz Morán

Mehr von Andoni Eguíluz Morán (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Programación III (Java) - 05 Genericos y Colecciones - java6-7