Wrappers

Introdução

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: Esses métodos permitem a conversão de strings em tipos primitivos equivalentes. Por exemplo, o método parseInt() pode ser usado para converter uma string em um inteiro, e o método parseDouble() pode ser usado para converter uma string em um número de ponto flutuante. Esses métodos são úteis quando você precisa ler dados de uma fonte externa e convertê-los em tipos primitivos.

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

• Métodos de conversão: Esses métodos permitem a conversão de tipos primitivos para objetos e vice-versa. Por exemplo, o método valueOf() pode ser usado para converter um tipo primitivo em um objeto equivalente, enquanto o método intValue() pode ser usado para converter um objeto Integer em um inteiro.

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

Integer obj = new Integer(100);
int i = obj.intValue();
System.out.println(i); // 100

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

• Métodos de comparação: Esses métodos permitem comparar objetos Wrappers para verificar se são iguais ou se um é maior ou menor que o outro. Por exemplo, o método equals() pode ser usado para comparar dois objetos Integer para verificar se eles são iguais, enquanto o método compareTo() pode ser usado para comparar dois objetos de forma mais geral.

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

• Métodos de informação: Esses métodos fornecem informações sobre o tipo Wrapper, como o valor mínimo e máximo que pode ser representado. Por exemplo, o método maxValue() pode ser usado para obter o valor máximo representável para um tipo Wrapper específico, enquanto o método minValue() pode ser usado para obter o valor mínimo representável.

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