Diferença entre int e Integer em Java
9 minutos de leitura
Autor(a)
mario-alvial
Inscreva-se em nossa Newsletter
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
9 minutos de leitura
Autor(a)
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Estou trabalhando em um sistema para uma loja de peças de carro online como revisor de código, ou seja, revisamos o código dos programadores desse sistema. Em uma das revisão nos deparamos com a seguinte classe:
public class Cliente {
private int idade;
private String nome;
}
Nessa classe, guardamos o nome e a idade de cada cliente, mas o atributo idade é opcional, o cliente não necessariamente precisa nos dar essa informação. E aí, vocês estão vendo algo estranho nessa classe?
Para ficar mais fácil de visualizar, vamos instanciar essa classe e imprimir seus valores:
public static void main(String[] args) {
Cliente cliente = new Cliente();
System.out.println(cliente.getIdade());
System.out.println(cliente.getNome());
}
Se executarmos este código, teremos o seguinte resultado:
0
null
Agora que vem a parte estranha. Por que a idade esta com valor 0? Eu não preenchi essa informação. E outra, idade “0”? Isso não existe.
Vamos entender o motivo disso. Se voltarmos para a nossa classe Cliente podemos perceber que o atributo idade é do tipo int. Esse tipo, por sua vez, é considerado um tipo primitivo, que nada mais é do que um tipo que não representa uma classe.
Quando declaramos um atributo (membro da classe) como sendo de algum tipo primitivo, esse atributo tem um valor padrão. No nosso caso, o padrão de int é 0, mas isso só vale para atributos de uma classe.
Não é isso que queremos, não é mesmo? Caso o cliente cadastre a idade, queremos salvar a idade, caso contrário, não queremos salvar nenhum valor, ou seja, queremos salvar o atributo idade como vazio.
Agora, se pensarmos, todos os tipos não primitivos são, por padrão, nulos caso não seja atribuído nenhum valor a eles.
Pensando nisso, a linguagem Java nos disponibilizou o que chamamos de Wrapper, que, basicamente, é uma classe que representa um tipo primitivo. Por exemplo o Wrapper de int é o Integer. Perceba que o Wrapper começa com letra maiúscula, ele segue a mesma nomenclatura que qualquer outra classe, pois ele também é uma.
Mas o que eu ganho usando esse Wrapper?
Boa pergunta. Bom, a maior vantagem é conseguir atribuir nulo. Mas com grandes poderes, vem grandes responsabilidades, logo, cuidado para não atribuir valores nulos a rodo, pois seu código fica muito propenso a tomar NullPointerException.
Podemos falar também dos métodos que ganhamos, como agora estamos tipando nossa variável com uma classe, essa classe pode ter métodos que podemos usar para o nosso inteiro.
Para exemplificar vamos tentar ver os métodos disponíveis para idade:
Nenhum, pois tipo primitivo não é um objeto. Não é a instância de uma classe, logo não possui métodos. Agora vamos mudar o tipo de idade para Integer:
private Integer idade;
E tentar, do mesmo jeito, ver os métodos disponíveis:
Além dos métodos, com Integer, você também faz com que seu atributo possa ser adicionado a uma coleção, você pode ter um List por exemplo. Com tipos primitivos como int isso não é possível.
Nossa, quanta coisa! Vou mudar tudo para Integer.
Não, não faça isso! Pelo menos não sem entender algumas desvantagens que os Wrappers possuem em relação ao seu tipo primitivo correspondente.
Em primeiro lugar, os métodos mostrados acima não são muito usados. Além desses métodos temos os métodos estáticos, que são os mais usados das classes wrappers, mas também não são muito usados no dia a dia, talvez com exceção do método valueOf(), que transforma o parâmetro para o wrapper que chamou este método.
Além disso, caso seja realmente necessário usar um dos métodos não estáticos, a forma de transformar um int em Integer é trivial.
Para conseguir essa transformação podemos usar exatamente esse método valueOf():
int tipoPrimitivo = 0;
Integer tipoPrimitivoTransformadoEmWrapper = Integer.valueOf(tipoPrimitivo);
Ou então, como Integer é uma classe não abstrata, podemos instânciá-la:
int tipoPrimitivo = 0;
Integer tipoPrimitivoTransformadoEmWrapper = new Integer(tipoPrimitivo);
Mas, poxa, é um pouco chato o jeito que é feita essa conversão né? Ter que ficar dando new ou ficar chamando o método estático para conseguir um Integer...
Vendo a regularidade que a conversão de tipo primitivo para Wrapper e vice-versa ocorria, foi desenvolvido para o Java 5 duas funcionalidades, o autoboxing e o unboxing.
O autoboxing é um recurso que automaticamente converte tipos primitivos em seu wrapper equivalente. Por exemplo, vamos supor que eu queira transformar o atributo idade que está com o tipo int para uma nova variável do tipo Integer. Com o autoboxing eu poderia fazer dessa forma:
Integer idadeWrapper = idade;
E pronto, legal,né? “Por baixo dos panos” o compilador compila para o seguinte código:
Integer idadeWrapper = Integer.valueOf(idade);
E o unboxing é o inverso do autoboxing, ou seja, ele pega um wrapper e o transforma em seu tipo primitivo. Assim:
int idadePrimitivo = idadeWrapper;
E por baixo dos panos, temos o seguinte:
int idadePrimitivo = idadeWrapper.intValue();
Agora que entendemos melhor as diferenças entre int e Integer podemos acabar de revisar a classe Cliente. Como idade é um atributo opcional e com certeza não queremos que por padrão seja 0, vamos mudar o tipo dela de int para Integer. Ficando com a seguinte classe:
public class Cliente {
private Integer idade;
private String nome;
}
Faltou falar sobre uma coisa. E para operações matemáticas? O que é melhor usar? int ou Integer?
Para isso vamos criar um método para calcular o valor das parcelas das compras feitas na loja online. Nesse cálculo temos que seguir algumas regras:
Bom, podemos criar um método que recebe o valor total, o número de peças compradas, o número de parcelas e retorna um objeto do tipo GerenciadorDeVendas que recebe em seu construtor o valor da comissão do vendedor e o valor de cada parcela:
public GerenciadorDeVendas calculaVenda(double total, int numeroDePecas, int numeroDeParcelas){
}
Como o foco não é a operação em si, se fôssemos resolver esse método, poderíamos fazer da seguinte forma:
public GerenciadorDeVendas calculaVenda(double total, int numeroDePecas, int numeroDeParcelas){
if(numeroDePecas > 3){
total *= 0.90;
}
double comissao = total * 0.05;
double valorParcela = total / numeroDePecas;
return new GerenciadorDeVendas(comissao, valorParcela);
}
Agora vocês devem estar se perguntando porque eu usei tipos primitivos ao invés de Wrappers, né? Então, se os usássemos, estaríamos correndo o risco de receber algum valor nulo e quando operássemos sobre esse valor iríamos tomar um belo NullPointerException. Portanto, usando os tipos primitivos estamos evitando isso. No máximo teremos algum dos parâmetros com valor 0.
O segundo motivo é a questão da performance. Um Wrapper não deixa de ser uma classe e quando criamos um, estamos, de fato, instanciando um objeto, logo estamos reservando um espaço da memória para ele.
Pensando nisso, imagine a quantidade de objetos que teríamos para resolver essa operação matemática, simplesmente não vale a pena, pois tudo que precisamos é trabalhar com valores e nesse aspecto o tipo primitivo consegue suprir essa necessidade.
Outra ponto importante é que o Java possui um cache para números baixos, então por exemplo:
public static void main(String[] args) {
Integer i1 = 500;
Integer i2 = 500;
if(i1 == i2){
System.out.println(true);
}else{
System.out.println(false);
}
}
Esse código imprime false pois Integer é uma classe, logo i1 e i2 são objetos dela e as suas referências estão alocadas em espaços diferentes na memória. Quando usamos o operador == em objetos, ele compara as referências e não os valores. Isto é, como os objetos não estão apontando para a mesma referência temos como resultado false.
Agora, olhe este código:
public static void main(String[] args) {
Integer i1 = 127;
Integer i2 = 127;
if(i1 == i2){
System.out.println(true);
}else{
System.out.println(false);
}
}
Este, por sua vez, imprime true.
Mas você acabou de falar que comparar objetos usando o operador
==resulta emfalse
O Java, para economizar memória, possui um cache de alguns objetos, incluindo o Integer. Dependendo de como é feita a utilização, se os objetos do tipo Integer tiverem o valor entre -128 até 127 o Java consegue fazer um boxing dos valores e os reutilizar.
Logo, efetuar comparações usando o operador “==” com Wrappers é arriscado, pois além de compararmos referências ao invés dos valores podemos cair nesse caso, onde é usado o cache e resultar em uma comparação inesperada.
Duas soluções para isso são: Usar tipos primitivos para efetuar comparação usando “==” ou usar o método equals() que é o mais adequado para comparar objetos.
Wrappers, como o Integer, são úteis quando precisamos usar nossa variável em coleções ou queremos deixar algum atributo opcional, leia-se, com valor nulo. Já tipos primitivos são ótimos para quando não queremos nulo e para operações matemáticas, pois ocupam pouco espaço na memória, melhorando a performance da sua aplicação.
É isso aí, espero que você tenha conseguido entender a diferença entre int e Integer e quando vale a pena usar cada um. Já se enrolou alguma vez na hora de comparar um Wrapper?
Para entender mais sobre esses detalhes da linguagem, como o cache feito pelo Java e outras coisas relacionadas aos Wrappers, na Alura temos o Curso Certificação Java SE 8 Programmer I: Conteúdo além da prova, lá você encontra um capítulo inteiro sobre classes Wrappers e várias outras peculiaridades da linguagem e uma formação completa em JAVA
Avalie este artigo
