Todo lo esencial de Java 21 en una sola página, para consultar mientras programas o repasas para el examen. Cada fila muestra el código y su resultado; para la explicación completa, sigue los enlaces de cada apartado.
Estructura de un programa y consola
| Código | Qué hace |
|---|
public class Hola { ... } | Clase principal: el archivo debe llamarse Hola.java |
public static void main(String[] args) | Punto de entrada del programa |
System.out.println("Hola"); | Escribe y salta de línea |
System.out.print("Hola"); | Escribe sin saltar de línea |
System.out.printf("%.2f €%n", 3.5); | Escribe con formato: 3,50 € o 3.50 € según el idioma del sistema |
// comentario / /* ... */ | Comentario de una línea / de varias |
javac Hola.java | Compila y genera Hola.class (bytecode) |
java Hola | Ejecuta el programa en la JVM |
java Hola.java | Compila y ejecuta en un paso (programas de un archivo) |
public class Hola {
public static void main(String[] args) {
System.out.println("Hola, DevSchool"); // Hola, DevSchool
}
}
Más en: ¿Qué es Java?
Variables y tipos
| Código | Qué hace |
|---|
int edad = 20; | Entero (32 bits): de -2147483648 a 2147483647 |
long poblacion = 3_000_000_000L; | Entero grande: lleva L al final |
double precio = 19.99; | Decimal (el habitual) |
float peso = 3.5f; | Decimal de menos precisión: lleva f |
char letra = 'A'; | Un carácter, con comillas simples |
boolean activo = true; | true o false |
String nombre = "Ana"; | Texto: es una clase, no un tipo primitivo |
final double IVA = 0.21; | Constante: no se puede reasignar |
var lista = new ArrayList<String>(); | El compilador deduce el tipo (solo variables locales) |
(int) 3.99 | 3 (casting: corta los decimales) |
(double) 7 / 2 | 3.5 |
(char) ('A' + 1) | 'B' |
Integer.MAX_VALUE + 1 | -2147483648 (desbordamiento) |
0.1 + 0.2 | 0.30000000000000004 |
Más en: Variables y tipos
Operadores
| Código | Resultado |
|---|
7 / 2 | 3 (entre enteros, división entera) |
7 / 2.0 | 3.5 |
7 % 3 | 1 (resto) |
-7 % 3 | -1 (el resto lleva el signo del dividendo) |
x++ (con x = 5) | Devuelve 5 y después x vale 6 |
++x (con x = 5) | Suma primero: devuelve 6 |
"5" + 3 | "53" (con un String, + concatena) |
1 + 2 + "3" | "33" (se evalúa de izquierda a derecha) |
"1" + 2 + 3 | "123" |
'a' + 'b' | 195 (los char se suman como números) |
5 > 3 && 2 > 4 | false (Y) |
5 > 3 || 2 > 4 | true (O) |
a == b | Compara valores en primitivos; en objetos compara la referencia |
10 > 5 ? "mayor" : "menor" | "mayor" (operador ternario) |
1 / 0 | Lanza ArithmeticException: / by zero |
Más en: Operadores
Scanner, condicionales y bucles
| Código | Qué hace |
|---|
import java.util.Scanner; | Importa la clase (antes de public class) |
Scanner sc = new Scanner(System.in); | Crea el lector de teclado |
int n = sc.nextInt(); | Lee un entero |
double d = sc.nextDouble(); | Lee un decimal |
String palabra = sc.next(); | Lee una palabra (hasta el espacio) |
String linea = sc.nextLine(); | Lee la línea completa |
sc.hasNextInt() | true si lo siguiente es un entero (para validar) |
Scanner sc = new Scanner(System.in);
System.out.print("Edad: ");
int edad = sc.nextInt();
sc.nextLine(); // limpia el salto de línea que deja nextInt()
System.out.print("Nombre: ");
String nombre = sc.nextLine();
| Condicionales y bucles | Qué hace |
|---|
if (cond) { ... } else if (otra) { ... } else { ... } | Elige un camino según las condiciones |
switch (dia) { case 1: ...; break; default: ... } | switch clásico: sin break, sigue al siguiente caso |
case 1, 7 -> "Fin de semana"; | switch moderno con flecha: sin break |
String tipo = switch (dia) { ... }; | switch como expresión que devuelve un valor |
for (int i = 0; i < 5; i++) { ... } | Repite con contador (0 a 4) |
for (String s : lista) { ... } | for-each: recorre arrays y colecciones |
while (cond) { ... } | Repite mientras se cumpla la condición |
do { ... } while (cond); | Se ejecuta al menos una vez (típico en menús) |
break / continue | Sale del bucle / pasa a la siguiente vuelta |
int dia = 3;
String tipo = switch (dia) {
case 1, 7 -> "Fin de semana";
case 2, 3, 4, 5, 6 -> "Laborable";
default -> "Día no válido";
};
System.out.println(tipo); // Laborable
Más en: Scanner · if, else y switch · Bucles
Cadenas: String y StringBuilder
Código (con s = "DevSchool") | Resultado |
|---|
s.length() | 9 |
s.charAt(0) | 'D' |
s.toUpperCase() | "DEVSCHOOL" |
s.substring(0, 3) | "Dev" (el final no se incluye) |
s.substring(3) | "School" |
s.indexOf("o") | 6 (-1 si no está) |
s.contains("School") | true |
s.startsWith("Dev") | true |
" hola ".trim() | "hola" (también strip()) |
" ".isBlank() | true |
"a-b-a".replace("a", "x") | "x-b-x" (todas las apariciones) |
"a,b,c".split(",") | ["a", "b", "c"] (un String[]) |
"hola".equals("Hola") | false (compara siempre con equals, nunca con ==) |
"hola".equalsIgnoreCase("Hola") | true |
"a".compareTo("c") | -2 (negativo: va antes) |
"ab".repeat(3) | "ababab" |
String.join("-", "a", "b", "c") | "a-b-c" |
String.valueOf(42) | "42" |
String.format("%05d", 42) | "00042" |
String.format("%-8s|", "Ana") | "Ana |" (alinea a la izquierda) |
"hola".toCharArray() | ['h', 'o', 'l', 'a'] |
new StringBuilder("Hola").append(" mundo") | "Hola mundo" (modificable, rápido en bucles) |
new StringBuilder("hola").reverse() | "aloh" |
sb.toString() | Convierte el StringBuilder en String |
Character.isDigit('7') | true (también isLetter, isUpperCase) |
Character.toUpperCase('a') | 'A' |
Más en: Cadenas
Math y clases envoltorio
| Código | Resultado |
|---|
Math.round(2.5) | 3 (devuelve long) |
Math.floor(2.7) | 2.0 |
Math.ceil(2.1) | 3.0 |
Math.abs(-5) | 5 |
Math.max(3, 9) / Math.min(3, 9) | 9 / 3 |
Math.pow(2, 10) | 1024.0 |
Math.sqrt(16) | 4.0 |
(int) (Math.random() * 6) + 1 | Entero aleatorio del 1 al 6 |
Integer.parseInt("42") | 42 (texto a int) |
Integer.parseInt("abc") | Lanza NumberFormatException |
Integer.toString(42) | "42" |
Integer.MAX_VALUE | 2147483647 |
Integer n = 5; | Autoboxing: el int se envuelve en un Integer |
Integer a = 1000, b = 1000; a == b | false (compara objetos: usa a.equals(b)) |
Más en: Math y envoltorios
Métodos y recursividad
| Código | Qué hace |
|---|
static int sumar(int a, int b) { return a + b; } | Método que recibe dos int y devuelve un int |
static void saludar(String nombre) { ... } | void: no devuelve nada |
int total = sumar(2, 3); | Llamada: total vale 5 |
static double media(int... notas) | Varargs: acepta cualquier número de argumentos |
| Sobrecarga | Mismo nombre, distintos parámetros: sumar(int, int) y sumar(double, double) |
| Paso por valor | El método recibe una copia; si es un objeto, copia la referencia |
| Caso base | Condición que detiene la recursión |
StackOverflowError | Recursión sin caso base (o demasiado profunda) |
static int factorial(int n) {
if (n <= 1) return 1; // caso base
return n * factorial(n - 1); // llamada recursiva
}
// factorial(5) → 120
Más en: Métodos · Recursividad
Arrays y matrices
| Código | Resultado |
|---|
int[] n = {5, 2, 8}; | Crea un array con valores |
int[] v = new int[3]; | [0, 0, 0] (se rellena con 0, false o null) |
n[0] | 5 (la primera posición es 0) |
n.length | 3 (sin paréntesis) |
n[3] | Lanza ArrayIndexOutOfBoundsException |
Arrays.toString(n) | "[5, 2, 8]" (para imprimirlo) |
Arrays.copyOf(n, 5) | [5, 2, 8, 0, 0] (copia con otro tamaño) |
Arrays.stream(n).sum() | 15 |
Arrays.sort(n) | Ordena el array: [2, 5, 8] |
Arrays.binarySearch(n, 5) | 1 (busca en un array ya ordenado) |
Arrays.fill(v, 7) | [7, 7, 7] |
int[][] m = {{1, 2, 3}, {4, 5, 6}}; | Matriz de 2 filas y 3 columnas |
m[1][2] | 6 (fila 1, columna 2) |
m.length / m[0].length | 2 filas / 3 columnas |
Arrays.deepToString(m) | "[[1, 2, 3], [4, 5, 6]]" |
int[][] m = {{1, 2, 3}, {4, 5, 6}};
int suma = 0;
for (int f = 0; f < m.length; f++) {
for (int c = 0; c < m[f].length; c++) {
suma += m[f][c];
}
}
System.out.println(suma); // 21
Más en: Arrays · Matrices
Clases, encapsulación y paquetes
| Código | Qué hace |
|---|
public class Producto { ... } | Define una clase (un molde de objetos) |
private String nombre; | Atributo privado: solo accesible desde la clase |
public Producto(String nombre) { this.nombre = nombre; } | Constructor; this es el objeto actual |
this(nombre, 0); | Llama a otro constructor de la misma clase |
Producto p = new Producto("Taza"); | Crea un objeto |
public String getNombre() { return nombre; } | Getter |
public void setPrecio(double precio) { ... } | Setter: puede validar antes de asignar |
static int contador; | Atributo compartido por todos los objetos de la clase |
@Override public String toString() | Texto que se muestra al imprimir el objeto |
public record Punto(int x, int y) {} | Clase inmutable con constructor, x(), y(), equals y toString |
public / protected / (nada) / private | Visible desde todo / paquete e hijas / paquete / solo la clase |
package es.devschool.tienda; | Primera línea: paquete al que pertenece la clase |
import java.util.List; / import java.util.*; | Usa una clase / todas las de un paquete |
Más en: Clases y objetos · Encapsulación · Paquetes
Herencia, interfaces, polimorfismo y enums
| Código | Qué hace |
|---|
class Libro extends Producto { ... } | Herencia: Libro es un Producto (solo un padre) |
super(nombre); | Llama al constructor del padre (primera línea) |
super.toString() | Llama al método del padre |
@Override | Marca que sobrescribes un método heredado |
final class / final void metodo() | No se puede heredar / sobrescribir |
abstract class Figura { abstract double area(); } | Clase abstracta: no se puede instanciar |
interface Pagable { double calcularPago(); } | Interfaz: contrato de métodos |
class Factura implements Pagable, Imprimible | Una clase puede implementar varias interfaces |
default void mostrar() { ... } | Método con código dentro de una interfaz |
Producto p = new Libro("Dune"); | Polimorfismo: variable del padre, objeto de la hija |
p instanceof Libro l | true si es un Libro, y lo guarda ya convertido en l |
enum Dia { LUNES, MARTES, MIERCOLES } | Conjunto cerrado de constantes |
Dia.MARTES.ordinal() | 1 |
Dia.valueOf("LUNES") | Dia.LUNES |
Dia.values() | [LUNES, MARTES, MIERCOLES] |
List<Figura> figuras = List.of(new Circulo(1), new Cuadrado(2));
for (Figura f : figuras) {
System.out.println(f.area()); // cada una usa su propia versión
}
Más en: Herencia · Interfaces · Polimorfismo · Enums
Excepciones
| Código | Qué hace |
|---|
try { ... } catch (Exception e) { ... } | Captura un error para que el programa no se detenga |
catch (NumberFormatException | NullPointerException e) | Captura varios tipos en un bloque |
finally { ... } | Se ejecuta siempre |
try (Scanner sc = new Scanner(f)) { ... } | try-with-resources: cierra el recurso solo |
throw new IllegalArgumentException("Precio negativo"); | Lanza una excepción |
void leer() throws IOException | Avisa de que el método puede lanzarla (comprobada) |
e.getMessage() | Texto del error |
class StockException extends Exception { ... } | Excepción propia |
NullPointerException | Usas un objeto que vale null |
ArrayIndexOutOfBoundsException | Índice fuera del array |
NumberFormatException | Integer.parseInt("abc") |
ArithmeticException | División entera entre 0 |
InputMismatchException | El Scanner esperaba otro tipo de dato |
try {
int n = Integer.parseInt("abc");
} catch (NumberFormatException e) {
System.out.println(e.getMessage()); // For input string: "abc"
} finally {
System.out.println("Fin"); // Fin
}
Más en: Excepciones
Colecciones: ArrayList, HashMap y HashSet
| Código | Resultado |
|---|
List<String> l = new ArrayList<>(); | Lista que crece sola (no admite int: usa Integer) |
l.add("uva") / l.add(0, "lima") | Añade al final / en la posición 0 |
l.get(1) | Elemento de la posición 1 |
l.set(1, "mango") | Reemplaza la posición 1 |
l.remove(0) / l.remove("kiwi") | Borra por posición / por valor |
numeros.remove(Integer.valueOf(10)) | Borra el valor 10 en una List<Integer> |
l.size() / l.isEmpty() | Tamaño / si está vacía |
l.contains("uva") / l.indexOf("uva") | ¿Está? / su posición (-1 si no) |
Collections.sort(l) / l.sort(Comparator.reverseOrder()) | Orden ascendente / descendente |
List.of(1, 2, 3) | Lista inmutable: add lanza UnsupportedOperationException |
lista.removeIf(n -> n % 2 == 0) | [1, 2, 3, 4] → [1, 3] |
Map<String, Integer> notas = new HashMap<>(); | Mapa clave-valor |
notas.put("Ana", 8) | Añade o reemplaza |
notas.get("Ana") / notas.get("Eva") | 8 / null |
notas.getOrDefault("Eva", 0) | 0 |
notas.containsKey("Ana") | true |
notas.merge("Ana", 1, Integer::sum) | Suma 1 (útil para contar) |
for (var e : notas.entrySet()) | Recorre pares con e.getKey() y e.getValue() |
new TreeMap<>(notas) | Mapa ordenado por clave |
Set<Integer> s = new HashSet<>(List.of(1, 2, 2, 3)); | [1, 2, 3] (sin repetidos) |
s.add(2) | false (ya estaba) |
new TreeSet<>(List.of(3, 1, 2)) | [1, 2, 3] (ordenado) |
Más en: ArrayList · HashMap y HashSet
Lambdas y streams
Código (con ls = List.of(1, 2, 3, 4, 5)) | Resultado |
|---|
(a, b) -> a + b | Lambda: función sin nombre |
String::length | Referencia a método (equivale a s -> s.length()) |
ls.forEach(System.out::println) | Imprime cada elemento |
ls.stream().map(n -> n * 2).toList() | [2, 4, 6, 8, 10] |
ls.stream().filter(n -> n % 2 == 0).toList() | [2, 4] |
ls.stream().reduce(0, Integer::sum) | 15 |
ls.stream().mapToInt(n -> n).average().orElse(0) | 3.0 |
ls.stream().filter(n -> n > 2).count() | 3 |
ls.stream().anyMatch(n -> n > 4) | true (también allMatch, noneMatch) |
ls.stream().filter(n -> n > 3).findFirst().orElse(-1) | 4 |
ls.stream().sorted(Comparator.reverseOrder()).limit(2).toList() | [5, 4] |
Stream.of("a", "b", "c").collect(Collectors.joining(", ")) | "a, b, c" |
Stream.of("ana", "luis", "eva").collect(Collectors.groupingBy(String::length)) | {3=[ana, eva], 4=[luis]} |
IntStream.rangeClosed(1, 5).sum() | 15 |
lista.sort(Comparator.comparing(Producto::getPrecio)) | Ordena objetos por un atributo |
Más en: Lambdas y streams
Fechas, ficheros y JDBC
| Código | Resultado |
|---|
LocalDate.now() | Fecha de hoy |
LocalDate.of(2026, 1, 15) | 2026-01-15 (los meses empiezan en 1) |
fecha.plusDays(30) | 2026-02-14 (devuelve una fecha nueva) |
LocalDate.of(2026, 3, 31).minusMonths(1) | 2026-02-28 |
fecha.getDayOfWeek() | THURSDAY |
fecha.isBefore(otra) / isAfter(otra) | Compara fechas |
ChronoUnit.DAYS.between(d1, d2) | Días entre dos fechas |
Period.between(nacimiento, hoy).getYears() | Edad en años |
fecha.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")) | "15/01/2026" |
LocalDate.parse("2026-09-30") | Texto ISO a LocalDate |
Files.readAllLines(Path.of("datos.txt")) | Lee un fichero en una List<String> |
Files.writeString(Path.of("salida.txt"), texto) | Escribe texto en un fichero |
new BufferedReader(new FileReader("datos.txt")) | Lector línea a línea con readLine() |
DriverManager.getConnection(url, usuario, clave) | Abre una conexión a la base de datos |
con.prepareStatement("SELECT * FROM clientes WHERE id = ?") | Consulta con parámetros (evita la inyección SQL) |
ps.setInt(1, 5) | Da valor al primer ? |
ResultSet rs = ps.executeQuery(); | Ejecuta un SELECT |
while (rs.next()) { rs.getString("nombre"); } | Recorre las filas del resultado |
ps.executeUpdate() | Ejecuta INSERT, UPDATE o DELETE; devuelve las filas afectadas |
String sql = "SELECT nombre FROM clientes WHERE ciudad = ?";
try (Connection con = DriverManager.getConnection(url, usuario, clave);
PreparedStatement ps = con.prepareStatement(sql)) {
ps.setString(1, "Madrid");
ResultSet rs = ps.executeQuery();
while (rs.next()) {
System.out.println(rs.getString("nombre"));
}
}
Más en: Fechas · Ficheros · JDBC