Club Desarrolladores

Estos wrapper no son más que clases que modelan los tipos de datos primitivos tales como enteros y flotantes, precisamente estos tipos primitivos son los únicos elementos en Java que no son clases.
Cabe destacar una diferencia notable entre los tipos primitivos y sus wrapper: Los tipos primitivos se pasan como argumento a los métodos por valor, mientras que los objetos se pasan por referencia. Esto implica una ventaja en cuanto a eficiencia.
Por otra parte estos wrapper ofrecen métodos de conversión muy convenientes.

Estas clases se encuentran en java.lang, derivan de Number que deriva de Object. Cada una de estas clases contiene un valor primitivo del tipo relacionado, por ejemplo (y es la clase que tomaremos para hacer las pruebas) un objeto Integer contiene un int como atributo.

Algunos métodos de Integer.

El constructor de un wrapper está sobrecargado para aceptar el tipo de dato primitivo que va a contener o un objeto String.

Integer(int)
Integer(String)

Entre sus métodos encontramos algunos que nos permiten recuperar el tipo primitivo que queramos.

doubleValue()
floatValue()
longValue()
intValue()
shortValue()
byteValue()

También tenemos conversores con la clase String.

String toString()
Integer valueOf(String)

Además todos estos métodos pueden utilizarse en forma estática, esto es, no es necesario crear una instancia para utilizarlos. Aunque esto no es del todo cierto, ya que por ejemplo como sucede con el método valueOf(), retorna una instancia del wrapper. Por lo tanto estas clases wrapper son fabricantes de objetos (ver factory pattern).
Estas clases también declaran constantes que definen su valor máximo, su valor mínimo, etc.

Conversiones entre distintos tipos de datos básicos

He creado esta clase para conversiones con el fin de agrupar estos métodos y mostrar los simples pasos de conversión que debemos seguir.
Básicamente el procedimiento en cada uno de los métodos es el mismo: crear una instancia del wrapper del argumento, con el valor de dicho argumento, y luego solicitar el tipo de dato primitivo a retornar por el método de conversión.

final class Cast
{
	/*float a int*/
	public static int toInt(float f)
	{
		int i;
		i = Float.valueOf(f).intValue();
		return i;
	}
	/*double a int*/
	public static int toInt(double d)
	{
		int i;
		i = Double.valueOf(d).intValue();
		return i;
	}
	/*int a double*/
	public static double toDouble(int i)
	{
		double d;
		d = Integer.valueOf(i).doubleValue();
		return d;
	}
	/*String a double*/
	public static double toDouble(String s)
	{
		double d;
		d = Double.valueOf(s).doubleValue();
		return d;
	}
	/*float a String*/
	public static String toString(float f)
	{
		String s;
		s = Float.valueOf(f).toString();
		return s;
	}
}

Si bien esta clase está incompleta (le faltarían muchos metodos más para ampliar su utilidad) podemos hacer un ejemplo y ver como trabaja.

int i;
float f;
double d;			
String s = "9.543";			
d = Cast.toDouble(s); // d = 9.543
i = Cast.toInt(d); // i = 9
f = i; // f = 9.0
s = Cast.toString(f); // s = "9.0"

En conclusión estas clases son muy valiosas, aprender a utilizarlas es muy facil (sus métodos son muy similares, recuerden que derivan de Number) y nos proveen de la funcionalidad extra que se necesita.
Para mayor información sobre los diferentes métodos de cada wrapper, referirse a la documentación.

Página 01 de 01 | Versión completa