Curso de Java. Objetos envoltorio. Clase Number.
A lo largo del curso de Java hemos empleado en sentencias con cálculos numéricos variables de tipo primitivo, como puede ser int, float, etc. En Java existen Clases que heredan de la clase Number del paquete java.lang (incluido por defecto en Java) y que sirven de envoltorio a los tipos primitivos ya conocidos.
Estas clases aparte de proporcionar métodos útiles, sirven en la conversión a objetos de un tipo primitivo y viceversa, acción que en determinados contextos puede ser realizada por el compilador de java de forma automática, aunque usando estas clases el programador puede realizarlo de forma explícita.
Subclases de la clase Number.
En la tabla siguiente se exponen las clases principales que heredan de la clase Number:
| Clase | Tipo primitivo. |
|---|---|
| Byte | byte. |
| Double | double. |
| Float | float. |
| Integer | int. |
| Short | short. |
| Long | long |
Métodos de las subclases de Number.
Hay distintos tipos de métodos comunes a todos los tipos primitivos que nos permiten realizar multitud de acciones con los distintos objetos envoltorios de tipos primitivo.
Métodos que retornan el tipo primitivo del objeto envoltorio.
1 2 3 4 5 6 | byte byteValue() short shortValue() int intValue() long longValue() float floatValue() double doubleValue() |
Métodos que comparan valores de objetos.
1 2 3 4 5 6 | int compareTo(Byte B) int compareTo(Double D) int compareTo(Float F) int compareTo(Integer I) int compareTo(Long L) int compareTo(Short S) |
Estos métodos retornan un entero que indica el resultado de la comparación. Los resultados pueden ser:
- > 0 —— El valor del argumento es menor.
- = 0 —— Son iguales.
- < 0 —— El valor del argumento es Mayor.
Métodos que comparan si dos objetos son iguales en tipo y valor.
1 | boolean equals(Object obj) |
Ejemplo de uso de los métodos compareTo() y equals().
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | package objetosenvoltorio; /** * * @author codesitio */ public class ObjetosEnvoltorio { /** * @param args the command line arguments */ public static void main(String[] args) { //Declaración de variables de tipo primitivo byte num, num2; int resul; boolean esCierto; //Inicializamos variables num=20; num2=30; //Declaramos los objetos envoltorio Byte objByte = new Byte(num); Byte objByte2 = new Byte(num2); Byte objByte3 = new Byte(num2); Integer objInt = new Integer(20); //Comparación de valores de los objetos resul = objByte.compareTo(objByte2); if(resul < 0){ System.out.println("El objeto objByte es menor que objByte2"); }else if(resul > 0){ System.out.println("El objeto objByte es mayor que objByte2"); }else{ System.out.println("Ambos objetos tienen mismo valor"); } //igualdad de objetos esCierto = objByte.equals(objByte2); if(esCierto){ System.out.println("El objByte y objByte2 son iguales"); }else{ System.out.println("El objByte y objByte2 son objetos distintos pese a ser mismo tipo"); } //igualdad de objetos esCierto = objByte2.equals(objByte3); if(esCierto){ System.out.println("El objByte2 y objByte3 son objetos de mismo tipo y valor"); }else{ System.out.println("El objByte2 y objByte3 son objetos de mismo tipo pero distinto valor"); } System.out.println(); //Comparación de valores de los objetos. Observe la conversión de Integer a Byte resul = objByte.compareTo(objInt.byteValue()); if(resul < 0){ System.out.println("El objeto objByte es menor que objInt"); }else if(resul > 0){ System.out.println("El objeto objByte es mayor que objInt"); }else{ System.out.println("El objeto objByte tiene el mismo valor que objInt"); } //igualdad de objetos esCierto = objByte.equals(objInt); if(esCierto){ System.out.println("Ambos objetos son iguales en tipo y valor"); }else{ System.out.println("Son objetos distintos en tipo o valor"); } } } |
Cabe destacar esta sentencia:
1 | resul = objByte.compareTo(objInt.byteValue()); |
En ella vemos como podemos realizar la transformación entre distintos tipos usando el método correspondiente, en este caso el método byteValue.
Por Consola tendremos los siguientes resultados:
Queda claro que dos objetos envoltorio son distintos si es distinto su valor o su tipo de dato y que el método compareTo es adecuado cuando se trata de comparar los valores de los objetos, no el objeto en si. En este segundo caso lo adecuado es usar el método equals.
Métodos que convierten números enteros en cadenas y viceversa.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | //Acepta String decimal, octal y hexadecimal static Integer decode(String s) //Sólo acepta String en decimal static int parseInt(String s) //en radix indicamos si es decimal (10), binario (2), //Octal (8) o hexadecimal (16) static int parseInt(String s, int radix) //Retorna un String del objeto Entero. String toString() //Retorna un String del primitivo entero pasado como argumentó static String toString(int i) //Devuelve un objeto Integer del primitivo entero pasado. static Integer valueOf(int i) //Retorna un objeto Integer con el valor especificado en String static Integer valueOf(String s) //Retorna un Integer en base a radix (2,8,10,16) static Integer valueOf(String s, int radix) |
Ejemplos de uso del método decode()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | package stringnum; /** * * @author codesitio.com */ public class StringNum { public static void main(String[] args) { String cadena ="200"; Integer objInt = 0; int num; /* * * Método static Integer decode(String s) * Acepta String decimal, octal y hexadecimal. * */ //Cadena en Decimal. num = objInt.decode(cadena); num ++; System.out.println(num); //resultado: 201 //Cadena en hexadecimal. cadena="#C8"; num = objInt.decode(cadena); num ++; System.out.println(num); //resultado: 201 //Cadena en Octal. cadena="0310"; num = objInt.decode(cadena); num ++; System.out.println(num); //resultado: 201 } } |
Ejemplos de uso del método parseInt()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | package stringnum2; /** * * @author codesitio.com */ public class StringNum2 { /** * @param args the command line arguments */ public static void main(String[] args) { String cadena ="100"; Integer objInt = 0; int num; /* * Solo acepta String decimal * * static int parseInt(String s) * */ num = objInt.parseInt(cadena); num++; System.out.println(num); //resultado: 101 /* * en radix indicamos si es decimal (10), binario (2), * Octal (8) o hexadecimal (16) * * static int parseInt(String s, int radix) * */ //Cadena en binario num = objInt.parseInt(cadena, 2); System.out.println(num); //resultado: 4 //Cadena en Octal num = objInt.parseInt(cadena, 8); System.out.println(num); //resultado: 64 //Cadena en hexadecimal num = objInt.parseInt(cadena, 16); System.out.println(num); //resultado: 256 } } |
Viendo como se aplican estos métodos, utilizar el método toString() y el método valueOf() no deben entrañar mayor dificultad.