Tipos de Dados em Java: o que são e como funcionam

Quando a gente começa a programar em Java, uma das primeiras coisas que aparecem são os tipos. Eles servem pra dizer ao programa os tipos de dados e que tipo de informação será guardada em cada variável, se é um número, uma letra, um texto, e por aí vai.

Java é uma linguagem fortemente tipada, o que significa que toda variável precisa ter um tipo definido antes de ser usada. E esses tipos se dividem em dois grupos: primitivos e não primitivos.

Tipos Primitivos:

Os tipos primitivos são os mais básicos. Eles não são objetos e vêm prontos na linguagem. Existem oito tipos primitivos em Java:

• byte: usado para números inteiros bem pequenos, vai de -128 até 127.

• short: também para números inteiros, mas com um intervalo um pouco maior, de -32.768 até 32.767.

• int: é o tipo inteiro mais usado, serve para a maioria dos casos. Vai de cerca de -2 bilhões até 2 bilhões.

• long: usado quando o número inteiro é muito grande; termina com L no final, tipo 10000000000L.

• float: representa números decimais com precisão simples. Termina com f, tipo 3.14f.

• double: também representa números decimais, mas com precisão maior.

• char: guarda um único caractere, como 'A' ou '9'.

• boolean: pode ter apenas dois valores: true ou false.

Contextualizando...

No dia a dia de desenvolvimento em Java, nem todos os tipos primitivos são usados com frequência. Aqui vai um resumo do que o mercado realmente utiliza mais:

• int: o mais comum de todos. É o padrão pra trabalhar com números inteiros (como IDs, contadores, quantidades, etc.).

• double: é o tipo mais usado pra números com casas decimais. O float quase não aparece hoje, porque o double tem mais precisão.

• boolean: usado o tempo todo em condições, validações, e estruturas de controle (if, while, etc.).

• char: aparece às vezes, mas geralmente o pessoal prefere String pra lidar com textos.

• long: usado em casos específicos, tipo quando os números são muito grandes (ex: IDs de banco de dados, timestamps).

• byte e short: quase nunca usados em código de aplicação comum. São mais vistos em sistemas embarcados ou quando se precisa economizar memória (tipo em hardware ou dispositivos pequenos).

Resumindo:
👉 No mercado, o trio int, double e boolean domina disparado.
O long aparece com frequência moderada, e os outros são mais raros.

Tipos não primitivos em Java

Os tipos não primitivos (também chamados de referência) são aqueles que não são básicos da linguagem, ou seja, são criados a partir de classes. Eles podem armazenar várias informações, ter métodos próprios e até serem criados por você.

Aqui estão os principais:

• String: É usada pra armazenar textos. Diferente de char, que guarda só uma letra, String pode ter várias. Exemplo:

String nome = "Bruna";

Ela tem vários métodos, como toUpperCase(), length(), substring() e outros.

• Arrays: guardam vários valores do mesmo tipo em uma única variável. Exemplo:

int[] numeros = {1, 2, 3, 4};

São muito usados quando você precisa lidar com listas fixas.

• Classes: você pode criar suas próprias classes pra representar algo, tipo um Usuario, Carro ou Produto.

class Usuario {
    String nome;
    int idade;
}

Esse tipo é a base da programação orientada a objetos em Java.

• Wrappers: são versões “objeto” dos tipos primitivos, como Integer, Long, Double, Boolean, etc.

Integer numero = 10;
Long quantidadeGrande = 10000000000L;
Double preco = 29.99;
Boolean ativo = true;

Eles permitem usar métodos e são úteis quando se trabalha com coleções (como ArrayList, que não aceita tipos primitivos).

ArrayList<int> numeros = new ArrayList<>(); // ❌ errado!
ArrayList<Integer> numeros = new ArrayList<>(); // ✅ certo!

Além disso, as classes Wrapper têm métodos úteis, como conversão de tipo ou comparação:

int x = 10;
Integer y = x; // autoboxing: o Java converte automaticamente int -> Integer
int z = y; // unboxing: converte Integer -> int

System.out.println(y.compareTo(5)); // compara valores
System.out.println(Integer.parseInt("123")); // converte String pra int

Autoboxing e Unboxing

Esses dois termos aparecem muito:

• Autoboxing: quando o Java converte automaticamente um tipo primitivo em Wrapper.
• Unboxing: quando ele faz o contrário, convertendo um Wrapper em primitivo.

O compilador faz isso sozinho na maioria das vezes, o que facilita a vida.

Quando usar Wrappers?

• Quando você precisa de métodos ou recursos extras.
• Quando vai armazenar dados em coleções (List, Map, etc.).
• Quando precisa converter tipos (como transformar texto em número).
• Mas, se quiser performance, prefira os tipos primitivos, porque os Wrappers são objetos e ocupam mais memória.

Outros tipos de referência

Incluem classes como StringBuilder, StringBuffer, e tipos personalizados criados pelo programador ou por bibliotecas externas.

Dúvidas comuns sobre Wrappers em Java

1. Qual a diferença entre int e Integer?
   int é um tipo primitivo, mais leve e rápido. Integer é uma classe (objeto) que possui métodos e pode ser usada em coleções.
2. Posso misturar int e Integer no mesmo código?
   Sim. O Java faz a conversão automática entre os dois tipos (autoboxing e unboxing).
3. Os Wrappers consomem mais memória?
   Sim. Por serem objetos, ocupam mais espaço e têm um pequeno custo de performance em relação aos tipos primitivos.
4. Por que não posso usar int em uma lista (ArrayList)?
   Porque coleções em Java aceitam apenas objetos. Por isso, é preciso usar Integer no lugar de int.
5. Como converter uma String em Integer (ou outro tipo numérico)?
   Usando os métodos das classes Wrapper, como parseInt e valueOf. parseInt retorna um tipo primitivo e valueOf retorna um objeto.
6. Existe diferença entre Integer.valueOf e new Integer?
   Sim. Integer.valueOf usa um cache interno do Java e evita criar objetos desnecessários, enquanto new Integer cria um novo objeto toda vez. O mais indicado é usar valueOf.
7. Posso comparar Integer com "==" ?
   Não é recomendado. O operador == compara referências (endereços de memória), e não o valor. Para comparar valores de objetos, use equals.

Entender os tipos de dados em Java é essencial para escrever códigos mais claros, eficientes e sem erros. Saber quando usar tipos primitivos e quando usar Wrappers ou outros tipos de referência faz toda a diferença no desempenho e na organização do programa. Com o tempo, essas escolhas se tornam automáticas, e você passa a enxergar o Java com muito mais naturalidade e confiança.