Ebook

Java
Completo

Escrito por Nathália Pavani Roma da Silva

 Variáveis
O que são variáveis?
Variáveis são espaços na memória usados para guardar dados (como números, textos, etc.) que o
programa pode usar e alterar enquanto roda.
Sintaxe básica
tipo nomeDaVariavel = valor;

Tipos de Variáveis em Java

1. int – Números inteiros
 Quando usar: Contagens, idades, índices de listas.
 Exemplo:
 int idade = 25;

2. double – Números decimais

 Quando usar: Valores com ponto flutuante, como preços e médias.
 Exemplo:
 double preco = 19.99;

3. boolean – Verdadeiro ou falso

 Quando usar: Condições lógicas, verificações de estado.
 Exemplo:
 boolean ativo = true;

4. char – Um único caractere

 Quando usar: Letras, símbolos individuais.
 Exemplo:
 char letra = 'A';

5. String – Conjunto de caracteres (texto)

 Quando usar: Nomes, mensagens, frases.
 Exemplo:
 String nome = "Maria";

Modificadores de Variáveis

1. Local – Dentro de métodos

 Só existe enquanto o método está rodando.
 Exemplo:

void exibir() {
int x = 10; // variável local
}

2. De instância – Fora dos métodos, sem static

 Pertence ao objeto.
 Exemplo:

class Pessoa {
String nome; // de instância
}
3. Estática (static) – Compartilhada entre todos os objetos
 Exemplo:
 static int contador = 0;

Dicas Rápidas
Tarefa Tipo mais usado
Contar coisas Int
Cálculos com casas decimais Double
Verificar condições Boolean
Guardar letras Char
Armazenar textos String
Valor comum a todos os objetos Static

Tipos de Dados em Java

Java possui dois grupos principais de tipos de dados:

1. Tipos Primitivos
Simples, leves e de uso direto.

Tipo Tamanho Exemplo Quando Usar

byte 8 bits byte b = 100; Números pequenos (ex: arquivos, sensores)
short 16 bits short s = 32000; Números inteiros maiores que byte
int 32 bits int x = 1500; Contagens, cálculos, índices (mais comum)
long 64 bits long l = 100000000L; Números muito grandes
float 32 bits float f = 5.5f; Números decimais com menos precisão
double 64 bits double d = 3.1415; Números decimais com mais precisão (mais usado)
char 16 bits char c = 'A'; Um único caractere
boolean 1 bit boolean ativo = true; Verdadeiro ou falso (condições)

2. Tipos por Referência (Não Primitivos)

Usam objetos para armazenar dados mais complexos.

Tipo Exemplo Quando Usar

String String nome = "João"; Textos, nomes, mensagens
Arrays int[] notas = {8, 9, 10}; Coleção de dados do mesmo tipo
Classes Pessoa p = new Pessoa(); Objetos com vários atributos e métodos
List List<String> nomes = new ArrayList<>(); Listas dinâmicas

Dicas Rápidas
 Use int para números inteiros, a menos que o valor seja muito grande → use long.
 Use double por padrão para números decimais, exceto se estiver lidando com poucos recursos
→ use float.
 Use boolean sempre que precisar tomar uma decisão (ex: ligado/desligado).
 Use char se precisar trabalhar com uma letra apenas (ex: iniciais).
 Use String para qualquer informação textual.
 Prefira tipos primitivos quando quiser melhor desempenho e economia de memória.
 Prefira tipos por referência quando precisar de mais funcionalidades (ex: métodos prontos de
String ou List).

Exemplo prático misturando tudo:

public class Aluno {
String nome;
int idade;
double mediaNotas;
boolean aprovado;

public Aluno(String nome, int idade, double mediaNotas) {

this.nome = nome;
this.idade = idade;
this.mediaNotas = mediaNotas;
this.aprovado = mediaNotas >= 6.0;
}
}

Tipos Numéricos em Java (Com Exemplos e Quando Usar)

1. Tipos Primitivos Numéricos

Intervalo
Tipo Tamanho Exemplo Quando Usar
aproximado
Dados pequenos, sensores, economia de
byte 8 bits -128 a 127 byte b = 120;
memória
short 16 bits -32.768 a 32.767 short s = 1000; Cálculos pequenos onde int é exagero
int 32 bits -2 bilhões a 2 bilhões int x = 2024; Contagens, operações gerais (mais usado)
Valores muito grandes, como tempo em
long 64 bits ±9 quintilhões long l = 999999L;
milissegundos
~7 dígitos de
float 32 bits float f = 3.14f; Decimais simples (economia de memória)
precisão
~15 dígitos de double d =
double 64 bits Decimais mais precisos (mais usado)
precisão 3.1415;

2. Wrappers (Classes Objeto dos Tipos Primitivos)

Usados quando você precisa tratar os valores como objetos (ex: listas, genéricos).

Primitivo Wrapper Exemplo

Int Integer Integer idade = 25;
Double Double Double salario = 2000.5;
boolean Boolean Boolean ativo = true;

Útil para trabalhar com Collections, como List<Integer>.

3. BigInteger e BigDecimal (java.math)

Usados quando os números ultrapassam os limites dos tipos primitivos ou quando se precisa de
precisão exata (como em dinheiro).

BigInteger – para inteiros muito grandes

import java.math.BigInteger;
BigInteger num1 = new BigInteger("9999999999999999999999999");
BigInteger num2 = new BigInteger("123456789");
BigInteger soma = num1.add(num2);

Quando usar: Criptografia, matemática avançada, ID's muito grandes.

BigDecimal – para decimais com precisão exata
import java.math.BigDecimal;
BigDecimal preco = new BigDecimal("19.99");
BigDecimal desconto = new BigDecimal("5.00");
BigDecimal finalPreco = preco.subtract(desconto);

Quando usar: Finanças, valores monetários, cálculo com casas decimais exatas.

Resumo Rápido de Quando Usar Cada Um:

Situação Tipo Ideal
Contagem simples Int
Tempo em milissegundos Long
Preços ou notas double ou BigDecimal (se exigir exatidão)
Números grandes demais BigInteger
Lista de números Integer, Double (com Collections)
Pouca memória e números pequenos byte, short, float
Cálculos financeiros com precisão BigDecimal

Conversão de Tipo em Java

Em Java, conversão de tipo é o processo de transformar um valor de um tipo de dado para outro.
Existem dois tipos principais:

1. Conversão Implícita (Widening / Automática)

Java converte automaticamente de um tipo menor para um maior, sem perda de dados.

Ordem de promoção automática:

byte → short → int → long → float → double

Quando usar: Quando você está passando um valor menor para um tipo maior, sem risco de perda de
informação.

Exemplo:
int x = 10;
double y = x; // conversão implícita de int para double

2. Conversão Explícita (Narrowing / Casting Manual)

É quando você força a conversão de um tipo maior para um menor. Pode haver perda de dados.

Quando usar: Quando você precisa controlar exatamente como os dados são convertidos, mesmo
correndo riscos.

Exemplo:
double preco = 19.99;
int inteiro = (int) preco; // Resultado: 19 (perde o .99)

Tabela Resumo
Risco de
Tipo de Conversão Exemplo Quando Usar
Perda?
Tipos compatíveis, sem perda de
Implícita (Widening) int x = 10; double y = x; ❌ Não
dados
double d = 3.14; int i = (int)
Explícita (Narrowing) ✅ Sim Necessário reduzir o tipo
d;
 Conversões Entre Tipos Incompatíveis (Usando Métodos)
Às vezes, você precisa converter tipos que não se conversam diretamente, como String → int ou int →
String.

String → Número
int idade = Integer.parseInt("30");
double preco = Double.parseDouble("19.99");

Quando usar: Ao receber dados do teclado, arquivos, ou da web (sempre vêm como String).
Número → String
int x = 50;
String texto = String.valueOf(x);
// ou
String texto2 = x + "";

Quando usar: Ao exibir resultados ou concatenar com outros textos.

char → int e vice-versa

char letra = 'A';
int codigo = (int) letra; // Resultado: 65
char letra2 = (char) 66; // Resultado: 'B'

Quando usar: Trabalhos com códigos ASCII, criptografia, ordenações.

Dicas Importantes
 Sempre verifique se há risco de perda de dados com conversão explícita.
 Prefira conversões com métodos prontos (Integer.parseInt, Double.valueOf) para evitar erros.
 Em valores monetários com String, use BigDecimal para evitar arredondamentos inesperados.

Operadores em Java
Operadores são símbolos usados para realizar operações com variáveis e valores. Em Java, eles se
dividem em categorias:

1. Aritméticos
Usados para fazer cálculos matemáticos.

Operador Significado Exemplo Resultado

+ Soma 5+3 8
- Subtração 5-2 3
* Multiplicação 4*2 8
/ Divisão 10 / 2 5
% Resto da divisão 10 % 3 1

Quando usar: Em cálculos, médias, porcentagens, controle de loops (i % 2 == 0 para pares).

2. Atribuição
Usados para atribuir valores a variáveis.
Operador Exemplo Equivalente a
= x = 10; -
+= x += 5; x = x + 5;
-= x -= 3; x = x - 3;
*= x *= 2; x = x * 2;
/= x /= 4; x = x / 4;
 Operador Exemplo Equivalente a
%= x %= 2; x = x % 2;

Quando usar: Para atualizar o valor de uma variável de forma compacta.

3. Comparação (Relacionais)
Comparam dois valores e retornam true ou false.

Operador Significado Exemplo Resultado

== Igualdade 5 == 5 true
!= Diferente 5 != 3 true
> Maior que 6>2 true
< Menor que 3<4 true
>= Maior ou igual 5 >= 5 true
<= Menor ou igual 4 <= 5 true

Quando usar: Em decisões (if, while, for, etc.).

4. Lógicos
Combinam expressões booleanas.

Operador Significado Exemplo Resultado

&& E (AND) true && false False
` ` Ou (OR)
! Negação (NOT) !true False

Quando usar: Em condições compostas:

if (idade > 18 && ativo) { ... }

5. Incremento e Decremento
Alteram o valor de uma variável em 1.

Operador Exemplo Resultado

++ x++ Incrementa 1 (pós)
-- x-- Decrementa 1 (pós)
++x ++x Incrementa antes
--x --x Decrementa antes

✅ Quando usar: Contadores em loops.

6. Ternário
Forma curta de if-else.

String resultado = (nota >= 6) ? "Aprovado" : "Reprovado";

✅ Quando usar: Para condições simples, de forma compacta.

Dicas Finais
 Evite == com String, use .equals():
 if (nome.equals("Maria")) { ... }
 Combine operadores lógicos e relacionais em condições complexas.
 O ternário deixa o código mais limpo em retornos simples.
 Use ++/-- com cuidado dentro de expressões para evitar confusão.
 Strings em Java
Em Java, String é uma classe imutável usada para trabalhar com textos (sequência de caracteres).

1. Declaração de String
String nome = "João";
String cidade = new String("São Paulo"); // menos comum

Quando usar: Sempre que lidar com texto, como nomes, mensagens, comandos, entrada de usuário.

2. Principais Métodos da Classe String

Método Exemplo Para que serve

length() nome.length() Retorna o tamanho da String
charAt(int) nome.charAt(0) Retorna o caractere na posição
toUpperCase() nome.toUpperCase() Converte para maiúsculas
toLowerCase() nome.toLowerCase() Converte para minúsculas
Compara conteúdo (diferencia
equals(String) nome.equals("João")
maiúsculas/minúsculas)
equalsIgnoreCase() nome.equalsIgnoreCase("joão") Compara ignorando maiúsculas/minúsculas
contains(String) nome.contains("ão") Verifica se contém o texto
startsWith(String) nome.startsWith("Jo") Verifica se começa com algo
endsWith(String) nome.endsWith("ão") Verifica se termina com algo
indexOf(String) nome.indexOf("o") Posição da 1ª ocorrência
lastIndexOf(String) nome.lastIndexOf("o") Posição da última ocorrência
substring(int, int) nome.substring(0, 2) Recorta parte da string
replace(String, ...) nome.replace("J", "L") Troca caracteres
trim() " João ".trim() Remove espaços do início e fim
isEmpty() nome.isEmpty() Verifica se a string está vazia ("")
isBlank() (Java 11+) " ".isBlank() Verifica se é vazia ou só espaços

3. Concatenação de Strings

Forma Exemplo
Com + "Olá, " + nome
Com concat() "Olá, ".concat(nome)
Com StringBuilder new StringBuilder().append(...)

Quando usar:
 Use + para juntar poucas Strings.
 Use StringBuilder para concatenar em loops ou grandes volumes, por ser mais eficiente.

4. Comparações de String
Evite ==! Use .equals().
String a = "java";
String b = "java";
String c = new String("java");

System.out.println(a == b); // true (mesmo objeto)

System.out.println(a == c); // false (objetos diferentes)
System.out.println(a.equals(c)); // true (mesmo conteúdo)
- Use equals() para comparar conteúdo
- Use == apenas para saber se são o MESMO objeto na memória

5. String vs StringBuilder vs StringBuffer

Tipo Mutável? É thread-safe? Quando usar
String ❌ ✅ Texto fixo ou poucas alterações
StringBuilder ✅ ❌ Texto com muitas alterações (sem concorrência)
StringBuffer ✅ ✅ Texto com alterações e concorrência

Exemplo prático
String frase = " Java é poderoso! ";
System.out.println(frase.trim().toUpperCase().replace("PODEROSO", "INCRÍVEL"));
// Resultado: JAVA É INCRÍVEL!

Dicas de Quando Usar

 Use trim() para limpar entrada do usuário.
 Use contains() ou startsWith() para filtros e buscas.
 Use substring() para extrair partes de CPF, datas, etc.
 Use StringBuilder em laços (for/while) com muitas concatenações.
 Use equalsIgnoreCase() ao comparar nomes digitados por usuários.

Classe Math em Java

A classe Math fornece métodos estáticos para operações matemáticas comuns, como potências, raízes,
arredondamentos e funções trigonométricas.

1. Constantes
Constante Descrição
Math.PI Valor de π (3.14159...)
Math.E Valor de Euler (2.71828...)

2. Operações Básicas
Método Exemplo Descrição Quando usar
Math.abs(x) Math.abs(-10) → 10 Valor absoluto Para evitar números negativos
Math.max(a, b) Math.max(5, 8) → 8 Maior valor Comparar e escolher maior número
Math.min(a, b) Math.min(5, 8) → 5 Menor valor Comparar e escolher menor número
Math.sqrt(x) Math.sqrt(16) → 4.0 Raiz quadrada Cálculos matemáticos, física
Math.pow(a, b) Math.pow(2, 3) → 8.0 Potência (a^b) Cálculos exponenciais

3. Arredondamentos
Método Exemplo Resultado Quando usar
Math.round(3.6) → Arredonda para o inteiro Quando quer arredondar
Math.round(float/double)
4 mais próximo valores decimais
Math.floor(3.9) → Arredonda para baixo
Math.floor(double) Para arredondar para baixo
3.0 (menor inteiro)
Math.ceil(3.1) → Arredonda para cima (maior
Math.ceil(double) Para arredondar para cima
4.0 inteiro)

4. Funções Trigonométricas
Método Exemplo Descrição Quando usar
Math.sin(Math.PI / 2) → Geometria, física,
Math.sin(angleRadians) Seno do ângulo (radianos)
1 gráficos
 Método Exemplo Descrição Quando usar
Cosseno do ângulo Geometria, física,
Math.cos(angleRadians) Math.cos(0) → 1
(radianos) gráficos
Math.tan(Math.PI / 4) →
Math.tan(angleRadians) Tangente do ângulo Geometria, física
1

5. Gerar números aleatórios

double r = Math.random(); // Valor entre 0.0 (inclusive) e 1.0 (exclusive)
✅ Quando usar: Jogos, simulações, sorteios.
Exemplo para número aleatório entre 1 e 100:
int aleatorio = (int)(Math.random() * 100) + 1;

Dicas Rápidas
 Use Math.pow() para elevar números a potências.
 Use Math.sqrt() para raiz quadrada.
 Use arredondamento adequado dependendo do contexto (floor, ceil ou round).
 Use funções trigonométricas em ângulos convertidos para radianos:
 double graus = 90;
 double rad = Math.toRadians(graus);
 double seno = Math.sin(rad);

Booleanos em Java
O tipo boolean representa valores lógicos, que podem ser true (verdadeiro) ou false (falso).

1. Declaração de boolean
boolean ligado = true;
boolean conectado = false;

Quando usar: Para indicar estados de verdadeiro/falso, ligar/desligar, condições de controle.

2. Operadores booleanos
Operador Exemplo Descrição Resultado Quando usar
&& true && false E (AND) false Quando todas condições devem ser verdadeiras
` ` `true
! !true Negação (NOT) false Para inverter o valor booleano

3. Uso em decisões
boolean temCarteira = true;
if (temCarteira) {
System.out.println("Pode dirigir.");
} else {
System.out.println("Não pode dirigir.");
}

Quando usar: Controle de fluxo (if, while, for), validações.

4. Expressões booleanas
Podem ser criadas comparando valores:
int idade = 20;
boolean maiorDeIdade = (idade >= 18); // true

5. Boolean como objeto (classe Boolean)

Boolean ligadoObj = Boolean.TRUE;
Boolean desconectadoObj = Boolean.FALSE;
Quando usar: Quando precisar de nullabilidade ou métodos da classe (ex: parseBoolean).

Dicas Importantes
 Nunca use == para comparar Boolean objetos, prefira .equals() ou compare boolean primitivo.
 Use boolean para controlar flags, estados e decisões lógicas simples.

Estrutura if-else em Java

if-else é uma estrutura condicional usada para executar diferentes blocos de código dependendo do
resultado de uma condição booleana.

1. Estrutura básica
if (condição) {
// executa se condição for verdadeira
} else {
// executa se condição for falsa
}
Exemplo:
int idade = 18;
if (idade >= 18) {
System.out.println("Maior de idade");
} else {
System.out.println("Menor de idade");
}

2. Uso do else if para múltiplas condições

if (nota >= 7) {
System.out.println("Aprovado");
} else if (nota >= 5) {
System.out.println("Recuperação");
} else {
System.out.println("Reprovado");
}

Quando usar: Para testar várias condições em sequência.

3. Condicional simples (sem else)

if (ativo) {
System.out.println("Usuário ativo");
}

Quando usar: Quando só precisa executar algo se a condição for verdadeira e nada caso contrário.

4. Expressões booleanas no if
A condição pode ser qualquer expressão que retorne true ou false.
if (senha.equals("1234")) {
System.out.println("Acesso permitido");
}

5. Operadores lógicos em if
Combine condições usando && (AND), || (OR) e ! (NOT):
if (idade >= 18 && temCNH) {
System.out.println("Pode dirigir");
}

Dicas rápidas
 Sempre use {} mesmo para blocos de uma linha para evitar erros.
 Use else if para evitar vários if separados, tornando o código mais claro.
  A condição do if deve ser obrigatoriamente booleana (true ou false).

Estrutura switch em Java

O switch é uma estrutura condicional usada para testar o valor de uma variável contra vários casos (case)
e executar blocos de código correspondentes.

1. Estrutura básica
switch (variável) {
case valor1:
// código se variável == valor1
break;
case valor2:
// código se variável == valor2
break;
default:
// código se nenhum case for atendido
break;
}

2. Exemplo prático
int dia = 3;
switch (dia) {
case 1:
System.out.println("Domingo");
break;
case 2:
System.out.println("Segunda-feira");
break;
case 3:
System.out.println("Terça-feira");
break;
default:
System.out.println("Dia inválido");
break;
}
Resultado: Terça-feira

3. Quando usar
 Quando tiver várias condições baseadas no valor exato de uma variável.
 Melhor que vários if-else if para múltiplas comparações de igualdade.
 Suporta tipos: byte, short, int, char, String (Java 7+), enums.

4. Dicas importantes
 Use break para evitar o efeito fall-through (execução contínua dos casos).
 O bloco default é opcional, serve como "else" para casos não previstos.
 A variável usada no switch deve ser compatível com os tipos suportados.
5. Switch com String
String comando = "sair";
switch (comando) {
case "entrar":
System.out.println("Entrando...");
break;
case "sair":
System.out.println("Saindo...");
break;
default:
System.out.println("Comando desconhecido");
}

Quando não usar

 Quando a condição envolve intervalos (ex: idade > 18), pois switch só compara valores exatos.
 Quando o número de casos for muito pequeno, um if pode ser mais legível.

Loop while em Java

O while é uma estrutura de repetição que executa um bloco de código enquanto uma condição booleana
for verdadeira.

1. Sintaxe básica
while (condição) {
// código a ser repetido
}
Exemplo:
int contador = 1;
while (contador <= 5) {
System.out.println("Contador: " + contador);
contador++;
}
Resultado: imprime números de 1 a 5.

2. Quando usar
 Quando você não sabe exatamente quantas vezes o loop vai executar.
 Quando a repetição depende de uma condição que pode mudar dentro do bloco.
 Útil para loops que dependem de variáveis externas e condições dinâmicas.

3. Loop infinito
Se a condição nunca virar false, o loop roda para sempre:
while (true) {
// cuidado! loop infinito
}
Use com cuidado e inclua um break para sair quando necessário.

4. Exemplo com break para sair do loop

int n = 0;
while (true) {
if (n == 5) {
break; // sai do loop quando n == 5
}
System.out.println(n);
n++;
}

5. Diferença entre while e do-while

 while verifica a condição antes de executar o bloco (pode não executar nenhuma vez).
 do-while executa o bloco pelo menos uma vez e depois verifica a condição.
do {
System.out.println("Executa pelo menos uma vez");
} while (condição);

Dicas rápidas
 Sempre atualize a variável da condição para evitar loops infinitos.
 Use while para repetir com condição incerta (ex: ler dados até condição de parada).
 Para loops com número definido de repetições, prefira for.
 Loop for em Java
O for é uma estrutura de repetição usada quando sabemos de antemão quantas vezes o código deve ser
executado.

1. Sintaxe básica
for (inicialização; condição; atualização) {
// código a ser repetido
}
Exemplo:
for (int i = 1; i <= 5; i++) {
System.out.println("i = " + i);
}
Resultado: imprime i de 1 até 5.

2. Componentes do for
 Inicialização: cria e inicializa a variável de controle (ex: int i = 0;).
 Condição: define até quando o loop roda (i < 10).
 Atualização: atualiza a variável de controle a cada iteração (i++).

3. Quando usar
 Quando sabemos exatamente o número de repetições.
 Para percorrer arrays ou coleções com índice.
 Para loops com passo fixo (incrementos ou decrementos).

4. Exemplo com array

String[] frutas = {"Maçã", "Banana", "Laranja"};

for (int i = 0; i < frutas.length; i++) {

System.out.println(frutas[i]);
}

5. For melhorado (foreach) para arrays e coleções

for (String fruta : frutas) {
System.out.println(fruta);
}
- Mais simples para percorrer todos os elementos sem usar índice.
Dicas rápidas
 Use for para loops contados e iteráveis.
 Sempre cuide para evitar loops infinitos (condição falsa em algum momento).
 Use for clássico quando precisar do índice.
 Use for-each para simplificar quando só precisa dos elementos.

break e continue em Java

Essas palavras-chave controlam o fluxo dentro de loops (for, while, do-while).

1. break
 Encerra imediatamente o loop atual, saindo dele.
 Usa-se para interromper um loop quando uma condição específica for satisfeita.

Exemplo:
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break; // sai do loop quando i == 5
}
System.out.println(i);
}
Resultado: imprime 1, 2, 3, 4 e para.

2. continue
 Pula a iteração atual do loop e vai direto para a próxima repetição.
 Usa-se para ignorar determinadas condições sem sair do loop.

Exemplo:
for (int i = 1; i <= 5; i++) {
if (i == 3) {
continue; // pula o número 3
}
System.out.println(i);
}
Resultado: imprime 1, 2, 4, 5 (pula o 3).

3. Quando usar
Palavra-chave Quando usar
break Para sair do loop ao encontrar uma condição específica
continue Para ignorar apenas a iteração atual e continuar o loop
Dicas importantes
 Use break para evitar execuções desnecessárias e otimizar loops.
 Use continue para filtrar casos dentro do loop sem parar tudo.
 Cuidado com loops infinitos e lógica complexa ao usar break e continue.

Arrays em Java
Arrays são estruturas que armazenam múltiplos valores do mesmo tipo em uma única variável.

1. Array Unidimensional
 Representa uma lista linear de elementos.
 Usado para armazenar uma sequência de dados.

Declaração e inicialização:
int[] numeros = new int[5]; // array com 5 posições (valores default 0)
int[] idades = {18, 21, 30, 25}; // array já inicializado

Acesso aos elementos:

int primeiro = idades[0]; // 18
idades[2] = 35; // altera o valor da posição 2 para 35
Exemplo:
for (int i = 0; i < idades.length; i++) {
System.out.println("Idade: " + idades[i]);
}

2. Quando usar Array Unidimensional

 Quando precisar armazenar uma coleção simples, linear e ordenada.
 Ex: lista de notas, idades, nomes (em array de Strings), etc.

3. Array Multidimensional (Matriz)

 Array de arrays, representando tabelas, grades, ou matrizes.
 O mais comum é o array bidimensional (int[][]), mas pode ter mais dimensões.

Declaração e inicialização:
int[][] matriz = new int[3][3]; // matriz 3x3, valores default 0
int[][] tabuleiro = {
{1, 2, 3},
{4, 5, 6},
 {7, 8, 9}
};

Acesso aos elementos:

int valor = tabuleiro[1][2]; // 6 (linha 1, coluna 2)
tabuleiro[0][0] = 10; // altera para 10
Exemplo:
for (int i = 0; i < tabuleiro.length; i++) {
for (int j = 0; j < tabuleiro[i].length; j++) {
System.out.print(tabuleiro[i][j] + " ");
}
System.out.println();
}

4. Quando usar Array Multidimensional

 Para representar dados tabulares, como planilhas, mapas, jogos de tabuleiro.
 Quando precisar de dados organizados em linhas e colunas.

Dicas rápidas
 Arrays em Java têm tamanho fixo — para tamanho variável, use ArrayList.
 Índices começam em zero (0).
 Sempre verifique o tamanho (length) para evitar ArrayIndexOutOfBoundsException.

Métodos em Java
Métodos são blocos de código que executam uma tarefa específica e podem ser reutilizados várias vezes.
Eles ajudam a organizar e modularizar o programa.

1. Declaração básica de método

public tipoRetorno nomeMetodo(parâmetros) {
// código do método
return valor; // se tipoRetorno não for void
}
Exemplo:
public int soma(int a, int b) {
return a + b;
}

2. Chamada do método
int resultado = soma(5, 3);
System.out.println(resultado); // imprime 8

3. Métodos sem retorno (void)

public void imprimirMensagem() {
System.out.println("Olá, mundo!");
}

4. Quando usar métodos

 Para reutilizar código e evitar repetição.
 Para organizar o código em blocos lógicos.
 Para facilitar a manutenção e leitura do programa.
 Para dividir tarefas complexas em partes menores.

5. Parâmetros e argumentos
 Parâmetros são variáveis definidas na assinatura do método.
 Argumentos são os valores passados ao chamar o método.

6. Exemplo com parâmetros múltiplos

public void apresentarPessoa(String nome, int idade) {
System.out.println("Nome: " + nome + ", Idade: " + idade);
}
Chamada:
apresentarPessoa("Ana", 25);

Dicas rápidas
 Use nomes claros para métodos que descrevam a ação.
 Métodos podem chamar outros métodos.
 Pode ter métodos sobrecarregados (mesmo nome, parâmetros diferentes).
 Métodos estáticos (static) pertencem à classe, não ao objeto.

Programação Orientada a Objetos (POO) em Java

POO é um paradigma que organiza o código em objetos que representam entidades do mundo real,
combinando dados e comportamentos.

1. Classes e Objetos
 Classe: molde que define atributos (dados) e métodos (comportamentos).
 Objeto: instância concreta de uma classe.

Exemplo:
public class Pessoa {
String nome;
int idade;

void falar() {
System.out.println("Olá, meu nome é " + nome);
}
}

// Criando objeto
Pessoa p = new Pessoa();
p.nome = "Ana";
p.idade = 25;
p.falar(); // Olá, meu nome é Ana

2. Encapsulamento
 Esconder detalhes internos da classe.
 Usar private para atributos e public métodos getters/setters para acesso.
public class Pessoa {
private String nome;

public String getNome() {

return nome;
}

public void setNome(String nome) {

this.nome = nome;
}
}

3. Herança
 Permite criar uma nova classe baseada em uma existente (reutilização de código).
 Usa extends.
public class Animal {
 void fazerSom() {
System.out.println("Som genérico");
}
}

public class Cachorro extends Animal {

void fazerSom() {
System.out.println("Au au");
}
}

4. Polimorfismo
 Capacidade de um objeto assumir várias formas.
 Métodos com mesmo nome, comportamento diferente (sobrescrita).
Animal a = new Cachorro();
a.fazerSom(); // Saída: Au au

5. Abstração
 Focar no essencial, escondendo detalhes complexos.
 Usar classes/métodos abstratos ou interfaces.
abstract class Forma {
abstract void desenhar();
}
6. Quando usar POO
 Projetos grandes e complexos.
 Quando precisar modelar entidades do mundo real.
 Para facilitar manutenção, reutilização e organização do código.

Dicas rápidas
 Sempre comece modelando classes com atributos e métodos.
 Use encapsulamento para proteger dados.
 Utilize herança para evitar duplicação.
 Aproveite polimorfismo para flexibilizar o código.

Interface em Java
Uma interface é um contrato que define um conjunto de métodos que uma classe deve implementar, sem
fornecer a implementação. Serve para garantir que classes diferentes sigam um mesmo padrão.

1. Declaração de interface
public interface Animal {
void fazerSom();
void mover();
}

2. Implementando uma interface

public class Cachorro implements Animal {
public void fazerSom() {
System.out.println("Au au");
}

public void mover() {

System.out.println("O cachorro corre");
}
}

3. Quando usar interfaces

  Para definir um contrato que várias classes diferentes devem seguir.
 Quando quiser garantir que classes diferentes implementem os mesmos métodos.
 Para permitir múltipla herança de tipos (Java não permite múltipla herança de classes, mas
permite múltiplas interfaces).
 Para desacoplar código e aumentar a flexibilidade.

4. Exemplo prático
public interface Veiculo {
void acelerar();
void frear();
}

public class Carro implements Veiculo {

public void acelerar() {
System.out.println("Carro acelerando");
}
public void frear() {
System.out.println("Carro freiando");
}
}

public class Bicicleta implements Veiculo {

public void acelerar() {
System.out.println("Bicicleta acelerando");
}
public void frear() {
System.out.println("Bicicleta freiando");
}
}

Dicas rápidas
 Métodos em interface são public e abstratos por padrão.
 Desde Java 8, interfaces podem ter métodos default com implementação.
 Use interfaces para projetar sistemas flexíveis e escaláveis.
 Evite usar interfaces para implementar comportamento (usar classes abstratas para isso).

Classes Abstratas em Java

Uma classe abstrata é uma classe que não pode ser instanciada diretamente e pode conter métodos
abstratos (sem implementação) e métodos concretos (com implementação).

1. Declaração de classe abstrata

public abstract class Animal {
public abstract void fazerSom(); // método abstrato (sem corpo)

public void dormir() { // método concreto

System.out.println("Dormindo...");
}
}

2. Classe concreta que estende classe abstrata

public class Cachorro extends Animal {
@Override
public void fazerSom() {
System.out.println("Au au");
}
}
3. Quando usar classes abstratas
 Quando quiser criar uma classe base que não faça sentido ser instanciada sozinha.
 Para fornecer parte da implementação comum para subclasses.
 Quando desejar que subclasses implementem métodos específicos obrigatoriamente.
 Quando quiser definir uma hierarquia com comportamento compartilhado.

4. Exemplo prático
public abstract class Forma {
public abstract double calcularArea();

public void desenhar() {

System.out.println("Desenhando a forma...");
}
}

public class Circulo extends Forma {

private double raio;

public Circulo(double raio) {

this.raio = raio;
}

@Override
public double calcularArea() {
return Math.PI * raio * raio;
}
}

Dicas rápidas
 Não pode criar objetos de classes abstratas: Animal a = new Animal(); → erro.
 Classes que estendem a abstrata devem implementar todos os métodos abstratos ou também
serem abstratas.
 Permite compartilhar código comum e garantir implementação de métodos essenciais.

Enums em Java
Enums (enumerações) são tipos especiais que representam um conjunto fixo de constantes, agrupando
valores relacionados.

1. Declaração básica de enum

public enum DiaSemana {
SEGUNDA,
TERÇA,
QUARTA,
QUINTA,
SEXTA,
SABADO,
DOMINGO
}

2. Uso do enum
DiaSemana hoje = DiaSemana.QUINTA;

if (hoje == DiaSemana.SABADO || hoje == DiaSemana.DOMINGO) {

System.out.println("Fim de semana!");
} else {
System.out.println("Dia útil.");
}

3. Enums com atributos e métodos

public enum StatusPedido {
PENDENTE(1),
PROCESSANDO(2),
ENVIADO(3),
ENTREGUE(4);

private int codigo;

StatusPedido(int codigo) {
this.codigo = codigo;
}

public int getCodigo() {

return codigo;
}
}
Uso:
StatusPedido status = StatusPedido.ENVIADO;
System.out.println(status.getCodigo()); // Imprime 3

4. Quando usar enums

 Para representar um conjunto fixo e limitado de valores.
 Quando quiser evitar erros de digitação (comparação com strings).
 Para melhorar a legibilidade e organização do código.
 Quando precisar associar valores ou métodos a constantes específicas.

Dicas rápidas
 Enums são tipos seguros — garantem que só valores definidos possam ser usados.
 Permitem métodos, construtores e implementam interfaces.
 Úteis para estados, categorias, dias da semana, opções fixas, etc.

Scanner em Java (Tipos de entrada)

A classe Scanner permite ler dados do usuário no console, suportando vários tipos de entrada: texto,
números e booleanos.

1. Importação e criação
import java.util.Scanner;

Scanner scanner = new Scanner(System.in);

2. Tipos de entrada e métodos do Scanner

Tipo Método Scanner Exemplo de uso
String (linha inteira) nextLine() String texto = scanner.nextLine();
String (palavra) next() String palavra = scanner.next();
int (inteiro) nextInt() int numero = scanner.nextInt();
double (decimal) nextDouble() double valor = scanner.nextDouble();
float (decimal menor) nextFloat() float valor = scanner.nextFloat();
long (inteiro grande) nextLong() long valor = scanner.nextLong();
boolean (true/false) nextBoolean() boolean b = scanner.nextBoolean();

3. Exemplo completo lendo vários tipos

import java.util.Scanner;

public class ExemploScanner {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Digite seu nome: ");

String nome = scanner.nextLine();

System.out.print("Digite sua idade: ");

int idade = scanner.nextInt();

System.out.print("Digite sua altura (ex: 1.75): ");

double altura = scanner.nextDouble();

System.out.print("Você é estudante? (true/false): ");

boolean estudante = scanner.nextBoolean();

System.out.println("\nResumo:");
System.out.println("Nome: " + nome);
System.out.println("Idade: " + idade);
System.out.println("Altura: " + altura);
System.out.println("Estudante: " + estudante);

scanner.close();
}
}

4. Dicas importantes ao usar Scanner

 Após usar nextInt(), nextDouble() ou outros que não lêem a linha inteira, chame
scanner.nextLine() para limpar o buffer antes de ler texto com nextLine().
 Sempre feche o Scanner com scanner.close() para liberar recursos.
 Use nextLine() para capturar textos com espaços.

5. Quando usar Scanner

 Para entrada de dados no console em programas simples.
 Quando precisar ler dados de tipos diferentes (texto, números, booleanos).
 Em testes, exercícios e aplicações pequenas que interagem com o usuário.

Data e Hora em Java

Java oferece várias classes para trabalhar com datas e horas, principalmente a partir do Java 8, usando o
pacote java.time, que é moderno, seguro e fácil de usar.

1. Classes principais do pacote java.time

Classe Descrição Quando usar
LocalDate Data (ano, mês, dia) Para datas sem horário (ex: aniversário)
Para horas sem data (ex: horário de
LocalTime Hora (hora, minuto, segundo)
expediente)
LocalDateTime Data + hora Para data e hora combinados
ZonedDateTime Data + hora + fuso horário Para datas com fuso horário
Duration Intervalo de tempo (segundos, etc.) Para medir intervalos curtos
Intervalo de tempo em dias, meses,
Period Para períodos longos (ex: idade)
anos

2. Exemplos básicos
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;

public class DataHoraExemplo {

public static void main(String[] args) {
LocalDate hoje = LocalDate.now(); // Data atual
LocalTime agora = LocalTime.now(); // Hora atual
LocalDateTime dataHora = LocalDateTime.now(); // Data e hora atual

System.out.println("Hoje: " + hoje);

System.out.println("Agora: " + agora);
System.out.println("Data e Hora: " + dataHora);
}
}

3. Formatar datas e horas

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

LocalDate hoje = LocalDate.now();

DateTimeFormatter formatador = DateTimeFormatter.ofPattern("dd/MM/yyyy");
String dataFormatada = hoje.format(formatador);
System.out.println("Data formatada: " + dataFormatada);

4. Criar datas específicas

LocalDate aniversario = LocalDate.of(1990, 5, 20);
LocalTime horaExata = LocalTime.of(14, 30, 0);

5. Calcular diferença entre datas

import java.time.LocalDate;
import java.time.Period;

LocalDate nascimento = LocalDate.of(1990, 5, 20);

LocalDate hoje = LocalDate.now();

Period idade = Period.between(nascimento, hoje);

System.out.println("Idade: " + idade.getYears() + " anos");

6. Quando usar cada classe

 LocalDate: para manipular datas (sem hora).
 LocalTime: para horários (sem data).
 LocalDateTime: para combinar data e hora.
 ZonedDateTime: para trabalhar com fusos horários.
 Period: para calcular diferença em anos, meses e dias.
 Duration: para intervalos de tempo menores (segundos, minutos).

Dicas rápidas
 Evite usar java.util.Date e java.util.Calendar (antigos e complicados).
 Use java.time (Java 8+) para melhor manipulação de datas/horas.
 Para entrada e saída, formate as datas com DateTimeFormatter.

Estruturas de Dados em Java e seus Métodos

1. Array (vetor)
 Estrutura básica, tamanho fixo.
  Métodos: arrays não têm métodos próprios além dos da classe Arrays para manipulação.

Exemplo:
int[] numeros = {1, 2, 3, 4, 5};
System.out.println(numeros[2]); // Acessa índice 2 (valor 3)

Métodos úteis da classe Arrays:

 Arrays.sort(array) — ordena o array
 Arrays.toString(array) — converte para String
 Arrays.copyOf(array, novoTamanho) — copia array

2. ArrayList
 Lista dinâmica, permite crescimento.
 Implementa List.

Principais métodos:
Método Descrição
add(E e) Adiciona elemento no fim
add(int index, E e) Adiciona elemento na posição
get(int index) Retorna elemento na posição
set(int index, E e) Substitui elemento na posição
remove(int index) Remove elemento pela posição
remove(Object o) Remove a primeira ocorrência
size() Retorna tamanho da lista
clear() Remove todos os elementos
contains(Object o) Verifica se contém o elemento
isEmpty() Verifica se está vazia

Exemplo:
ArrayList<String> lista = new ArrayList<>();
lista.add("Ana");
lista.add("Pedro");
System.out.println(lista.get(1)); // Pedro
lista.remove("Ana");
System.out.println(lista.size()); // 1

3. LinkedList
 Lista duplamente ligada.
 Implementa List e Deque.

Principais métodos (List e Deque):

Método Descrição
add(E e) Adiciona elemento no fim
addFirst(E e) Adiciona no início
addLast(E e) Adiciona no fim
get(int index) Retorna elemento na posição
remove(int index) Remove elemento na posição
removeFirst() Remove primeiro elemento
removeLast() Remove último elemento
size() Retorna tamanho
 Método Descrição
contains(Object o) Verifica se contém elemento
clear() Limpa lista

Exemplo:
LinkedList<String> fila = new LinkedList<>();
fila.add("Maria");
fila.addFirst("João");
System.out.println(fila.get(0)); // João
fila.removeLast();

4. HashSet
 Conjunto não ordenado, elementos únicos.
 Implementa Set.
Principais métodos:
Método Descrição
add(E e) Adiciona elemento (não duplica)
remove(Object o) Remove elemento
contains(Object o) Verifica se contém
size() Retorna tamanho
clear() Limpa conjunto
isEmpty() Verifica se vazio

Exemplo:
HashSet<Integer> numeros = new HashSet<>();
numeros.add(1);
numeros.add(2);
numeros.add(2); // Ignorado
System.out.println(numeros.size()); // 2

5. HashMap
 Mapa chave-valor, chave única.
 Implementa Map.
Principais métodos:

Método Descrição
put(K chave, V valor) Adiciona ou atualiza valor pela chave
get(Object chave) Retorna valor da chave
remove(Object chave) Remove par chave-valor
containsKey(Object chave) Verifica se chave existe
containsValue(Object valor) Verifica se valor existe
size() Tamanho do mapa
clear() Limpa mapa
keySet() Retorna conjunto das chaves
values() Retorna coleção dos valores

Exemplo:
HashMap<String, Integer> idades = new HashMap<>();
idades.put("Carlos", 30);
idades.put("Ana", 25);
System.out.println(idades.get("Ana")); // 25
idades.remove("Carlos");

6. Stack
 Pilha LIFO (último a entrar, primeiro a sair).
 Extende Vector.

Principais métodos:
Método Descrição
push(E e) Empilha elemento
pop() Remove e retorna topo
peek() Retorna topo sem remover
empty() Verifica se pilha está vazia

Exemplo:
Stack<String> pilha = new Stack<>();
pilha.push("Tarefa1");
pilha.push("Tarefa2");
System.out.println(pilha.pop()); // Tarefa2
System.out.println(pilha.peek()); // Tarefa1

7. Queue (Fila)
 Fila FIFO (primeiro a entrar, primeiro a sair).
 Implementada por classes como LinkedList.

Principais métodos:
Método Descrição
add(E e) Adiciona elemento (lança exceção se falhar)
offer(E e) Adiciona elemento (retorna false se falhar)
remove() Remove e retorna cabeça da fila (exceção se vazia)
poll() Remove e retorna cabeça (null se vazia)
element() Retorna cabeça sem remover (exceção se vazia)
peek() Retorna cabeça sem remover (null se vazia)

Exemplo:
Queue<String> fila = new LinkedList<>();
fila.offer("Pessoa1");
fila.offer("Pessoa2");
System.out.println(fila.poll()); // Pessoa1
System.out.println(fila.peek()); // Pessoa2

Quando usar cada estrutura

Estrutura Quando usar

Array Tamanho fixo, acesso rápido por índice
ArrayList Lista dinâmica com acesso por índice
LinkedList Muitas inserções/remoções no meio da lista
HashSet Elementos únicos, sem ordem
HashMap Busca rápida por chave
Stack LIFO, pilha de tarefas, desfazer/refazer
Queue FIFO, filas de processamento
 Quando usar cada estrutura de dados em Java
1. Array
 Situação ideal: Quando você sabe o número fixo de elementos que vai armazenar.
 Exemplo prático: Guardar os dias da semana, meses do ano, ou notas fixas.
 Vantagem: Acesso rápido pelo índice (O(1)).
 Limitação: Tamanho fixo, não cresce nem diminui dinamicamente.

2. ArrayList
 Situação ideal: Quando precisa de uma lista que pode crescer ou diminuir dinamicamente.
 Exemplo prático: Lista de alunos que podem ser adicionados ou removidos durante a
execução.
 Vantagem: Permite acesso rápido por índice e crescimento automático.
 Limitação: Inserções/remover no meio da lista são mais lentas (O(n)).

3. LinkedList
 Situação ideal: Quando você vai inserir ou remover muitos elementos no começo, meio ou fim
da lista.
 Exemplo prático: Implementar uma fila de espera, onde pessoas entram e saem
frequentemente.
 Vantagem: Inserções e remoções rápidas em qualquer posição (O(1) se tiver referência).
 Limitação: Acesso a elementos por índice é lento (O(n)).

4. HashSet
 Situação ideal: Quando você precisa garantir que os elementos sejam únicos e a ordem não
importa.
 Exemplo prático: Armazenar números de identificação únicos, palavras-chave sem repetição.
 Vantagem: Operações rápidas de inserção e busca (O(1) em média).
 Limitação: Não mantém ordem dos elementos.

5. HashMap
 Situação ideal: Quando você precisa associar pares chave-valor e acessar valores rapidamente
pela chave.
 Exemplo prático: Armazenar nomes de usuários e suas senhas, ou produtos e seus preços.
 Vantagem: Busca, inserção e remoção rápidas (O(1) em média).
 Limitação: Não mantém a ordem das chaves.

6. Stack (Pilha)
 Situação ideal: Quando você precisa de estrutura LIFO — o último elemento inserido é o
primeiro a ser retirado.
 Exemplo prático: Histórico de navegação, desfazer/refazer operações, avaliar expressões
matemáticas.
 Vantagem: Controle simples de "último a entrar, primeiro a sair".
 Limitação: Acesso apenas ao topo da pilha.

7. Queue (Fila)
 Situação ideal: Quando você precisa de estrutura FIFO — o primeiro elemento inserido é o
primeiro a ser retirado.
 Exemplo prático: Filas de impressão, atendimento ao cliente, processamento de tarefas.
 Vantagem: Mantém a ordem natural de chegada.
 Limitação: Acesso apenas ao início e ao fim da fila.

Resumo rápido:

Estrutura Quando usar (exemplo) Característica chave

Array Número fixo de elementos (dias da semana) Tamanho fixo, acesso rápido
 Estrutura Quando usar (exemplo) Característica chave
ArrayList Lista dinâmica (lista de usuários) Cresce/diminui, acesso rápido
LinkedList Muitas inserções/remover no meio (fila de espera) Inserção/remover eficiente
HashSet Itens únicos (CPF únicos) Não permite duplicatas
HashMap Associação chave-valor (produto → preço) Busca rápida por chave
Stack Último a entrar, primeiro a sair (desfazer) Pilha LIFO
Queue Primeiro a entrar, primeiro a sair (fila) Fila FIFO

Java Generics
O que são Generics?
 Generics permitem criar classes, interfaces e métodos que funcionam com tipos genéricos (não
fixos).
 Garantem segurança de tipo em tempo de compilação, evitando erros de ClassCastException.
 Evitam necessidade de cast explícito.

Sintaxe básica
class Caixa<T> {
private T objeto;

public void guardar(T obj) {

this.objeto = obj;
}

public T abrir() {
return objeto;
}
}

Aqui, T é um tipo genérico que será definido na hora do uso.

Exemplos de uso
Exemplo 1: Usando uma classe genérica
Caixa<String> caixaDeString = new Caixa<>();
caixaDeString.guardar("Olá");
String texto = caixaDeString.abrir();
System.out.println(texto);
Exemplo 2: Método genérico
public static <T> void imprimirArray(T[] array) {
for (T elemento : array) {
System.out.println(elemento);
}
}

Quando usar Generics?

 Quando quer criar estruturas de dados (listas, pilhas, filas, mapas) que funcionam para
qualquer tipo.
 Para reutilizar código sem perder segurança de tipos.
 Ao criar métodos utilitários que podem operar com qualquer tipo de dado.
 Evitar o uso de Object e casts explícitos, aumentando legibilidade e segurança.

Exemplo prático: Lista genérica

import java.util.ArrayList;

ArrayList<Integer> numeros = new ArrayList<>();

numeros.add(10);
// numeros.add("texto"); // Erro de compilação!

Resumo:
Conceito Descrição
T, E, K, V Convenções para tipos genéricos (ex: T=Tipo)
Classe genérica Classe parametrizada por tipo
Método genérico Método parametrizado por tipo
Segurança de tipo Erros detectados em tempo de compilação
Evita cast explícito Menos erro em tempo de execução

Java Exceptions
O que são Exceptions?
 Exceptions são erros que ocorrem durante a execução do programa.
 Permitem tratar falhas de forma controlada sem quebrar o programa.

Tipos de Exceptions

Tipo Exemplo Quando usar/tratar

Checked (verificadas) IOException, SQLException O compilador obriga a tratar
Unchecked (não NullPointerException,
Erros de lógica, opcional tratar
verificadas) IllegalArgumentException
Problemas graves no sistema, não
Errors OutOfMemoryError
tratar

Como tratar uma Exception

try-catch-finally
try {
int resultado = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Erro: divisão por zero.");
} finally {
System.out.println("Sempre executa!");
}
 try → bloco que pode lançar exceção
 catch → bloco que trata a exceção
 finally → sempre executa, mesmo com erro

Lançando sua própria Exception

public void sacar(double valor) {
if (valor > saldo) {
throw new IllegalArgumentException("Saldo insuficiente");
}
}

Principais Exceptions com exemplos

1. ArithmeticException
int x = 10 / 0;
 Uso: erros aritméticos como divisão por zero.

2. NullPointerException
String nome = null;
System.out.println(nome.length());
 Uso: acessar membros de objetos nulos.

3. ArrayIndexOutOfBoundsException
int[] nums = {1, 2, 3};
System.out.println(nums[5]);
 Uso: acessar índice inexistente de array.

4. IOException
BufferedReader reader = new BufferedReader(new FileReader("arquivo.txt"));
 Uso: leitura/gravação de arquivos — Checked, precisa de try-catch.

5. FileNotFoundException
new FileInputStream("inexistente.txt");
 Uso: arquivo não encontrado — é uma subclasse de IOException.

6. SQLException
 Uso: erros relacionados a banco de dados — sempre tratar com try-catch.

7. ClassCastException
Object x = "texto";
Integer y = (Integer) x; // erro
 Uso: conversão de tipos incompatíveis.

8. IllegalArgumentException
public void setIdade(int idade) {
if (idade < 0) {
throw new IllegalArgumentException("Idade inválida");
}
}
 Uso: validar argumentos inválidos passados para métodos.

Boas práticas
 Trate exceções específicas, evite catch (Exception e) genérico.
 Use finally para liberar recursos (como arquivos, conexões).
 Crie suas próprias exceções se necessário:
class SaldoInsuficienteException extends Exception {
public SaldoInsuficienteException(String msg) {
super(msg);
}
}

Resumo
Bloco Função
try Testa código que pode lançar erro
catch Trata a exceção
finally Sempre executado (liberação de recursos)
throw Lança manualmente uma exceção
throws Declara que um método pode lançar

Java Regex (Expressões Regulares)

O que é Regex?
  Regex (Regular Expression) é uma linguagem para buscar, validar ou manipular padrões em
textos.
 Em Java, usa-se com a classe Pattern e Matcher.

Importações necessárias:
import java.util.regex.Pattern;
import java.util.regex.Matcher;

Quando usar Regex?

 Validar e-mails, senhas, CPF, CEP, datas, etc.
 Encontrar padrões em textos (ex: números, palavras específicas).
 Substituir partes de texto com replaceAll.

Principais Métodos
Método Descrição
Pattern.matches(regex, str) Verifica se a string inteira bate com o padrão
Pattern.compile(regex) Cria um padrão reutilizável
matcher.find() Procura ocorrência parcial
matcher.matches() Verifica se toda a string combina
matcher.group() Retorna o que foi capturado

Exemplos práticos
Verificar se o texto é um número
System.out.println(Pattern.matches("\\d+", "12345")); // true
\\d+ = um ou mais dígitos (0-9)

Validar e-mail
String email = "[email protected]";
boolean valido = email.matches("^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,6}$");
System.out.println(valido); // true

Encontrar palavras que começam com "a"

Pattern p = Pattern.compile("\\ba\\w*");
Matcher m = p.matcher("amor arte ação bola casa");
while (m.find()) {
System.out.println(m.group()); // amor, arte, ação
}
\\b = início de palavra
a\\w* = começa com “a”, seguido de letras/dígitos

Substituir todos os números por “X”

String texto = "Senha 1234, código 5678";
System.out.println(texto.replaceAll("\\d+", "X"));
// Saída: Senha X, código X

Tabela de símbolos úteis (mais comuns)

Símbolo Significado
. Qualquer caractere (exceto \n)
\\d Dígito (0–9)
\\D Não dígito
\\w Letra, número ou _
\\s Espaço em branco
 Símbolo Significado
* 0 ou mais repetições
+ 1 ou mais repetições
? 0 ou 1 ocorrência
^ Início da string
$ Fim da string
[abc] a, b ou c
[^abc] Qualquer caractere exceto a, b ou c
(abc) Agrupamento

Dicas rápidas:
 Sempre use \\ no Java para escapar caracteres (\d vira "\\d").
 Prefira Pattern.compile() para usar o mesmo padrão várias vezes.
 Regex pode ser difícil no início, mas muito poderoso quando dominado.

Java Threads
O que são Threads?
 Thread é uma unidade de execução dentro de um programa.
 Permite executar várias tarefas simultaneamente (concorrência).
 Ideal para tarefas demoradas que não devem travar a interface ou o programa.

Quando usar Threads?

 Tarefas em paralelo: download, leitura de arquivos, chamadas de API.
 Processamento em segundo plano (ex: barra de carregamento).
 Melhorar o desempenho em sistemas com múltiplos núcleos.

Formas de criar uma Thread

1. Estendendo a classe Thread
class MinhaThread extends Thread {
public void run() {
System.out.println("Executando a thread!");
}
}

new MinhaThread().start();
- Simples e direto.
- Não pode herdar outra classe (limitação do Java por só permitir herança única).

2. Implementando a interface Runnable

class MinhaTarefa implements Runnable {
public void run() {
System.out.println("Rodando em paralelo!");
}
}

Thread t = new Thread(new MinhaTarefa());

t.start();
-Mais flexível (permite herdar outra classe).
-Recomendado na maioria dos casos.

3. Usando lambda (Java 8+)

Thread t = new Thread(() -> System.out.println("Com lambda!"));
t.start();
- Código mais enxuto e moderno.

Métodos úteis
Método Descrição
start() Inicia a thread
run() Lógica da thread (não chama diretamente)
sleep(ms) Pausa a thread por x milissegundos
join() Espera a thread terminar antes de seguir
isAlive() Verifica se a thread ainda está rodando
interrupt() Interrompe a execução (sinaliza parada)

Exemplo com sleep

public class Contador extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Contando: " + i);
try {
Thread.sleep(1000); // pausa 1 segundo
} catch (InterruptedException e) {
System.out.println("Thread interrompida.");
}
}
}
}

Executar múltiplas threads

new Thread(() -> {
for (int i = 0; i < 3; i++) {
System.out.println("Thread 1 - " + i);
}
}).start();

new Thread(() -> {

for (int i = 0; i < 3; i++) {
System.out.println("Thread 2 - " + i);
}
}).start();

Quando usar cada abordagem

Abordagem Quando usar
Thread (extends) Projetos simples e quando não precisa herdar outra classe
Runnable (implements) Projeto profissional e flexível
Lambda (com Runnable) Código enxuto, a partir do Java 8

Cuidados com Threads

 Concorrência pode gerar problemas de sincronização (ex: duas threads acessando o mesmo
recurso).
 Use synchronized para evitar conflitos:
public synchronized void metodoSeguro() {
// só uma thread entra por vez
}

Java Advanced Sorting (Comparable vs Comparator)

O que é ordenação avançada?
 Permite ordenar objetos personalizados (ex: produtos, alunos, livros).
 Usado com Collections.sort() ou Arrays.sort().
 Requer definir critérios de comparação.

1. Interface Comparable<T>
Define a ordem natural de um objeto.

Como usar:
 Implemente Comparable<T> na classe.
 Override do método compareTo().

Exemplo:
class Produto implements Comparable<Produto> {
String nome;
double preco;

public Produto(String nome, double preco) {

this.nome = nome;
this.preco = preco;
}

public int compareTo(Produto outro) {

return Double.compare(this.preco, outro.preco); // crescente
}
}

// Uso:
List<Produto> lista = new ArrayList<>();
lista.add(new Produto("TV", 2000));
lista.add(new Produto("Celular", 1500));
Collections.sort(lista); // ordena por preço

Quando usar Comparable?

 Quando existe uma ordem principal e fixa (ex: ordenar sempre por nome ou preço).
 Útil para ordem natural padrão.

2. Interface Comparator<T>
Permite múltiplas formas de ordenação externas à classe.

Como usar:
 Crie uma classe que implemente Comparator<T>.
 Override do método compare().

Exemplo:
class ComparadorPorNome implements Comparator<Produto> {
public int compare(Produto p1, Produto p2) {
return p1.nome.compareTo(p2.nome);
}
}

// Uso:
Collections.sort(lista, new ComparadorPorNome());

Exemplo com Comparator + Lambda (Java 8+):

// Ordenar por nome decrescente
lista.sort((p1, p2) -> p2.nome.compareTo(p1.nome));

Diferenças principais
Característica Comparable Comparator
Onde é implementado? Na própria classe Em uma classe externa (ou lambda)
Método compareTo() compare()
Ordem Apenas uma ordem natural Pode criar várias formas de ordenação
Uso com Collections.sort() Collections.sort(lista) Collections.sort(lista, comparator)

Exemplos prontos para revisar

Ordenar por nome (usando Comparator):
lista.sort(Comparator.comparing(produto -> produto.nome));

Ordenar por preço decrescente:

lista.sort((p1, p2) -> Double.compare(p2.preco, p1.preco));

Ordenar por múltiplos critérios:

lista.sort(Comparator.comparing(Produto::getNome)
.thenComparing(Produto::getPreco));

⚙️Dica para arrays:

Arrays.sort(arrayDeProdutos); // se Produto implementa Comparable
Arrays.sort(arrayDeProdutos, new ComparadorPorNome()); // se usar Comparator

Conclusão: Quando usar cada um?

Situação Use
Quer ordenar sempre por um atributo Comparable
Quer ordenar por vários critérios Comparator
Precisa de flexibilidade de ordenação Comparator (pode ser externa ou lambda)
Usa Java 8+ Comparator.comparing() com lambda

Java Files (Leitura, Escrita e Criação de Arquivos)

O que é?
 Permite ler, escrever, criar e manipular arquivos e diretórios.
 Classes principais:
o File (java.io)
o Files (java.nio.file)
o FileWriter, FileReader
o BufferedReader, BufferedWriter
o Scanner (para leitura simples)

1. Classe File (verificar, criar, excluir)

import java.io.File;

public class ExemploFile {

public static void main(String[] args) {
File arquivo = new File("teste.txt");

if (!arquivo.exists()) {
try {
arquivo.createNewFile();
 System.out.println("Arquivo criado!");
} catch (Exception e) {
e.printStackTrace();
}
} else {
System.out.println("Arquivo já existe.");
}
}
}
Quando usar?
 Verificar se o arquivo existe.
 Criar ou deletar arquivos e diretórios.
 Trabalhar com informações do arquivo (nome, tamanho, caminho etc).

2. Escrever em arquivo com FileWriter / BufferedWriter

import java.io.*;

public class EscreverArquivo {

public static void main(String[] args) {
try {
BufferedWriter writer = new BufferedWriter(new FileWriter("saida.txt"));
writer.write("Olá, mundo!");
writer.newLine();
writer.write("Segunda linha.");
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Quando usar?
 Para escrever dados simples em arquivos.
 Use BufferedWriter para maior performance com muitos dados.

3. Ler arquivo com BufferedReader

import java.io.*;

public class LerArquivo {

public static void main(String[] args) {
try {
BufferedReader reader = new BufferedReader(new FileReader("saida.txt"));
String linha;
while ((linha = reader.readLine()) != null) {
System.out.println(linha);
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Quando usar?
 Para ler arquivos linha por linha.
 Ideal para textos grandes.

4. Leitura simples com Scanner

import java.io.File;
import java.util.Scanner;

public class LerComScanner {

public static void main(String[] args) {
try {
Scanner sc = new Scanner(new File("saida.txt"));
while (sc.hasNextLine()) {
System.out.println(sc.nextLine());
}
sc.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Quando usar?
 Leitura simples e rápida, útil para arquivos pequenos ou scripts.

5. Usando Files (java.nio) – moderno e prático

import java.nio.file.*;
import java.io.IOException;
import java.util.List;

public class FilesAPI {

public static void main(String[] args) throws IOException {
Path caminho = Paths.get("saida.txt");

// Ler todas as linhas

List<String> linhas = Files.readAllLines(caminho);
linhas.forEach(System.out::println);

// Escrever (sobrescreve)
Files.write(caminho, List.of("Linha 1", "Linha 2"));

// Adicionar (append)
Files.write(caminho, List.of("Nova linha"), StandardOpenOption.APPEND);
}
}

Quando usar?
 Trabalhar com arquivos pequenos/moderados de forma moderna e limpa.
 Ideal para projetos com Java 8+.

Quando usar cada abordagem?

Situação Classe recomendada

Criar/verificar arquivos File
Ler arquivos linha por linha BufferedReader ou Scanner
Escrever arquivos FileWriter + BufferedWriter
Operações simples e modernas Files (java.nio.file)
Leitura simples e rápida Scanner

Dicas importantes
  Sempre use try-with-resources ou feche os recursos (.close()).
 Trate exceções com try-catch ou throws IOException.
 Prefira Files e BufferedReader para desempenho e simplicidade.

Java StringBuilder (com todos os métodos principais)

O que é StringBuilder?
 Uma classe mutável para manipular strings de forma mais eficiente do que a String comum.
 Evita criar múltiplos objetos em memória.
 Ideal para muitas concatenações e edições de texto.
 Está no pacote java.lang (não precisa importar).

Exemplo simples:
StringBuilder sb = new StringBuilder("Olá");
sb.append(" mundo!");
System.out.println(sb); // Olá mundo!

Métodos principais do StringBuilder:

Método Descrição Exemplo
append(String s) Adiciona texto ao final sb.append("!");
insert(int offset, String s) Insere texto na posição indicada sb.insert(3, "ABC");
replace(int start, int end, String
Substitui trecho entre índices sb.replace(0, 3, "Oi");
s)
delete(int start, int end) Remove parte da string sb.delete(0, 2);
deleteCharAt(int index) Remove um único caractere sb.deleteCharAt(5);
reverse() Inverte a string sb.reverse();
charAt(int index) Retorna o caractere em uma posição char c = sb.charAt(2);
setCharAt(int index, char c) Altera o caractere na posição indicada sb.setCharAt(0, 'H');
toString() Converte para String String texto = sb.toString();
length() Retorna o comprimento da string int len = sb.length();
capacity() Retorna a capacidade (espaço alocado) int cap = sb.capacity();
Garante que a capacidade mínima seja
ensureCapacity(int min) sb.ensureCapacity(100);
suficiente
setLength(int newLength) Define novo tamanho da string sb.setLength(0); // limpa
substring(int start) Retorna substring a partir de um índice sb.substring(4);
substring(int start, int end) Retorna substring entre dois índices sb.substring(0, 4);
indexOf(String str) Retorna índice da primeira ocorrência sb.indexOf("Java");
lastIndexOf(String str) Retorna índice da última ocorrência sb.lastIndexOf("a");
Reduz a capacidade para o comprimento
trimToSize() sb.trimToSize();
atual

Quando usar StringBuilder?

Situação Use StringBuilder
Muitas concatenações dentro de loops ✅ Sim – melhora desempenho
Montar grandes textos dinâmicos ✅ Sim – mais eficiente
Precisa modificar partes específicas da string ✅ Sim – tem métodos para alterar, apagar, inserir
Precisa de performance mas não precisa ser thread-
✅ Sim (senão, use StringBuffer)
safe

Diferença: String vs StringBuilder vs StringBuffer

 Recurso String StringBuilder StringBuffer
Mutável ❌ Não ✅ Sim ✅ Sim
Performance ⚠️Lenta ✅ Rápida ⚠️Mais lenta (thread-safe)
Thread-safe ✅ Sim ❌ Não ✅ Sim

Exemplo final com vários métodos:

public class ExemploCompleto {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Java");

sb.append(" é legal");
sb.insert(4, "Script"); // JavaScript é legal
sb.replace(0, 4, "Type"); // TypeScript é legal
sb.delete(10, 15); // remove " é"
sb.reverse(); // inverte
sb.setCharAt(0, '!'); // troca primeiro caractere
sb.reverse(); // volta ao normal
System.out.println("Texto final: " + sb);
System.out.println("Substring: " + sb.substring(0, 4));
System.out.println("Index of 'S': " + sb.indexOf("S"));
}
}

Exercícios de Java
1. Variáveis e Tipos Primitivos
Crie um programa que declare e imprima variáveis dos seguintes tipos:
 int, double, char, boolean, byte, short, long, float

2. Conversão de Tipos (Casting)

Converta um double para int, e um int para String e vice-versa.
Mostre no console cada resultado.
3. Operadores
Crie um programa que use operadores aritméticos, relacionais e lógicos para comparar dois
números.
Mostre o resultado de cada operação.

4. Strings
Receba uma String do usuário e:
 Conte o número de caracteres
 Transforme em maiúscula
 Verifique se contém a letra "a"

5. Java Math
Gere dois números aleatórios entre 1 e 100 e calcule:
 Raiz quadrada
 Potência
 Valor absoluto da subtração

6. Booleanos e Condicionais
Verifique se uma pessoa pode votar com base na idade (>= 16).
Use uma variável booleana para armazenar o resultado.

7. If/Else
Crie um programa que diga se o número digitado é positivo, negativo ou zero.

8. Switch
Peça um número de 1 a 7 e mostre o dia da semana correspondente.
Use switch.

9. While Loop
Imprima todos os números pares de 1 a 20 usando while.

10. For Loop

Imprima a tabuada de multiplicação do número 5 usando for.

11. Break e Continue

Use for de 1 a 10:
 Pule o número 5 com continue
 Interrompa no número 8 com break

12. Arrays
Crie um array de 5 nomes e imprima todos com for.
Depois, transforme em caixa alta usando toUpperCase().

13. Arrays Multidimensionais

Crie uma matriz 3x3 com números inteiros e imprima os valores.
Some todos os elementos da matriz.

14. Métodos
Crie um método soma(int a, int b) que retorne a soma.
Chame o método no main.

15. Programação Orientada a Objetos

Crie uma classe Pessoa com atributos nome e idade.
Crie um objeto, atribua valores e imprima-os.
16. Interface
Crie uma interface Animal com o método fazerSom().
Implemente nas classes Cachorro e Gato.

17. Classe Abstrata

Crie uma classe abstrata Veiculo com método mover().
Implemente em Carro e Bicicleta.

18. Enums
Crie um enum com os dias da semana e imprima uma mensagem diferente para DOMINGO.

19. Scanner + Tipos

Use Scanner para ler:
 String (nome), int (idade), double (altura), boolean (estudante)
Depois imprima todos os dados.

20. Data e Hora + StringBuilder

Pegue a data atual e monte uma frase usando StringBuilder:
"Hoje é dd/MM/yyyy e a hora é HH:mm:ss"
Use LocalDateTime e DateTimeFormatter.

Resolução dos Exercícios

Exercício 1: Variáveis e Tipos Primitivos
int idade = 25;
double salario = 2500.75;
char genero = 'M';
boolean ativo = true;
byte b = 100;
short s = 32000;
long l = 1000000000L;
float f = 3.14f;

System.out.println(idade + ", " + salario + ", " + genero + ", " + ativo + ", " + b + ", " + s + ", " + l + ", " + f);

Exercício 2: Conversão de Tipos

int i = (int) 5.67;
String str = Integer.toString(10);
int j = Integer.parseInt("20");
System.out.println(i + ", " + str + ", " + j);

Exercício 3: Operadores
int a = 10, b2 = 20;
System.out.println(a + b2);
System.out.println(a > b2);
System.out.println(a < b2 && b2 > 15);

Exercício 4: Strings
Scanner sc = new Scanner(System.in);
String entrada = sc.nextLine();
System.out.println(entrada.length());
System.out.println(entrada.toUpperCase());
System.out.println(entrada.contains("a"));

Exercício 5: Math
int n1 = (int)(Math.random() * 100 + 1);
int n2 = (int)(Math.random() * 100 + 1);
System.out.println(Math.sqrt(n1));
System.out.println(Math.pow(n1, 2));
System.out.println(Math.abs(n1 - n2));

Exercício 6: Booleanos
int idadeVoto = 17;
boolean podeVotar = idadeVoto >= 16;
System.out.println(podeVotar);

Exercício 7: If/Else
int numero = -5;
if (numero > 0) System.out.println("Positivo");
else if (numero < 0) System.out.println("Negativo");
else System.out.println("Zero");

Exercício 8: Switch
int dia = 3;
switch (dia) {
case 1 -> System.out.println("Domingo");
case 2 -> System.out.println("Segunda");
case 3 -> System.out.println("Terça");
case 4 -> System.out.println("Quarta");
case 5 -> System.out.println("Quinta");
case 6 -> System.out.println("Sexta");
case 7 -> System.out.println("Sábado");
default -> System.out.println("Dia inválido");
}

Exercício 9: While
int count = 1;
while (count <= 20) {
if (count % 2 == 0) System.out.println(count);
count++;
}

Exercício 10: For

for (int k = 1; k <= 10; k++) {
System.out.println("5 x " + k + " = " + (5 * k));
}

Exercício 11: Break e Continue

for (int x = 1; x <= 10; x++) {
if (x == 5) continue;
if (x == 8) break;
System.out.println(x);
}

Exercício 12: Array

String[] nomes = {"Ana", "Bea", "Carlos", "Daniel", "Eva"};
for (String nome : nomes) {
System.out.println(nome.toUpperCase());
}

Exercício 13: Matriz

int[][] matriz = {{1,2,3},{4,5,6},{7,8,9}};
int soma = 0;
for (int[] linha : matriz) {
for (int v : linha) {
System.out.println(v);
soma += v;
}
}
System.out.println("Soma: " + soma);

Exercício 14: Métodos

public static int soma(int a, int b) {
return a + b;
}
System.out.println(soma(3, 4));

Exercício 15: Classe Pessoa

class Pessoa {
String nome;
int idade;
}
Pessoa p = new Pessoa();
p.nome = "João";
p.idade = 30;
System.out.println(p.nome + " - " + p.idade);

Exercício 16: Interface

interface Animal {
void fazerSom();
}
class Cachorro implements Animal {
public void fazerSom() { System.out.println("Au au"); }
}
class Gato implements Animal {
public void fazerSom() { System.out.println("Miau"); }
}
new Cachorro().fazerSom();
new Gato().fazerSom();

Exercício 17: Classe Abstrata

abstract class Veiculo {
abstract void mover();
}
class Carro extends Veiculo {
void mover() { System.out.println("Carro se movendo"); }
}
class Bicicleta extends Veiculo {
void mover() { System.out.println("Bicicleta pedalando"); }
}
new Carro().mover();
new Bicicleta().mover();

Exercício 18: Enum

enum DiaSemana { DOMINGO, SEGUNDA, TERCA }
DiaSemana hoje = DiaSemana.DOMINGO;
switch (hoje) {
case DOMINGO -> System.out.println("Descanso!");
default -> System.out.println("Dia útil");
}

Exercício 19: Scanner

Scanner scanner = new Scanner(System.in);
System.out.println("Nome:");
String nome = scanner.nextLine();
System.out.println("Idade:");
int idadeScan = scanner.nextInt();
System.out.println("Altura:");
double altura = scanner.nextDouble();
System.out.println("Estudante (true/false):");
boolean estudante = scanner.nextBoolean();
System.out.println(nome + " - " + idadeScan + " - " + altura + " - " + estudante);

Exercício 20: Data e Hora + StringBuilder

LocalDateTime agora = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");
StringBuilder sb = new StringBuilder("Hoje é ");
sb.append(dtf.format(agora));
System.out.println(sb);