Tipos de envoltura en detalle

1. Integerclase

Integertambién es bueno porque es una clase, lo que significa que puede tener campos y métodos. Y, por supuesto, los tiene. Muchos de ellos, docenas de ellos. Aquí consideraremos los más básicos.

La Integerclase tiene dos campos que contienen los valores máximos y mínimos posibles del inttipo:

Integer.MAX_VALUE

Integer.MIN_VALUE

A veces desea asignar el intvalor más pequeño o más grande posible a una variable. Para evitar saturar su código con constantes incomprensibles, puede escribir esto muy claramente de la siguiente manera:

int min = Integer.MIN_VALUE;

min == 0x80000000

La Integerclase también tiene algunos métodos interesantes. Aquí están:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

Anteriormente se encontró con el Integer.parseInt()método estático. Recordemos cómo funciona:

int name = Integer.parseInt(string);

Si se pasa una cadena que contiene un número (solo dígitos) al parseInt()método, analizará la cadena y devolverá el número que contiene.

El resto de los métodos también son útiles. Por ejemplo, algunos de ellos pueden convertir un número pasado en una cadena que contiene la representación binaria, octal o hexadecimal del número.

2. Doubleclase

En general, la Doubleclase es similar a la Integerclase, solo que envuelve un doubleen lugar de un int. También tiene campos y métodos que nos serán de interés. Considere algunos de ellos:

La Doubleclase tiene seis campos interesantes:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

Infinidad

Si divides -1.0por 0.0, obtienes infinito negativo. Si divides 1.0por 0.0, obtienes infinito positivo. No solo puede dividir a doublepor cero, sino que también puede usarlo para almacenar el resultado de estas operaciones.

exponente de undouble

Comprender el exponente es fácil. Internamente, un doble consta de una mantisa y un exponente. Pero aquí el valor del exponente no es , sino . Por lo tanto, si el exponente aumenta en , el valor total del número se duplicará.10x2x1

MIN_EXPONENT == -1024, lo que significa , que es aproximadamente igual a2-102410-308

Y por supuesto, la Doubleclase tiene métodos interesantes:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Curiosamente, hay un isInfinite()método que devuelve truesi el número pasado es infinito positivo o negativo.

El isNaN()método es similar: verifica si el número pasado es NaN( Not-a-Number , una constante especial que indica un valor indefinido).

3. Characterclase

La Characterclase es interesante principalmente por su gran cantidad de métodos de utilidad estáticos que le permiten verificar si los caracteres pertenecen a varias categorías.

Ejemplos

Character.isAlphabetic(int)

Character.isLetter(char)

Character.isDigit(char)

Character.isSpaceChar(char)

Character.isWhitespace(char)

Character.isLowerCase(char)

Character.isUpperCase(char)

Character.toLowerCase(char)

Character.toUpperCase(char)

Una característica de estos métodos es que funcionan con todos los alfabetos conocidos: los números arábigos se clasifican como dígitos, etc.

4. Booleanclase

El Booleantipo es prácticamente el mismo que el booleantipo. Las diferencias son mínimas.

A continuación mostramos una versión simplificada de la Booleanclase:

class Boolean
{
   public static final Boolean TRUE = new Boolean(true);
   public static final Boolean FALSE = new Boolean(false);

   private final boolean value;

   public Boolean(boolean value)
   {
      this.value = value;
   }

   public boolean booleanValue()
   {
      return value;
   }

   public static Boolean valueOf(boolean value)
   {
      return (value ? TRUE : FALSE);
   }
}

El Booleantipo tiene dos constantes (dos campos):

Boolean.TRUE

true

Boolean.FALSE

false

Puede trabajar con ellos de la misma manera que trabaja con el booleantipo:

if (Boolean.TRUE)
{
}

Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean c = true;

Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)

El autoboxing funciona muy bien aquí. Eso significa que puede usar este tipo de la misma manera que el booleantipo: no hay trampas a las que prestar atención.

Boolean a = true;
Boolean b = true;
Boolean c = false;
boolean d = a;

Boolean a = Boolean.valueOf(true);
Boolean b = Boolean.valueOf(true);
Boolean c = Boolean.valueOf(false);
boolean d = a.booleanValue();

Y aquí una comparación de los tipos booleany Boolean:

boolean a = true;
Boolean b = true; // b will be equal to Boolean.TRUE
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // true (compared by reference, but they point to the same object)

Si realmente necesita un Booleanobjeto independiente, debe crearlo explícitamente:

boolean a = true;
Boolean b = new Boolean(true); // New Boolean object
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // false (compared by reference, and they point to different objects)

Un ejemplo más, donde usaremos un Booleaninterior de un if:

Boolean less = (2 < 3);
if (less)
{
   ...
}

¡Esto se compilará, pero no funcionará!

Boolean less = null;
if (less)
{
   ...
}

5. Almacenamiento en caché de valores durante el autoboxing

Hay algunas trampas relacionadas con los tipos de envoltura de enteros.

Como ya sabes, si comparamos an inty an Integer, el Integerse convierte en un int:

int a = 5;
Integer b = 5;
if (a == b)
{
   ...
}

int a = 5;
Integer b = Integer.valueOf(5);
if (a == b.intValue())
{
   ...
}

Si compara dos Integerobjetos entre sí, no se convierten en ints:

Integer a = 500;
Integer b = 500;
int c = 500;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

false
true
true

a == cy , pero , porque cuando comparamos y estamos comparando referencias. Que es esencialmente lo que esperaríamos.b == ca != bab

Sorpresa

Pero si reemplazamos 500con 100, obtenemos un resultado completamente diferente:

Integer a = 100;
Integer b = 100;
int c = 100;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

true
true
true

El problema aquí es que un nuevo Integerobjeto no siempre se crea realmente durante el autoboxeo . Los objetos se almacenan en caché para valores -128hasta 127inclusive.

La Integerclase tiene una matriz oculta que almacena objetos: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Si escribe Integer x = 128, el proceso de autoboxing crea un nuevo objeto, pero si escribe Integer x = 127, el proceso de autoboxing recupera el objeto existente de la memoria caché (de la matriz).

Si no desea que el Integerobjeto provenga del caché, deberá crearlo explícitamente escribiendo:Integer x = new Integer(127);

Todos los tipos de contenedor tienen un caché de este tipo: Integer, Long, Byte, Short, Boolean. Para el Booleantipo, sus valores TRUEy FALSEson constantes, por lo que también se almacenan esencialmente en caché.