Java Academy · Aula

Tipos Primitivos versus Tipos Envoltórios

Integer, Double, Boolean e outros

Tipos Primitivos versus Tipos Envoltórios é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Dois mundos de valores

Java possui tipos primitivos, como int, double e boolean, que armazenam valores brutos diretamente. Ele também possui classes encapsuladoras, como Integer, Double e Boolean, que envolvem esses valores em objetos.

Os tipos primitivos são rápidos e leves. Os encapsuladores são objetos completos que podem existir em coleções e podem ser null.

Os oito tipos primitivos

Java define exatamente oito tipos primitivos:

byte, short, int, long para números inteiros
float, double para números decimais
char para um único caractere
boolean para verdadeiro/falso

Cada um possui uma classe encapsuladora correspondente no pacote java.lang.

Nomes correspondentes dos encapsuladores

Na maioria dos casos, basta colocar a inicial do tipo primitivo em maiúscula para obter o nome do encapsulador, mas há duas exceções:

int se torna Integer
char se torna Caractere
boolean se torna Boolean, double se torna Double, e assim por diante

Vamos exibir alguns encapsuladores.

public class Main {
    public static void main(String[] args) {
        Integer count = 42;
        Double price = 9.99;
        Boolean active = true;
        Character grade = 'A';
        System.out.println(count);
        System.out.println(price);
        System.out.println(active);
        System.out.println(grade);
    }
}

Encapsuladores são objetos

Um tipo primitivo armazena um valor. Um encapsulador é uma referência de objeto, portanto pode apontar para lugar nenhum usando null.

Isso torna os encapsuladores úteis quando um valor pode estar ausente, como em uma coluna de banco de dados que permite NULL.

public class Main {
    public static void main(String[] args) {
        Integer missing = null;
        int present = 5;
        System.out.println(missing);
        System.out.println(present);
    }
}

Constantes úteis

As classes encapsuladoras disponibilizam constantes práticas. Integer.MAX_VALUE e Integer.MIN_VALUE fornecem os maiores e menores valores de int.

Isso é muito mais fácil do que memorizar os números por conta própria.

public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
    }
}

Métodos auxiliares

As classes encapsuladoras também funcionam como caixas de ferramentas de métodos auxiliares estáticos. Por exemplo, Integer.toBinaryString exibe um número na base 2, e Integer.max retorna o maior de dois valores.

public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(10));
        System.out.println(Integer.max(7, 3));
        System.out.println(Integer.toHexString(255));
    }
}

Por que as coleções precisam de encapsuladores

Os tipos genéricos de Java funcionam somente com objetos, não com tipos primitivos. Você não pode escrever List<int>.

Em vez disso, use List<Integer>. O encapsulador faz o valor primitivo caber no universo de objetos exigido pelas coleções.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        System.out.println(numbers);
    }
}

Comparação de valores encapsulados

Para comparar o valor numérico dentro de dois encapsuladores, use .equals() ou .compareTo(), não os operadores matemáticos aplicados aos próprios objetos.

compareTo retorna um número negativo, zero ou um número positivo.

public class Main {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 200;
        System.out.println(a.equals(b));
        System.out.println(a.compareTo(b));
    }
}

Memória e desempenho

Os tipos primitivos usam menos memória e são executados mais rapidamente porque não têm a sobrecarga de objetos. Um único int contém apenas 4 bytes de dados brutos.

Um objeto encapsulador carrega informações adicionais de cabeçalho. Em laços intensivos que percorrem milhões de valores, prefira os tipos primitivos.

Os valores padrão são diferentes

Um campo primitivo não inicializado recebe por padrão um valor semelhante a zero: int é 0, e boolean é false.

Um campo encapsulador não inicializado recebe null por padrão. Essa diferença é importante quando você tenta usar o valor posteriormente.

public class Main {
    static int primitiveField;
    static Integer wrapperField;

    public static void main(String[] args) {
        System.out.println(primitiveField);
        System.out.println(wrapperField);
    }
}

Escolha entre eles

Uma regra simples: use tipos primitivos por padrão para obter desempenho e clareza. Mude para um encapsulador quando precisar de um elemento de coleção, de um tipo genérico ou da capacidade de representar um valor ausente com null.

Verificação rápida

Verifique sua compreensão sobre tipos primitivos e encapsuladores.

Recapitulação

Você aprendeu a diferença entre tipos primitivos e encapsuladores:

Os oito tipos primitivos correspondem a oito classes encapsuladoras, como Integer e Double
Os encapsuladores são objetos, podem ser null e podem ser usados em coleções
Os tipos primitivos são mais rápidos e leves; por isso, use-os por padrão
As classes encapsuladoras também fornecem constantes e métodos auxiliares úteis

Perguntas Frequentes

A aula “Tipos Primitivos versus Tipos Envoltórios” é grátis?

Sim — o texto completo de “Tipos Primitivos versus Tipos Envoltórios” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Tipos Primitivos versus Tipos Envoltórios”?

Integer, Double, Boolean e outros Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Tipos Primitivos versus Tipos Envoltórios”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Tipos Primitivos versus Tipos Envoltórios
Autoboxing e Unboxing
Análise e Valueof
Armadilhas do Autoboxing

← Voltar para Java Academy