Tipos Primitivos vs. Tipos Primitivos Empacotados

• Tipos Primitivos: int, double, boolean, etc.
• Tipos Primitivos Empacotados: Integer, Double, Boolean, etc.
• O Java possui um sistema de tipos duplo: tipos primitivos e tipos de referência (objetos).
• Cada tipo primitivo tem um correspondente empacotado (wrapper class).

Diferenças Principais

• Identidade vs. Valor:
  Primitivos: Não possuem identidade; dois primitivos com o mesmo valor são sempre iguais.
  Empacotados: São objetos e possuem identidade; dois objetos podem ter o mesmo valor, mas identidades diferentes.

• Valores Nulos:
  Primitivos: Sempre têm um valor padrão (por exemplo, 0 para int).
  Empacotados: Podem ser null, o que pode levar a exceções NullPointerException se não tratados adequadamente.

• Desempenho:
  Primitivos: Mais eficientes em termos de tempo e espaço.
  Empacotados: Introduzem overhead devido à criação de objetos adicionais.

Problemas Comuns ao Misturar Primitivos e Empacotados

• 1. Comparação de Identidade em Vez de Valor
• Ao comparar objetos empacotados usando ==, você está comparando referências de objeto, não os valores. Isso pode levar a resultados inesperados.

Exemplo Problemático:

Comparator naturalOrder = (i, j) -> (i 



Problema: A comparação i == j compara referências, não valores.

Comportamento Incorreto: naturalOrder.compare(new Integer(42), new Integer(42)) retorna 1 em vez de 0.

Solução:

Use o método compareTo ou métodos utilitários da classe Integer.


Comparator naturalOrder = Integer::compare;





Ou, corrigindo o comparador original:


Comparator naturalOrder = (iBoxed, jBoxed) -> {
    int i = iBoxed;
    int j = jBoxed;
    return (i 



2. Autounboxing e NullPointerException

Ao usar tipos empacotados que podem ser null, o autounboxing pode lançar exceções se o objeto for null.

Exemplo Problemático:


Integer i = null;
if (i == 42) {
    System.out.println("Inacreditável");
}





Problema: i é null; ao comparar com 42, ocorre autounboxing de null, resultando em NullPointerException.
Solução: Use tipos primitivos quando possível.


int i = 0;
if (i == 42) {
    System.out.println("Inacreditável");
}





3. Desempenho Degradado devido ao Autoboxing/Unboxing

O uso inadvertido de tipos empacotados em operações intensivas pode causar degradação de desempenho devido ao autoboxing e criação desnecessária de objetos.

Exemplo Problemático:


Long sum = 0L;
for (long i = 0; i 



Problema: sum é um Long empacotado; em cada iteração, ocorre autoboxing/desempacotamento.

Impacto: Código muito mais lento e uso excessivo de memória.
Solução:

Use tipos primitivos para variáveis locais em operações intensivas.


long sum = 0L;
for (long i = 0; i 



Quando Usar Tipos Empacotados

Coleções: Não é possível usar tipos primitivos em coleções genéricas (por exemplo, List).
Parâmetros Genéricos: Tipos genéricos não suportam tipos primitivos (por exemplo, ThreadLocal).
APIs que Requerem Objetos: Certas APIs exigem objetos em vez de tipos primitivos.
Boas Práticas

Prefira Tipos Primitivos: Sempre que possível, use tipos primitivos para simplicidade e eficiência.
Cuidado com o Autoboxing/Unboxing: O autoboxing reduz a verbosidade, mas pode introduzir erros sutis.
Evite Comparações com == em Empacotados: Use métodos como equals() ou compare os valores desempacotados.
Verifique Nulos: Ao trabalhar com tipos empacotados, esteja ciente de que podem ser null e causem NullPointerException.
Resumo
Tipos Primitivos:

Mais simples e rápidos.

Não podem ser null.

Não têm identidade (apenas valor).

Tipos Empacotados:

Necessários para uso em coleções e APIs genéricas.

Podem ser null.

Têm identidade de objeto.