Wrappers

Os tipos primitivos não são objetos, mas às vezes é necessário trabalhar com eles como se fossem. Por exemplo, quando você precisa passar um valor primitivo como um parâmetro de um método, você precisa converter o valor primitivo em um objeto. Nesse caso, você pode usar os tipos wrappers.

Os tipos wrappers são classes que representam os tipos primitivos. Eles são imutáveis, o que significa que uma vez criado um objeto wrapper, seu valor não pode ser alterado para garantir a segurança.

Os seguintes tipos Wrappers estão disponíveis em Java:

Integer     (int)
Long        (long)
Float       (float)
Double      (double)
Short       (short)
Byte        (byte)
Boolean     (boolean)
Character   (char)

Conversão de Tipos

A conversão de tipos é necessária quando você deseja armazenar um valor de um tipo de dado em uma variável de outro tipo. Por exemplo, você pode armazenar um valor int em uma variável de tipo double porque o tipo double pode armazenar valores inteiros e fracionários.

Conversão de Tipos Explícita: é feita por meio de uma expressão de conversão de tipos. Ela é necessária quando você deseja converter um valor de um tipo de dado em outro que não seja compatível com o dado original.

// conversão explicita
double d = 100.0;
int i = (double) d;
System.out.println(i); // 100

Conversão de Tipos Implícita: é feita automaticamente pelo compilador da linguagem não sendo necessário nenhum tipo de demarcação.

// conversão implícita
double d = 100.0;
int i = d;
System.out.println(i); // 100

Conversão entre tipos

double d = 3.75;
int i =  d;
System.out.println(i); // ???

Métodos Wrapper

Os tipos Wrappers em Java oferecem uma série de métodos úteis para a manipulação de tipos primitivos. Alguns desses métodos incluem:

• Métodos de parsing: permitem a conversão de strings em tipos primitivos equivalentes. Por exemplo, parseInt() converte uma string em inteiro, e parseDouble() converte uma string em número de ponto flutuante. Esses métodos são úteis quando você precisa ler dados de uma fonte externa e transformá-los em tipos primitivos.

String num = "100";
int i = Integer.parseInt(num);
System.out.println(i); // 100

• Métodos de conversão: permitem converter tipos primitivos para objetos e vice-versa.
  • Para criar um wrapper a partir de um primitivo, use valueOf().
  • Para obter o valor primitivo de um wrapper, use métodos como intValue(), doubleValue(), etc.

String num = "100";
Integer obj = Integer.valueOf(num);
System.out.println(obj); // 100

Integer obj2 = Integer.valueOf(100);
int i2 = obj2.intValue();
System.out.println(i2); // 100

Em Java, muitos métodos possuem sobrecarga. Isso significa que métodos com o mesmo nome podem ter diferentes tipos ou números de parâmetros, permitindo ao compilador escolher a versão correta a ser chamada.

Integer.valueOf(int i)
Integer.valueOf(String s)

• Métodos de comparação: permitem comparar objetos Wrappers para verificar igualdade ou ordem.
  • equals() compara se dois objetos possuem o mesmo valor.
  • compareTo() compara dois objetos, retornando 0 se forem iguais, número negativo se o primeiro for menor, e número positivo se o primeiro for maior.

Integer obj1 = Integer.valueOf(100);
Integer obj2 = Integer.valueOf(100);
System.out.println(obj1.equals(obj2));   // true
System.out.println(obj1.compareTo(obj2)); // 0

• Métodos de informação: fornecem informações sobre o tipo Wrapper, como os valores mínimo e máximo representáveis, acessados através das constantes MIN_VALUE e MAX_VALUE.

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648

Wrapper vs boolean

Embora o uso de classes Wrapper seja recomendado na maioria dos casos, para valores lógicos o tipo primitivo boolean ainda é mais aconselhável. Isso ocorre porque o boolean não aceita null, evitando estados indefinidos e possíveis erros em tempo de execução. Já a classe Boolean pode assumir null, o que exige cuidados adicionais no código. Por esse motivo, sempre que não houver necessidade de trabalhar com objetos ou coleções, o uso do tipo primitivo boolean é a opção mais segura e simples.