Tipos de wrapper em detalhes

1. Integeraula

Integertambém é bom porque é uma classe, o que significa que pode ter campos e métodos. E, claro, tem eles. Muitos deles - dezenas deles. Aqui vamos considerar os mais básicos.

A Integerclasse possui dois campos que contém os valores máximo e mínimo possíveis do inttipo:

Integer.MAX_VALUE

Integer.MIN_VALUE

Às vezes, você deseja atribuir o menor ou o maior intvalor possível a uma variável. Para evitar sobrecarregar seu código com constantes incompreensíveis, você pode escrever isso claramente da seguinte maneira:

int min = Integer.MIN_VALUE;

min == 0x80000000

A Integerclasse também tem alguns métodos interessantes. Aqui estão eles:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

Você encontrou anteriormente o Integer.parseInt()método estático. Vamos relembrar como funciona:

int name = Integer.parseInt(string);

Se uma string contendo um número (somente dígitos) for passada para o parseInt()método, ele analisará a string e retornará o número que ela contém.

O resto dos métodos também são úteis. Por exemplo, alguns deles podem converter um número passado em uma string contendo a representação binária, octal ou hexadecimal do número.

2. Doubleclasse

Em geral, a Doubleclasse é semelhante à Integerclasse, apenas envolve um doubleem vez de um int. Também possui campos e métodos que nos interessarão. Considere alguns deles:

A Doubleclasse tem seis campos interessantes:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

Infinidade

Se você dividir -1.0por 0.0, obterá infinito negativo. Se você dividir 1.0por 0.0, obterá infinito positivo. Você não apenas pode dividir a doublepor zero, mas também pode usá-lo para armazenar o resultado dessas operações.

Expoente de umdouble

Entender o expoente é fácil. Internamente, um duplo consiste em uma mantissa e um expoente. Mas aqui o valor do expoente não é , mas . Assim, se o expoente aumentar em , o valor total do número dobrará.10x2x1

MIN_EXPONENT == -1024, o que significa , que é aproximadamente igual a2-102410-308

E claro, a Doubleclasse tem métodos interessantes:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Curiosamente, existe um isInfinite()método que retorna truese o número passado for infinito positivo ou negativo.

O isNaN()método é semelhante — verifica se o número passado é NaN( Not-a-Number , uma constante especial que indica um valor indefinido).

3. Characterclasse

A Characterclasse é interessante principalmente por seu grande número de métodos utilitários estáticos que permitem verificar se os caracteres pertencem a várias categorias.

Exemplos

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)

Uma característica desses métodos é que eles funcionam com todos os alfabetos conhecidos: os algarismos arábicos são classificados como dígitos, etc.

4. Booleanclasse

O Booleantipo é praticamente o mesmo que o booleantipo. As diferenças são mínimas.

Abaixo mostramos uma versão simplificada da Booleanclasse:

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);
   }
}

O Booleantipo tem duas constantes (dois campos):

Boolean.TRUE

true

Boolean.FALSE

false

Você pode trabalhar com eles da mesma forma que trabalha com o 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)

Autoboxing funciona muito bem aqui. Isso significa que você pode usar esse tipo da mesma forma que o booleantipo - não há armadilhas a serem observadas.

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();

E aqui uma comparação dos tipos booleane 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)

Se você realmente precisa de um Booleanobjeto independente, então você precisa criá-lo explicitamente:

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)

Mais um exemplo, onde usaremos um Booleandentro de um if:

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

Isso irá compilar, mas não vai funcionar!

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

5. Cacheando valores durante o autoboxing

Existem algumas armadilhas relacionadas aos tipos de wrapper de número inteiro.

Como você já sabe, se compararmos an inte an Integer, o Integeré convertido em an int:

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

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

Se você comparar dois Integerobjetos entre si, eles não serão convertidos em 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 == ce , mas , porque quando comparamos e estamos comparando referências. O que é essencialmente o que esperaríamos.b == ca != bab

Surpresa

Mas se substituirmos 500por 100, obteremos um 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

A questão aqui é que um novo Integerobjeto nem sempre é realmente criado durante o autoboxing . Os objetos são armazenados em cache para valores -128por meio de 127inclusive.

A Integerclasse possui um array oculto que armazena objetos: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Se você escrever Integer x = 128, o processo de autoboxing criará um novo objeto, mas se você escrever Integer x = 127, o processo de autoboxing recuperará o objeto existente do cache (do array).

Se você não deseja que o Integerobjeto venha do cache, deverá criá-lo explicitamente escrevendo:Integer x = new Integer(127);

Todos os tipos de wrapper têm esse cache: Integer, Long, Byte, Short, Boolean. Para o Booleantipo, seus valores TRUEe FALSEsão constantes, portanto, também são essencialmente armazenados em cache.