Anexo A. Novedades en Java 1.5

 

En este documento se resumen las principales novedades que ofrece la versión 1.5 de Java, separándolas en diferentes áreas. Para una explicación más detallada, consultar la página de Sun:

http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html

 

1. Novedades en la máquina virtual

Autoajuste de memoria mejorado

La capacidad de autoajustar la cantidad de memoria necesaria (pila, recolector de basura, etc) se ve mejorada en esta versión.

Compartir clases

Al instalar la máquina virtual, se cargan en memoria un conjunto de clases del sistema, en forma de representación interna, de forma que las siguientes llamadas a la máquina virtual ya encuentren estas clases mapeadas en memoria, y se permita que los datos de estas clases se compartan entre múltiples procesos dentro de la JVM.

Ajuste del recolector de basura

Relacionado con el autoajuste de memoria, el recolector de basura también se autoadapta a las necesidades de memoria de la aplicación, para evitar que el usuario tenga que ajustar su tamaño y características desde línea de comandos.

Tratamiento de errores fatales

El mecanismo de listado de errores fatales se ha mejorado de forma que se obtengan mejores diagnósticos a partir de las salidas generadas por dichos errores.

 

2. Novedades en el lenguaje

Tipos de datos parametrizados (generics)

Esta mejora permite tener colecciones de tipos concretos de datos, lo que permite asegurar que los datos que se van a almacenar van a ser compatibles con un determinado tipo o tipos. Por ejemplo, podemos crear un Vector que sólo almacene Strings, o una HashMap que tome como claves Integers y como valores Vectors. Además, con esto nos ahorramos las conversiones cast al tipo que deseemos, puesto que la colección ya se asume que será de dicho tipo.

Ejemplo

// Vector de cadenas
Vector<String> v = new Vector<String>();
v.addElement("Hola");
String s = v.getElementAt(0);
v.addElement(new Integer(20));			// Daría error!!

// HashMap con claves enteras y valores de vectores
HashMap<Integer, Vector> hm = new HashMap<Integer, Vector>();
hm.put(1, v);
Vector v2 = hm.get(1);

Autoboxing

Esta nueva característica evita al programador tener que establecer correspondencias manuales entre los tipos simples (int, double, etc) y sus correspondientes wrappers o tipos complejos (Integer, Double, etc). Podremos utilizar un int donde se espere un objeto complejo (Integer), y viceversa.

Ejemplo

Vector<Integer> v = new Vector<Integer>();
v.addElement(30);
Integer n = v.getElementAt(0);
n = n+1;

Mejoras en bucles

Se mejoran las posibilidades de recorrer colecciones y arrays, previniendo índices fuera de rango, y pudiendo recorrer colecciones sin necesidad de acceder a sus iteradores (Iterator).

Ejemplo

// Recorre e imprime todos los elementos de un array
int[] arrayInt = {1, 20, 30, 2, 3, 5};
for(int elemento: arrayInt)
	System.out.println (elemento);

// Recorre e imprime todos los elementos de un Vector
Vector<String> v = new Vector<String>();
for(String cadena: v)
	System.out.println (cadena);

Tipo enum

El tipo enum que se introduce permite definir un conjunto de posibles valores o estados, que luego podremos utilizar donde queramos:

Ejemplo

// Define una lista de 3 valores y luego comprueba en un switch 
// cuál es el valor que tiene un objeto de ese tipo
enum EstadoCivil {soltero, casado, divorciado};
EstadoCivil ec = EstadoCivil.casado;
ec = EstadoCivil.soltero;
switch(ec)
{
	case soltero:	System.out.println("Es soltero");
			break;
	case casado:	System.out.println("Es casado");
			break;
	case divorciado:System.out.println("Es divorciado");
			break;
}

Imports estáticos

Los imports estáticos permiten importar los elementos estáticos de una clase, de forma que para referenciarlos no tengamos que poner siempre como prefijo el nombre de la clase. Por ejemplo, podemos utilizar las constantes de color de la clase java.awt.Color, o bien los métodos matemáticos de la case Math.

Ejemplo

import static java.awt.Color;
import static java.lang.Math;

public class... 
{
...
	JLabel lbl = new JLabel();
	lbl.setBackground(white);		// Antes sería Color.white
...
	double raiz = sqrt(1252.2);		// Antes sería Math.sqrt(...)
}

Argumentos variables

Ahora Java permite pasar un número variable de argumentos a una función (como sucede con funciones como printf en C). Esto se consigue mediante la expresión "..." a partir del momento en que queramos tener un número variable de argumentos.

Ejemplo

// Funcion que tiene un parámetro String obligatorio
// y n parámetros int opcionales

public void miFunc(String param, int... args) 
{
...
	// Una forma de procesar n parametros variables
	for (int argumento: args)
	{
		...
	}
...
}

...
miFunc("Hola", 1, 20, 30, 2);
miFunc("Adios");

Metainformación

Se tiene la posibilidad de añadir ciertas anotaciones en campos, métodos, clases y otros elementos, que permitan a las herramientas de desarrollo o de despliegue leerlas y realizar ciertas tareas. Por ejemplo, generar ficheros fuentes, ficheros XML, o un Stub de métodos para utilizar remotamente con RMI.

Un ejemplo más claro lo tenemos en las anotaciones que ya se utilizan para la herramienta Javadoc. Las marcas @deprecated no afectan al comportamiento de los métodos que las llevan, pero previenen al compilador para que muestre una advertencia indicando que el método que se utiliza está desaconsejado. También se tienen otras marcas @param, @return, @see, etc, que utiliza Javadoc para generar las páginas de documentación y las relaciones entre ellas.

Ejemplo

// Definición de una interfaz mediante metainformacion

public @interface MiInterfaz
{
	int metodo1();
	String metodo2();
}

3. Novedades en librerías principales

Red

Se han añadido cambios y mejoras para el trabajo en red, como:

Seguridad

Hay bastantes mejoras en seguridad. Se da soporte a más estándares de seguridad (SASL, OCSP, TSP, etc), hay mejoras en la escalabilidad a través de SSLEngine, en criptografía, etc.

Internacionalización

Mediante la internacionalización podemos construir una aplicación que se adapte a varios idiomas, formatos monetarios, de fecha, etc, sin tener que reprogramarla. En este aspecto, se añaden mejoras en la versión 1.5, relacionadas con:

Formateador

La clase Formatter permite dar formato (justificación y alineamiento, formatos numéricos, de fecha, etc) a las cadenas y otros tipos de datos, siguiendo un estilo parecido al printf de C. También se permite mediante la interfaz Formattable dar formatos (limitados) a tipos creados por el usuario.

Ejemplo

// Uso de formatter para construir cadenas formateadas
StringBuilder sb = new StringBuilder();
Formatter f = new Formatter(sb, Locale.US);
f.format("Hola, %1$2s, esta es tu visita numero %2$d", "Pepe", 20);
// Resultaría: "Hola, Pepe, esta es tu visita numero 20"

// También se tienen unos métodos predefinidos en ciertas clases
System.out.format("Hola, %1$2s, esta es tu visita numero %2$d", "Pepe", 20);
System.err.printf("Hola, %1$2s, esta es tu visita numero %2$d", "Pepe", 20);
String s = String.format("Hola, %1$2s", "Pepe");

Escaneador

La clase Scanner permite parsear un flujo de entrada (fichero, cadena de texto, stream de datos, etc), y extraer tokens siguiendo un determinado patrón o tipo de datos. También se permite trabajar con expresiones regulares para indicar qué patrones se deben buscar.

Ejemplo

// Lectura de enteros de la entrada estándar
Scanner sc = Scanner.create(System.in);
int n = sc.nextInt();

// Lectura de todos los doubles de un fichero
Scanner sc = Scanner.create(new File("miFich.txt"));
while (sc.hasNextDouble())
	double d = sc.nextDouble();

// Uso de otros delimitadores
String s = "Esto hola es hola 1 hola ejemplo";
Scanner sc = Scanner.create(s).useDelimiter("\\s*hola\\s*");
System.out.println(sc.next());
System.out.println(sc.next());
System.out.println(sc.next());
// Sacaría Esto \n es \n 1

Arquitectura de JavaBeans

La arquitectura de JavaBeans se encuentra dentro del paquete java.beans.  Se ha añadido una nueva clase, IndexedPropertyChangeEvent, subclase de PropertyChangeEvent, para dar soporte a eventos que respondan a cambios en propiedades indexadas (propiedades que utilicen un índice para identificar la parte del bean que haya cambiado). También se han añadido mejoras a la hora de crear editores de propiedades de beans (PropertyEditor), como el método createPropertyEditor(...), y constructores públicos para la clase PropertyEditorSupport. 

Arquitectura de colecciones

Como se ha comentado antes, las colecciones (estructura que contiene clases e interfaces como Collection, Vector, ArrayList, etc) dan soporte a nuevas características del lenguaje, como el autoboxing, mejoras en los bucles (for) , y el uso de generics. Además, se han añadido interfaces nuevos, como Queue, BlockingQueue y ConcurrentMap, con algunas implementaciones concretas de dichas interfaces. Además, se tienen nuevas implementaciones de List, Set y Map.

Manipulación de bits

Los wrappers de tipos simples (es decir, clases como Integer, Long, Double, Char) soportan operaciones de bits, como highestOneBit, lowestOneBit, rotateLeft, rotateRight, reverse, etc. 

Elementos matemáticos

El paquete java.math también ha sufrido modificaciones, como la adición en la clase BigDecimal de soporte para cálculo en coma flotante de precisión fija. Clases como Math o StrictMath además incluyen soporte para senos y cosenos hiperbólicos, raíces cúbicas o logaritmos en base 10. Por último, también se da soporte al uso de números hexadecimales con coma flotante.

Serialización

Además de corregir errores previos en la serialización, se da soporte para serializar el nuevo tipo enum, aunque la forma de serializarlo difiere ligeramente de los tipos tradicionales.

Hilos

Se han añadido los paquetes java.util.concurrent, java.util.concurrent.atomic y java.util.concurrent.locks, que permiten crear diversas infraestructuras de hilos, como pooling de hilos o colas de bloqueos, liberando al programador de tener que controlar todas estas estructuras "a mano". En definitiva, se da soporte para automatizar la programación concurrente.

Además, a la clase Thread se le han añadido los métodos getStackTrace y getAllStackTraces para obtener la traza de los hilos en un momento dado.

Monitorización y gestión

Se tienen mejoras en el control o la monitorización tanto de las aplicaciones Java como de la máquina virtual (JVM), a través de la API de JMX.

4. Novedades en librerías adicionales

RMI

Se tienen dos mejoras fundamentales en RMI:

JDBC

En Java 1.4 se introdujo la interfaz RowSet, que permitía pasar datos entre componentes. En Java 1.5 se han desarrollado 5 implementaciones de dicha interfaz, para cubrir 5 posibles casos de uso:

JNDI

5. Novedades en la interfaz de usuario

Internacionalización

Para permitir renderizar texto multilingüe utilizando fuentes lógicas, se tienen en cuenta tanto las fuentes del cliente como las del locale que tengamos instalado. Además, AWT utiliza APIs Unicode en Windows 2000 y XP, con lo que se puede manejar texto sin estar limitado a la configuración de locale de Windows.

Java Sound

Para el tratamiento del sonido desde Java, se tienen también los siguientes cambios, principalmente:

Java 2D

Flujos de imágenes

Se permite, además de los formatos de imágenes ya soportados (PNG, JPG, etc), leer y escribir imágenes BMP y WBMP.

AWT

Las novedades más significativas son:

Swing

Entre otras, se tienen las novedades:

// Antes
JFrame f = new JFrame();
f.getContentPane().add(new JButton("Hola"));

// Ahora
JFrame f = new JFrame();
f.add(new JButton("Hola"));

6. Novedades en despliegue de aplicaciones

Despliegue general

Se tienen, entre otras, las siguientes novedades en cuanto a despliegue de aplicaciones:

Java Web Start

Hay también cambios específicos de Java Web Start, como son:

7. Novedades en herramientas

JPDA

JPDA es un conjunto de interfaces utilizadas para depurar en entornos y sistemas de desarrollo. En la versión 1.5 se tienen nuevas mejoras y funcionalidades de esta herramienta. Muchas de estas nuevas funcionalidades se han añadido para adaptar las nuevas características de la versión 1.5 de Java, como los argumentos variables, imports estáticos, etc.

JVMTI

JVMTI (Java Virtual Machine Tool Interface) es una nueva interfaz de programación nativa para utilizar en herramientas de desarrollo y monitorización. Forma parte de las interfaces contenidas en JPDA para depuración. Permite chequear el estado y controlar la ejecución de una aplicación.

Compilador (javac)

Se han añadido algunas características a la hora de utilizar el compilador, como son los parámetros:

Herramienta javadoc

Se tienen nuevas funcionalidades en la herramienta javadoc. Como en otros elementos, muchos de los cambios dan soporte a características nuevas de Java 1.5 (generics, tipo enum, etc). Se tienen también marcas nuevas, como regression para indicar funcionalidades que se desaconsejaron en versiones anteriores, pero que han sido corregidas en la nueva. También se da soporte a anotaciones para generar metainformación que utilizar en otros programas.