Quais são tipos primitivos versus tipos de referência em Java?

Question

IT Interview Practice · Accepted Answer

Java tem duas categorias fundamentais de tipos: **primitivos** (valores simples armazenados diretamente) e **tipos de referência** (objetos, onde a variável contém uma referência/ponteiro para o objeto). Eles se comportam de forma muito diferente em memória, atribuição e comparação. ## Os 8 tipos primitivos ```java int i = 42; // 32-bit integer long l = 100L; // 64-bit integer double d = 3.14; // 64-bit floating point float f = 1.5f; // 32-bit floating point boolean b = true; // true/false char c = 'A'; // 16-bit Unicode character byte by = 127; // 8-bit short s = 1000; // 16-bit ``` Tipos primitivos armazenam o **valor real** diretamente, têm tamanho fixo, não podem ser null e vivem na pilha (para variáveis locais). Eles são rápidos e eficientes em memória. ## Tipos de referência — objetos ```java String name = "Ann"; // reference to a String object int[] arr = {1, 2, 3}; // reference to an array object List list = new ArrayList<>(); // reference to a List object Person p = new Person("Bob"); // reference to a Person object ``` Variáveis de referência contêm uma **referência** (endereço de memória) para um objeto armazenado no heap — não o objeto em si. Eles podem ser `null`. ## A diferença crítica: atribuição e comparação ```java // primitives — assignment COPIES the value (independent) int a = 5; int b = a; // b is a COPY b = 10; // a is still 5 // references — assignment COPIES the reference (both point to the SAME object) int[] x = {1, 2, 3}; int[] y = x; // y points to the SAME array y[0] = 99; // x[0] is now 99 too! (shared object) ``` ```java // == compares VALUES for primitives, but REFERENCES (identity) for objects String s1 = new String("hi"); String s2 = new String("hi"); s1 == s2; // false — different objects (different references) s1.equals(s2); // true — equals() compares CONTENT ``` Esta é uma armadilha importante: **`==` em objetos compara identidade (mesmo objeto?), não conteúdo** — use `.equals()` para comparação de conteúdo. ## Classes wrapper conectam os dois ```java Integer boxed = 42; // Integer is the OBJECT wrapper for int (autoboxing) int unboxed = boxed; // auto-unboxing back to primitive List nums; // collections need objects, not primitives ``` Cada tipo primitivo tem uma classe wrapper (`int`→`Integer`, etc.) para que tipos primitivos possam ser usados onde objetos são necessários (coleções, genéricos). ## Por que isso importa A distinção primitivo-versus-referência é fundamental em Java e a fonte de muitos bugs sutis e comportamentos: atribuição copia valores para primitivos, mas compartilha referências para objetos (então modificar um objeto compartilhado afeta todas as referências), e especialmente que **`==` compara identidade para objetos** (um erro clássico — use `.equals()` para comparação de conteúdo). Compreender isso afeta a correção em comparações, argumentos de método (objetos são efetivamente passados por valor de referência), tratamento de null (apenas referências podem ser null) e desempenho (primitivos são mais leves). É conhecimento essencial para escrever Java correto.

Os 8 tipos primitivos

Tipos de referência — objetos

A diferença crítica: atribuição e comparação

Classes wrapper conectam os dois

Por que isso importa

Perguntas relacionadas