Folha de Consulta Java
Última atualização
Hello World e estrutura do programa
Todo programa Java é executado a partir de um método main dentro de uma classe.
| Elemento | Código |
|---|---|
| Declaração de classe | public class Main { ... } |
| Ponto de entrada | public static void main(String[] args) { ... } |
| Exibir uma linha | System.out.println("Hello, World!"); |
| Exibir sem quebra de linha | System.out.print("text"); |
| Ler entrada | Scanner sc = new Scanner(System.in); |
| Importar uma classe | import java.util.ArrayList; |
| Comentários | // line e /* block */ |
Tipos de dados
Os primitivos são em minúsculas; suas classes wrapper começam com maiúscula.
| Tipo | Descrição |
|---|---|
int | Inteiro com sinal de 32 bits |
long | Inteiro com sinal de 64 bits |
double / float | Números de ponto flutuante |
boolean | true ou false |
char | Caractere Unicode único de 16 bits |
byte / short | Inteiros de 8 bits / 16 bits |
String | Texto imutável (uma classe, não um primitivo) |
Integer, Double, Boolean | Classes wrapper para primitivos |
var | Tipo local inferido (Java 10+) |
Variáveis
| Operação | Sintaxe |
|---|---|
| Declarar e inicializar | int x = 5; |
| Inferência de tipo (local) | var name = "Ada"; |
| Constante | final double PI = 3.14159; |
| Concatenação de strings | String s = "Hi " + name; |
| Converter string para int | int n = Integer.parseInt("42"); |
| Converter int para string | String s = String.valueOf(42); |
| String formatada | String.format("%d items", n) |
Controle de fluxo
| Instrução | Sintaxe |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Instrução switch | switch (n) { case 1: ...; break; default: ...; } |
| Expressão switch | var s = switch (n) { case 1 -> "one"; default -> "other"; }; |
| Laço while | while (i < n) { ... } |
| Laço do-while | do { ... } while (i < n); |
| Laço for | for (int i = 0; i < n; i++) { ... } |
| For aprimorado (for-each) | for (String item : list) { ... } |
| Break / continue | break; sai de um laço, continue; pula para a próxima iteração |
Métodos
| Operação | Sintaxe |
|---|---|
| Definir um método | int add(int a, int b) { return a + b; } |
| Sem valor de retorno | void greet() { ... } |
| Método estático | static int square(int x) { return x * x; } |
| Método público | public String getName() { return name; } |
| Varargs | int sum(int... nums) { ... } |
| Chamar um método | int r = add(2, 3); |
| Chamar um método estático | Math.max(a, b); |
| Sobrecarga de método | int max(int a, int b) e double max(double a, double b) |
Classes e OOP
| Operação | Sintaxe |
|---|---|
| Definir uma classe | public class Dog { ... } |
| Campo | private String name; |
| Construtor | public Dog(String name) { this.name = name; } |
| Criar um objeto | Dog d = new Dog("Rex"); |
| Getter / setter | public String getName() { return name; } |
| Herança | class Puppy extends Dog { ... } |
| Interface | interface Runnable { void run(); } |
| Implementar uma interface | class Task implements Runnable { ... } |
| Sobrescrever um método | @Override public void speak() { ... } |
Coleções
Coleções genéricas de java.util.
| Tipo | Uso e exemplo |
|---|---|
ArrayList<T> | Array dinâmico: list.add(1); list.get(0); list.size(); |
HashMap<K, V> | Chave-valor: map.put("a", 1); map.get("a"); |
HashSet<T> | Valores únicos: set.add(5); set.contains(5); |
LinkedList<T> | Lista duplamente encadeada, boa como fila/deque |
ArrayDeque<T> | Pilha/fila: dq.push(x); dq.pop(); |
| Array | int[] nums = {1, 2, 3}; |
| Iterar uma lista | for (T x : list) { ... } |
| Iterar um map | for (var e : map.entrySet()) { e.getKey(); e.getValue(); } |
Streams e lambdas
Pipelines em estilo funcional sobre coleções (Java 8+).
| Operação | Sintaxe |
|---|---|
| Expressão lambda | x -> x * 2 |
| Criar uma stream | list.stream() |
| Filtrar | .filter(n -> n > 0) |
| Mapear / transformar | .map(n -> n * 2) |
| Ordenar | .sorted() ou .sorted(Comparator.reverseOrder()) |
| Reduzir / somar | .reduce(0, Integer::sum) |
| Contar / corresponder | .count(), .anyMatch(n -> n > 5) |
| Coletar em lista | .collect(Collectors.toList()) |
| Para cada | .forEach(System.out::println) |
Padrões comuns (try/catch, generics)
| Padrão | Sintaxe |
|---|---|
| Try / catch | try { ... } catch (Exception e) { ... } |
| Capturar exceção específica | catch (IOException e) { ... } |
| Finally | finally { ... } sempre executa |
| Try-with-resources | try (Scanner sc = new Scanner(...)) { ... } |
| Lançar uma exceção | throw new IllegalArgumentException("bad"); |
| Classe genérica | class Box<T> { T value; } |
| Método genérico | <T> T first(List<T> list) { ... } |
| Tipo limitado | <T extends Number> |
A sintaxe, as coleções e as operações de stream de Java que você mais usa, em uma única página. Esta folha de consulta Java é uma referência rápida para escrever Java - os tipos de dados, o controle de fluxo, as classes, as coleções ArrayList/HashMap, a Streams API e os padrões de exceção e generics que você usa todos os dias.
Tudo aqui é Java padrão (Java 8 e posterior) e compila com javac. Copie o que precisar ou teste qualquer trecho ao vivo no playground de Java - sem JDK para instalar.
Perguntas frequentes sobre a folha de consulta Java
Esta folha de consulta Java é gratuita?
Sim. Esta folha de consulta Java é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar uma sintaxe, uma coleção ou uma operação de stream.
Qual é a diferença entre == e .equals() em Java?
Para objetos,
== compara referências - se duas variáveis apontam exatamente para o mesmo objeto - enquanto .equals() compara o conteúdo. Dois objetos String diferentes com o mesmo texto são .equals(), mas podem não ser ==. Sempre use .equals() para comparar strings e outros objetos por igualdade de valor; use == apenas para primitivos (int, boolean, etc.) ou para verificar null.Para que servem as streams em Java?
A Streams API (Java 8+) permite processar coleções com um pipeline legível de operações -
filter, map, sorted, reduce, collect - em vez de laços manuais. Você começa com list.stream(), encadeia operações intermediárias e finaliza com uma operação terminal como collect(Collectors.toList()) ou forEach. Isso mantém o código de transformação de dados conciso e expressivo.Posso praticar Java online?
Sim. Abra o playground de Java para compilar e executar qualquer trecho desta folha de consulta no seu navegador - sem JDK para instalar. Quando quiser estrutura, o curso interativo e gratuito de Java da Coddy leva você passo a passo de variáveis e laços a classes, coleções e streams.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos blocos de construção mais comuns (tipos, controle de fluxo, métodos) até os avançados (streams, generics, exceções), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para o resto.
Recursos relacionados
Mais folhas de consulta
