Tipos de Dados em Java

Guia completo sobre tipos primitivos, Strings, conversões e type casting

1. O Básico: Entendendo Tipos de Dados

Em Java, cada variável precisa ter um tipo definido. O tipo determina que tipo de valor a variável pode armazenar, quanto espaço ela ocupa na memória e quais operações podem ser realizadas com ela.

Imagine os tipos de dados como diferentes tamanhos de caixas em um depósito. Uma caixa pequena (byte) serve para guardar números pequenos e economiza espaço. Uma caixa grande (long) pode guardar números enormes, mas ocupa mais espaço.

2. Tipos Primitivos em Java

Java possui 8 tipos primitivos fundamentais. Eles são os blocos básicos de construção da linguagem e não são objetos.

2.1 Tipos Numéricos Inteiros

byte

Tamanho: 8 bits (1 byte)

Intervalo: -128 a 127

Uso: Economizar memória, dados binários

java

byte idade = 25;
byte temperatura = -10;
byte nivelBateria = 100;

short

Tamanho: 16 bits (2 bytes)

Intervalo: -32.768 a 32.767

Uso: Números inteiros médios, economizar memória

java

short anoAtual = 2024;
short populacao = 15000;

int

Tamanho: 32 bits (4 bytes)

Intervalo: -2.147.483.648 a 2.147.483.647

Uso: Padrão para números inteiros

java

int salario = 5000;
int habitantes = 1000000;
int distancia = 450;

long

Tamanho: 64 bits (8 bytes)

Intervalo: Números muito grandes

Uso: IDs únicos, timestamps, números astronômicos

java

long populacaoMundial = 8000000000L;
long timestamp = System.currentTimeMillis();

2.2 Tipos Numéricos de Ponto Flutuante

float

Tamanho: 32 bits (4 bytes)

Precisão: 6-7 dígitos decimais

Uso: Números decimais com economia de memória

java

float altura = 1.75f;
float preco = 29.99f;
float temperatura = 36.5f;

double

Tamanho: 64 bits (8 bytes)

Precisão: 15-16 dígitos decimais

Uso: Padrão para decimais, cálculos científicos

java

double pi = 3.141592653589793;
double salario = 5500.75;
double distancia = 384400.5;

2.3 Outros Tipos Primitivos

char

Tamanho: 16 bits (2 bytes)

Uso: Um único caractere Unicode

java

char letra = 'A';
char simbolo = '@';
char numero = '5';

boolean

Tamanho: 1 bit (teoricamente)

Valores: true ou false

Uso: Condições lógicas, flags, estados

java

boolean estaLogado = true;
boolean temPermissao = false;
boolean maiorIdade = idade >= 18;

3. Tabela Comparativa de Tipos

Tipo	Tamanho	Padrão	Intervalo/Uso
byte	1 byte	0	-128 a 127
short	2 bytes	0	-32.768 a 32.767
int	4 bytes	0	~-2 bilhões a 2 bilhões
long	8 bytes	0L	Números muito grandes (L)
float	4 bytes	0.0f	Decimais (f)
double	8 bytes	0.0d	Decimais precisos
char	2 bytes	'\u0000'	Um caractere
boolean	1 bit	false	true/false

4. String: O Tipo Referência Mais Usado

Diferente dos tipos primitivos, String é um tipo de referência (objeto). Armazena sequências de caracteres (texto).

Características da String:

Imutável: Uma vez criada, não pode ser modificada
Aspas duplas: "texto" ao invés de aspas simples
Classe especial: Tem suporte especial do Java apesar de ser objeto
Pool de Strings: Java otimiza Strings literais na memória

java

String nome = "Maria Silva";
String email = "maria@email.com";

// Concatenação
String saudacao = "Olá, " + nome + "!";

// Métodos comuns
int tamanho = nome.length();
String maiuscula = nome.toUpperCase();
String minuscula = nome.toLowerCase();
boolean contem = nome.contains("Silva");

// Comparação (SEMPRE use .equals!)
boolean igual = nome.equals("Maria Silva");

5. Type Casting: Conversão entre Tipos

Type casting é converter um valor de um tipo para outro. Existem dois tipos principais.

5.1 Conversão Implícita (Widening)

Automática ao converter de tipo menor para maior. Sem perda de dados.

java

byte b = 10;
short s = b; // byte → short (automático)
int i = s; // short → int (automático)
long l = i; // int → long (automático)
double d = l; // long → double (automático)

5.2 Conversão Explícita (Narrowing)

Manual ao converter de tipo maior para menor. Pode haver perda de dados.

java

double d = 100.75;
int i = (int) d; // 100 (perde decimal)

long l = 1000L;
int i2 = (int) l; // 1000

float f = 10.5f;
int i3 = (int) f; // 10 (trunca)

5.3 Conversão com Wrapper Classes

Para converter entre primitivos e Strings.

java

// String para primitivos
String textoNumero = "123";
int numero = Integer.parseInt(textoNumero); // 123

String textoDecimal = "45.67";
double decimal = Double.parseDouble(textoDecimal); // 45.67

// Primitivos para String
int idade = 25;
String idadeTexto = String.valueOf(idade); // "25"
String idadeTexto2 = "" + idade; // "25"

6. Erros Comuns e Boas Práticas

Erro 1: Overflow em Tipos Pequenos

java

// ERRO: Número muito grande para byte
byte numero = 200; // ERRO! byte vai de -128 a 127

// CORRETO
int numero = 200; // OK

Erro 2: Comparar Strings com ==

java

// ERRADO
if (nome1 == nome2) { // Compara referências

// CORRETO
if (nome1.equals(nome2)) { // Compara conteúdo

Boas Práticas:

Use int como padrão para inteiros
Use double como padrão para decimais
Use long com sufixo L para números grandes
Use float com sufixo f quando necessário
Use .equals() para comparar Strings
Tenha cuidado com casting - pode perder dados

7. Exemplos Práticos

Exemplo 1: Calculadora de IMC

java

public class CalculadoraIMC {
    public static void main(String[] args) {
        String nome = "Carlos Silva";
        double peso = 75.5;
        double altura = 1.75;
        
        double imc = peso / (altura * altura);
        
        System.out.println("Nome: " + nome);
        System.out.printf("IMC: %.2f\n", imc);
    }
}

Exemplo 2: Conversão de Temperaturas

java

import java.util.Scanner;

public class ConversorTemperatura {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Digite a temperatura em Celsius: ");
        double celsius = sc.nextDouble();
        
        double fahrenheit = (celsius * 9.0 / 5.0) + 32.0;
        int fahrenheitInt = (int) fahrenheit;
        
        System.out.printf("%.2f°C = %.2f°F\n", celsius, fahrenheit);
        sc.close();
    }
}

8. Resumo Visual

Tipos Numéricos Inteiros:

byte (1 byte): -128 a 127

short (2 bytes): -32.768 a 32.767

int (4 bytes): ~-2 bilhões a 2 bilhões

long (8 bytes): números muito grandes (sufixo L)

Tipos Numéricos Decimais:

float (4 bytes): 6-7 dígitos (sufixo f)

double (8 bytes): 15-16 dígitos (padrão)

Outros Tipos:

char (2 bytes): Um caractere (aspas simples 'A')

boolean (1 bit): true ou false

String (objeto): Texto (aspas duplas "texto")

Conversões:

Implícita: Tipo menor → Tipo maior (automática)

Explícita: Tipo maior → Tipo menor (tipo)variavel

String ↔ Primitivo: Integer.parseInt(), String.valueOf()

Conclusão

Entender tipos de dados é fundamental para programar em Java de forma eficiente. Escolher o tipo correto significa usar a memória inteligentemente e evitar erros.

Regra de ouro: Use int para inteiros, double para decimais, String para texto e boolean para sim/não.