Quando usar primitivo vs classe em Java?

Eu vejo que Java tem booleano (classe) vs booleano (primitivo). Da mesma forma, há um número inteiro (classe) vs int (primitivo). Qual é a melhor prática sobre quando usar a versão primitiva versus a classe? Eu basicamente sempre deveria estar usando a versão da classe, a menos que eu tenha um motivo específico (de desempenho?) Para não? Qual é a maneira mais comum e aceita de usar cada um?

No item 5, do Java efetivo, Joshua Bloch diz

A lição é clara: prefira primitivas a primitivas in a box e cuidado com as caixas automáticas não intencionais .

Um bom uso para classes é ao usá-las como tipos genéricos (incluindo classes de coleção, como listas e mapas) ou quando você deseja transformá-las em outro tipo sem conversão implícita (por exemplo, Integerclasse possui métodos doubleValue()ou byteValue().

Edit: A razão de Joshua Bloch é:

// Hideously slow program! Can you spot the object creation?
public static void main(String[] args) {
    Long sum = 0L;
    for (long i = 0; i < Integer.MAX_VALUE; i++) {
         sum += i;
    }
    System.out.println(sum);
}

Este programa obtém a resposta certa, mas é muito mais lento do que deveria, devido a um erro tipográfico de um caractere. A variável sumé declarada como um em Longvez de a long, o que significa que o programa constrói cerca de 2 ^ 31 Longinstâncias desnecessárias (aproximadamente uma para cada vez que long ié adicionada à Long sum). Alterar a declaração da soma de Longpara longreduz o tempo de execução de 43 segundos para 6,8 segundos na minha máquina.

A prática padrão é seguir as primitivas, a menos que você esteja lidando com genéricos (certifique-se de estar ciente de caixas automáticas e unboxing !).

Existem várias boas razões para seguir a convenção:

1. Você evita erros simples:

Existem alguns casos sutis e não intuitivos, que geralmente envolvem iniciantes. Até mesmo codificadores experientes escorregam e cometem esses erros algumas vezes (espero que isso seja seguido por palavrões quando eles depurarem o código e encontrarem o erro!).

O erro mais comum é usar em a == bvez de a.equals(b). As pessoas estão acostumadas a fazer uso de a == bprimitivas, portanto isso é fácil quando você está usando os wrappers Object.

Integer a = new Integer(2);
Integer b = new Integer(2);
if (a == b) { // Should be a.equals(b)
    // This never gets executed.
}
Integer c = Integer.valueOf(2);
Integer d = Integer.valueOf(2);
if (c == d) { // Should be a.equals(b), but happens to work with these particular values!
    // This will get executed
}
Integer e = 1000;
Integer f = 1000;
if (e == f) { // Should be a.equals(b)
    // Whether this gets executed depends on which compiler you use!
}

2. Legibilidade:

Considere os dois exemplos a seguir. A maioria das pessoas diria que o segundo é mais legível.

Integer a = 2;
Integer b = 2;
if (!a.equals(b)) {
    // ...
}
int c = 2;
int d = 2;
if (c != d) {
    // ...
}

3. Desempenho:

O fato é que é mais lento usar os wrappers Object para primitivas do que apenas usar as primitivas. Você está adicionando o custo da instanciação de objetos, chamadas de métodos etc. às coisas que usa em todo o lugar .

A citação de Knuth "... digamos cerca de 97% do tempo: a otimização prematura é a raiz de todo mal" não se aplica aqui. Ele estava falando sobre otimizações que tornam o código (ou sistema) mais complicado - se você concorda com o ponto 2, essa é uma otimização que torna o código menos complicado!

4. É a convenção:

Se você fizer escolhas estilísticas diferentes para 99% dos outros programadores Java, existem duas desvantagens:

• Você encontrará o código de outras pessoas mais difícil de ler. 99% dos exemplos / tutoriais / etc lá fora usarão primitivos. Sempre que você ler um, terá a sobrecarga cognitiva extra de pensar em como ficaria no estilo com o qual está acostumado.
• Outras pessoas acharão seu código mais difícil de ler. Sempre que você faz perguntas no Stack Overflow, você precisa filtrar as respostas / comentários, perguntando "por que você não está usando primitivas?". Se você não acredita em mim, basta olhar para as batalhas que as pessoas enfrentam, como posicionamento de colchetes, que nem sequer afeta o código gerado!

Normalmente eu listaria alguns contrapontos, mas honestamente não consigo pensar em nenhuma boa razão para não ir à convenção aqui!

Normalmente eu vou com os primitivos. No entanto, uma peculiaridade de usar classes como Integere Booleané a possibilidade de atribuir nulla essas variáveis. Claro, isso significa que você tem que fazer nullverificações o tempo todo, mas ainda melhor para obter um NullPointerException do que ter erros de lógica, devido ao uso de alguns intou booleanvariável que não foi inicializado corretamente.

Obviamente, desde o Java 8, você pode (e provavelmente deveria) ir um passo além e, em vez de, por exemplo, Integerusar Optional<Integer>para variáveis ​​que podem ou não ter um valor.

Além disso, apresenta a possibilidade de usar nullpara atribuir a essas variáveis ​​um valor " desconhecido " ou " curinga ". Isso pode ser útil em algumas situações, por exemplo, na lógica ternária . Ou você pode verificar se um determinado objeto corresponde a algum modelo; nesse caso, você pode usar nullpara aquelas variáveis ​​no modelo que podem ter qualquer valor no objeto.

Nas palavras dos leigos:

Você usa os wrappers quando precisa adicionar itens às coleções.

As coleções não podem conter primitivas.

O Java apresenta a autoboxing como m3th0dman apontou. Pense no nível mais baixo possível e você verá que a autoboxing (entrada ou saída) de um valor primitivo implicará ciclos de relógio gastos em algumas tarefas que você não precisa se estiver trabalhando com tipos de dados nativos em seu aplicativo.

Como regra geral, você deve tentar usar tipos de dados nativos sempre que possível.