Hoja de Trucos de Java
Última actualización
Hola Mundo y estructura del programa
Cada programa Java se ejecuta a partir de un método main dentro de una clase.
| Elemento | Código |
|---|---|
| Declaración de clase | public class Main { ... } |
| Punto de entrada | public static void main(String[] args) { ... } |
| Imprimir una línea | System.out.println("Hello, World!"); |
| Imprimir sin salto de línea | System.out.print("text"); |
| Leer entrada | Scanner sc = new Scanner(System.in); |
| Importar una clase | import java.util.ArrayList; |
| Comentarios | // line y /* block */ |
Tipos de datos
Los primitivos van en minúscula; sus clases envoltorio van con mayúscula inicial.
| Tipo | Descripción |
|---|---|
int | Entero con signo de 32 bits |
long | Entero con signo de 64 bits |
double / float | Números de punto flotante |
boolean | true o false |
char | Un solo carácter Unicode de 16 bits |
byte / short | Enteros de 8 bits / 16 bits |
String | Texto inmutable (una clase, no un primitivo) |
Integer, Double, Boolean | Clases envoltorio de los primitivos |
var | Tipo local inferido (Java 10+) |
Variables
| Operación | Sintaxis |
|---|---|
| Declarar e inicializar | int x = 5; |
| Inferencia de tipo (local) | var name = "Ada"; |
| Constante | final double PI = 3.14159; |
| Concatenación de cadenas | String s = "Hi " + name; |
| Convertir cadena a int | int n = Integer.parseInt("42"); |
| Convertir int a cadena | String s = String.valueOf(42); |
| Cadena con formato | String.format("%d items", n) |
Control de flujo
| Sentencia | Sintaxis |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Sentencia switch | switch (n) { case 1: ...; break; default: ...; } |
| Expresión switch | var s = switch (n) { case 1 -> "one"; default -> "other"; }; |
| Bucle while | while (i < n) { ... } |
| Bucle do-while | do { ... } while (i < n); |
| Bucle for | for (int i = 0; i < n; i++) { ... } |
| For mejorado (for-each) | for (String item : list) { ... } |
| Break / continue | break; sale de un bucle, continue; salta a la siguiente iteración |
Métodos
| Operación | Sintaxis |
|---|---|
| Definir un método | int add(int a, int b) { return a + b; } |
| Sin 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) { ... } |
| Llamar a un método | int r = add(2, 3); |
| Llamar a un método estático | Math.max(a, b); |
| Sobrecarga de métodos | int max(int a, int b) y double max(double a, double b) |
Clases y POO
| Operación | Sintaxis |
|---|---|
| Definir una clase | public class Dog { ... } |
| Campo | private String name; |
| Constructor | public Dog(String name) { this.name = name; } |
| Crear un objeto | Dog d = new Dog("Rex"); |
| Getter / setter | public String getName() { return name; } |
| Herencia | class Puppy extends Dog { ... } |
| Interfaz | interface Runnable { void run(); } |
| Implementar una interfaz | class Task implements Runnable { ... } |
| Sobrescribir un método | @Override public void speak() { ... } |
Colecciones
Colecciones genéricas de java.util.
| Tipo | Uso y ejemplo |
|---|---|
ArrayList<T> | Array dinámico: list.add(1); list.get(0); list.size(); |
HashMap<K, V> | Clave-valor: map.put("a", 1); map.get("a"); |
HashSet<T> | Valores únicos: set.add(5); set.contains(5); |
LinkedList<T> | Lista doblemente enlazada, buena como cola/deque |
ArrayDeque<T> | Pila/cola: dq.push(x); dq.pop(); |
| Array | int[] nums = {1, 2, 3}; |
| Iterar una lista | for (T x : list) { ... } |
| Iterar un mapa | for (var e : map.entrySet()) { e.getKey(); e.getValue(); } |
Streams y lambdas
Pipelines de estilo funcional sobre colecciones (Java 8+).
| Operación | Sintaxis |
|---|---|
| Expresión lambda | x -> x * 2 |
| Crear un stream | list.stream() |
| Filtrar | .filter(n -> n > 0) |
| Mapear / transformar | .map(n -> n * 2) |
| Ordenar | .sorted() o .sorted(Comparator.reverseOrder()) |
| Reducir / sumar | .reduce(0, Integer::sum) |
| Contar / coincidir | .count(), .anyMatch(n -> n > 5) |
| Recolectar en una lista | .collect(Collectors.toList()) |
| Para cada | .forEach(System.out::println) |
Patrones comunes (try/catch, genéricos)
| Patrón | Sintaxis |
|---|---|
| Try / catch | try { ... } catch (Exception e) { ... } |
| Capturar una excepción específica | catch (IOException e) { ... } |
| Finally | finally { ... } siempre se ejecuta |
| Try-with-resources | try (Scanner sc = new Scanner(...)) { ... } |
| Lanzar una excepción | throw new IllegalArgumentException("bad"); |
| Clase genérica | class Box<T> { T value; } |
| Método genérico | <T> T first(List<T> list) { ... } |
| Tipo acotado | <T extends Number> |
La sintaxis, las colecciones y las operaciones de stream de Java que más usas, en una sola página. Esta hoja de trucos de Java es una referencia rápida para escribir Java: los tipos de datos, el control de flujo, las clases, las colecciones ArrayList/HashMap, la API de Streams y los patrones de excepciones y genéricos que usas a diario.
Todo lo que hay aquí es Java estándar (Java 8 y posteriores) y se compila con javac. Copia lo que necesites o prueba cualquier fragmento en vivo en el playground de Java, sin instalar ningún JDK.
Preguntas frecuentes sobre la hoja de trucos de Java
¿Esta hoja de trucos de Java es gratis?
Sí. Esta hoja de trucos de Java es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar la sintaxis, una colección o una operación de stream.
¿Cuál es la diferencia entre == y .equals() en Java?
Para objetos,
== compara referencias (si dos variables apuntan exactamente al mismo objeto), mientras que .equals() compara el contenido. Dos objetos String distintos con el mismo texto son .equals() pero pueden no ser ==. Usa siempre .equals() para comparar cadenas y otros objetos por igualdad de valor; usa == solo para primitivos (int, boolean, etc.) o para comprobar si es null.¿Para qué se usan los streams en Java?
La API de Streams (Java 8+) te permite procesar colecciones con un pipeline legible de operaciones (
filter, map, sorted, reduce, collect) en lugar de bucles manuales. Empiezas con list.stream(), encadenas operaciones intermedias y terminas con una operación terminal como collect(Collectors.toList()) o forEach. Mantiene el código de transformación de datos conciso y expresivo.¿Puedo practicar Java en línea?
Sí. Abre el playground de Java para compilar y ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin instalar ningún JDK. Cuando quieras estructura, el curso interactivo y gratuito de Java de Coddy te lleva paso a paso desde las variables y los bucles hasta las clases, las colecciones y los streams.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los componentes básicos más comunes (tipos, control de flujo, métodos) hasta los avanzados (streams, genéricos, excepciones), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el resto.
Recursos relacionados
Más hojas de referencia
