50 ejercicios de Java resueltos paso a paso

public class IntercambioVariables {
    public static void main(String[] args) {
        int a = 10;
        int b = 25;
        System.out.println("Antes: a=" + a + ", b=" + b);

        a = a + b;   // a = 35
        b = a - b;   // b = 10 (valor original de a)
        a = a - b;   // a = 25 (valor original de b)

        System.out.println("Después: a=" + a + ", b=" + b);
    }
}

public class ConversionTemperatura {
    public static void main(String[] args) {
        double celsius = 36.6;
        double fahrenheit = celsius * 9.0 / 5.0 + 32;
        double kelvin = celsius + 273.15;

        System.out.printf("%.1f °C = %.1f °F = %.2f K%n",
                         celsius, fahrenheit, kelvin);
    }
}

public class DesgloseSegundos {
    public static void main(String[] args) {
        int total = 86523;
        int horas    = total / 3600;
        int minutos  = (total % 3600) / 60;
        int segundos = total % 60;

        System.out.printf("%02d:%02d:%02d%n", horas, minutos, segundos);
    }
}

public class Circulo {
    public static void main(String[] args) {
        double radio = 7.5;
        double area = Math.PI * Math.pow(radio, 2);
        double perimetro = 2 * Math.PI * radio;

        System.out.printf("Radio: %.1f%n", radio);
        System.out.printf("Área: %.4f%n", area);
        System.out.printf("Perímetro: %.4f%n", perimetro);
    }
}

public class CastingTipos {
    public static void main(String[] args) {
        int entero = 257;
        byte casteado = (byte) entero;
        System.out.println("int 257 → byte: " + casteado);

        double decimal = 9.99;
        int truncado = (int) decimal;
        System.out.println("double 9.99 → int: " + truncado);
    }
}

public class ClasificadorNotas {
    public static void main(String[] args) {
        double nota = 7.5;
        String calificacion;

        if (nota < 0 || nota > 10) {
            calificacion = "Nota no válida";
        } else if (nota < 5) {
            calificacion = "Suspenso";
        } else if (nota < 7) {
            calificacion = "Aprobado";
        } else if (nota < 9) {
            calificacion = "Notable";
        } else if (nota < 10) {
            calificacion = "Sobresaliente";
        } else {
            calificacion = "Matrícula de Honor";
        }
        System.out.println("Nota: " + nota + " → " + calificacion);
    }
}

public class Calculadora {
    public static void main(String[] args) {
        double a = 15.0, b = 4.0;
        char op = '/';
        double resultado;

        switch (op) {
            case '+': resultado = a + b; break;
            case '-': resultado = a - b; break;
            case '*': resultado = a * b; break;
            case '/':
                if (b == 0) { System.out.println("Error: división por cero"); return; }
                resultado = a / b; break;
            default:
                System.out.println("Operador no válido"); return;
        }
        System.out.printf("%.1f %c %.1f = %.2f%n", a, op, b, resultado);
    }
}

public class AnioBisiesto {
    public static void main(String[] args) {
        int anio = 2024;
        boolean bisiesto = (anio % 4 == 0 && anio % 100 != 0)
                          || (anio % 400 == 0);
        System.out.println(anio + (bisiesto ? " SÍ es bisiesto" : " NO es bisiesto"));
    }
}

public class ClasificadorTriangulos {
    public static void main(String[] args) {
        double a = 5, b = 5, c = 8;

        if (a + b <= c || a + c <= b || b + c <= a) {
            System.out.println("No forman un triángulo válido"); return;
        }
        if (a == b && b == c) System.out.println("Equilátero");
        else if (a == b || b == c || a == c) System.out.println("Isósceles");
        else System.out.println("Escaleno");
    }
}

public class MayorDeTres {
    public static void main(String[] args) {
        int a = 42, b = 87, c = 65;
        int mayor = (a > b) ? (a > c ? a : c) : (b > c ? b : c);
        System.out.println("Mayor de (" + a + "," + b + "," + c + ") = " + mayor);
    }
}

public class Fibonacci {
    public static void main(String[] args) {
        int n = 20;
        long anterior = 0, actual = 1;

        for (int i = 0; i < n; i++) {
            System.out.print(anterior + (i < n - 1 ? ", " : "\n"));
            long sig = anterior + actual;
            anterior = actual;
            actual = sig;
        }
    }
}

public class NumerosPrimos {
    public static void main(String[] args) {
        int limite = 100, cont = 0;
        for (int num = 2; num <= limite; num++) {
            boolean primo = true;
            for (int d = 2; d <= Math.sqrt(num); d++) {
                if (num % d == 0) { primo = false; break; }
            }
            if (primo) {
                System.out.printf("%4d", num);
                if (++cont % 10 == 0) System.out.println();
            }
        }
        System.out.println("\nTotal: " + cont + " primos");
    }
}

public class Piramide {
    public static void main(String[] args) {
        int filas = 7;
        for (int i = 1; i <= filas; i++) {
            System.out.print(" ".repeat(filas - i));     // espacios
            System.out.println("*".repeat(2 * i - 1)); // asteriscos
        }
    }
}

public class McdEuclides {
    public static void main(String[] args) {
        int a = 48, b = 18;
        int origA = a, origB = b;

        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        System.out.println("MCD(" + origA + ", " + origB + ") = " + a);
    }
}

import java.util.Scanner;
import java.util.Random;

public class AdivinaNumero {
    public static void main(String[] args) {
        int secreto = new Random().nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);
        int intento, intentos = 0;

        System.out.println("Adivina el número (1-100):");

        do {
            System.out.print("Tu intento: ");
            intento = sc.nextInt();
            intentos++;

            if (intento < secreto) System.out.println("↑ Más alto");
            else if (intento > secreto) System.out.println("↓ Más bajo");
        } while (intento != secreto);

        System.out.println("¡Correcto! Lo adivinaste en " + intentos + " intentos.");
        sc.close();
    }
}

public class EstadisticasArray {
    public static void main(String[] args) {
        int[] datos = {23, 8, 45, 12, 67, 34, 91, 56, 3, 78};
        int min = datos[0], max = datos[0], suma = 0, pares = 0;

        for (int v : datos) {
            if (v < min) min = v;
            if (v > max) max = v;
            suma += v;
            if (v % 2 == 0) pares++;
        }
        System.out.printf("Min=%d  Max=%d  Suma=%d  Media=%.2f  Pares=%d%n",
                         min, max, suma, (double) suma / datos.length, pares);
    }
}

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("Antes:   " + Arrays.toString(arr));

        for (int i = 0; i < arr.length - 1; i++) {
            boolean swap = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp;
                    swap = true;
                }
            }
            if (!swap) break;
        }
        System.out.println("Después: " + Arrays.toString(arr));
    }
}

public class BusquedaBinaria {
    static int buscar(int[] arr, int objetivo) {
        int izq = 0, der = arr.length - 1;
        while (izq <= der) {
            int mid = izq + (der - izq) / 2;
            if (arr[mid] == objetivo) return mid;
            else if (arr[mid] < objetivo) izq = mid + 1;
            else der = mid - 1;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] datos = {2, 5, 8, 12, 16, 23, 34, 45, 56, 72, 91};
        System.out.println("34 encontrado en posición: " + buscar(datos, 34));
    }
}

public class MatrizTraspuesta {
    public static void main(String[] args) {
        int[][] m = {{1,2,3}, {4,5,6}, {7,8,9}};
        int[][] t = new int[3][3];

        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                t[j][i] = m[i][j];

        System.out.println("Traspuesta:");
        for (int[] fila : t)
            System.out.println(java.util.Arrays.toString(fila));
    }
}

import java.util.*;

public class EliminarDuplicados {
    public static void main(String[] args) {
        int[] original = {4, 2, 7, 2, 4, 8, 7, 1};
        LinkedHashSet<Integer> set = new LinkedHashSet<>();
        for (int n : original) set.add(n);

        int[] sinDuplicados = set.stream().mapToInt(Integer::intValue).toArray();

        System.out.println("Original: " + Arrays.toString(original));
        System.out.println("Sin dup.:  " + Arrays.toString(sinDuplicados));
    }
}

import java.text.Normalizer;

public class Palindromo {
    static boolean esPalindromo(String texto) {
        String limpio = Normalizer.normalize(texto, Normalizer.Form.NFD)
            .replaceAll("[\\p{M}]", "")
            .replaceAll("[^a-zA-Z0-9]", "")
            .toLowerCase();

        int i = 0, j = limpio.length() - 1;
        while (i < j) {
            if (limpio.charAt(i++) != limpio.charAt(j--)) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        String[] pruebas = {"Anita lava la tina", "Dábale arroz a la zorra el abad", "Hola"};
        for (String t : pruebas)
            System.out.printf("\"%s\" → %s%n", t, esPalindromo(t) ? "SÍ" : "NO");
    }
}

public class ContadorTexto {
    public static void main(String[] args) {
        String texto = "Java 21 es genial";
        int vocales = 0, consonantes = 0, digitos = 0;

        for (char c : texto.toLowerCase().toCharArray()) {
            if ("aeiouáéíóú".indexOf(c) != -1) vocales++;
            else if (Character.isLetter(c)) consonantes++;
            else if (Character.isDigit(c)) digitos++;
        }
        int palabras = texto.trim().split("\\s+").length;

        System.out.printf("Vocales=%d  Consonantes=%d  Dígitos=%d  Palabras=%d%n",
                         vocales, consonantes, digitos, palabras);
    }
}

public class CifradoCesar {
    static String cifrar(String texto, int k) {
        StringBuilder sb = new StringBuilder();
        for (char c : texto.toCharArray()) {
            if (Character.isUpperCase(c))
                sb.append((char) ((c - 'A' + k) % 26 + 'A'));
            else if (Character.isLowerCase(c))
                sb.append((char) ((c - 'a' + k) % 26 + 'a'));
            else sb.append(c);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String orig = "HOLA MUNDO";
        String cifrado = cifrar(orig, 3);
        System.out.println("Cifrado: " + cifrado);
        System.out.println("Descifrado: " + cifrar(cifrado, 23));
    }
}

public class InvertirPalabras {
    public static void main(String[] args) {
        String frase = "Java es poderoso";
        StringBuilder resultado = new StringBuilder();

        for (String palabra : frase.split(" ")) {
            resultado.append(new StringBuilder(palabra).reverse()).append(" ");
        }
        System.out.println(resultado.toString().trim());
    }
}

public class CompresionRLE {
    static String comprimir(String s) {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        while (i < s.length()) {
            char c = s.charAt(i);
            int count = 0;
            while (i < s.length() && s.charAt(i) == c) { count++; i++; }
            sb.append(c).append(count);
        }
        return sb.length() < s.length() ? sb.toString() : s;
    }

    public static void main(String[] args) {
        System.out.println(comprimir("aaabbbccddddee"));  // a3b3c2d4e2
        System.out.println(comprimir("abcde"));           // abcde (no comprime)
    }
}

public class Factorial {
    static long factorialRec(int n) {
        if (n <= 1) return 1;
        return n * factorialRec(n - 1);
    }
    static long factorialIter(int n) {
        long r = 1;
        for (int i = 2; i <= n; i++) r *= i;
        return r;
    }
    public static void main(String[] args) {
        for (int n : new int[]{5, 10, 20})
            System.out.printf("%d! = %d%n", n, factorialIter(n));
    }
}

public class CalculadoraAreas {
    static double calcularArea(double radio) {
        return Math.PI * radio * radio;
    }
    static double calcularArea(double base, double altura) {
        return base * altura;
    }
    static double calcularArea(double base, double altura, boolean esTriangulo) {
        return esTriangulo ? (base * altura / 2) : (base * altura);
    }
    public static void main(String[] args) {
        System.out.printf("Círculo (r=5):    %.2f%n", calcularArea(5.0));
        System.out.printf("Rectángulo (4×6): %.2f%n", calcularArea(4.0, 6.0));
        System.out.printf("Triángulo (4×6):  %.2f%n", calcularArea(4.0, 6.0, true));
    }
}

public class SumaFlexible {
    static int sumar(int... numeros) {
        int total = 0;
        for (int n : numeros) total += n;
        return total;
    }
    public static void main(String[] args) {
        System.out.println(sumar(1, 2));           // 3
        System.out.println(sumar(1, 2, 3, 4, 5)); // 15
        System.out.println(sumar());              // 0
    }
}

public class MaximoGenerico {
    static <T extends Comparable<T>> T maximo(T a, T b, T c) {
        T max = a;
        if (b.compareTo(max) > 0) max = b;
        if (c.compareTo(max) > 0) max = c;
        return max;
    }
    public static void main(String[] args) {
        System.out.println(maximo(3, 7, 5));
        System.out.println(maximo("alfa", "zeta", "beta"));
    }
}

import java.util.Arrays;

public class OrdenarYBuscar {
    static int buscarOrdenado(int[] arr, int objetivo) {
        Arrays.sort(arr);
        return Arrays.binarySearch(arr, objetivo);
    }
    public static void main(String[] args) {
        int[] datos = {45, 12, 78, 34, 23, 56};
        System.out.println("34 en posición: " + buscarOrdenado(datos, 34));
        System.out.println("Ordenado: " + Arrays.toString(datos));
    }
}

public class CuentaBancaria {
    private String titular;
    private double saldo;

    public CuentaBancaria(String titular, double saldoInicial) {
        this.titular = titular;
        this.saldo = Math.max(0, saldoInicial);
    }
    public void depositar(double cantidad) {
        if (cantidad > 0) saldo += cantidad;
    }
    public boolean retirar(double cantidad) {
        if (cantidad > 0 && cantidad <= saldo) { saldo -= cantidad; return true; }
        return false;
    }
    @Override
    public String toString() {
        return String.format("Cuenta[%s, saldo=%.2f€]", titular, saldo);
    }
    public static void main(String[] args) {
        CuentaBancaria c = new CuentaBancaria("Ana", 1000);
        c.depositar(500);
        System.out.println(c);
        System.out.println("Retirar 2000: " + c.retirar(2000));
    }
}

import java.util.*;

public class Estudiante implements Comparable<Estudiante> {
    private String nombre;
    private double nota;

    public Estudiante(String nombre, double nota) {
        this.nombre = nombre; this.nota = nota;
    }
    @Override
    public int compareTo(Estudiante otro) {
        return Double.compare(otro.nota, this.nota);
    }
    @Override
    public String toString() { return String.format("%-12s %.1f", nombre, nota); }

    public static void main(String[] args) {
        List<Estudiante> lista = Arrays.asList(
            new Estudiante("María", 8.5), new Estudiante("Pedro", 9.2),
            new Estudiante("Laura", 7.8));
        Collections.sort(lista);
        lista.forEach(System.out::println);
    }
}

public enum DiaSemana {
    LUNES(8), MARTES(8), MIERCOLES(8), JUEVES(8), VIERNES(7),
    SABADO(0), DOMINGO(0);

    private final int horas;
    DiaSemana(int h) { horas = h; }
    public boolean esLaborable() { return horas > 0; }

    public static void main(String[] args) {
        for (DiaSemana d : DiaSemana.values())
            System.out.printf("%-10s %s (%dh)%n", d,
                d.esLaborable() ? "Laborable" : "Festivo", d.horas);
    }
}

import java.util.Objects;

public final class Punto2D {
    private final double x, y;
    public Punto2D(double x, double y) { this.x = x; this.y = y; }

    public double distanciaA(Punto2D otro) {
        return Math.sqrt(Math.pow(otro.x - x, 2) + Math.pow(otro.y - y, 2));
    }
    public Punto2D trasladar(double dx, double dy) {
        return new Punto2D(x + dx, y + dy);
    }
    @Override public boolean equals(Object o) {
        if (!(o instanceof Punto2D p)) return false;
        return Double.compare(x, p.x) == 0 && Double.compare(y, p.y) == 0;
    }
    @Override public int hashCode() { return Objects.hash(x, y); }
    @Override public String toString() { return "(" + x + ", " + y + ")"; }

    public static void main(String[] args) {
        Punto2D a = new Punto2D(3, 4);
        Punto2D b = a.trasladar(2, -1);
        System.out.printf("Distancia %s → %s = %.2f%n", a, b, a.distanciaA(b));
    }
}

class Direccion {
    private String calle, ciudad;
    private int cp;
    public Direccion(String calle, String ciudad, int cp) {
        this.calle = calle; this.ciudad = ciudad; this.cp = cp;
    }
    @Override public String toString() {
        return calle + ", " + cp + " " + ciudad;
    }
}

public class Persona {
    private String nombre;
    private final Direccion direccion; // Composición: creada en constructor

    public Persona(String nombre, String calle, String ciudad, int cp) {
        this.nombre = nombre;
        this.direccion = new Direccion(calle, ciudad, cp);
    }

    @Override public String toString() {
        return nombre + " — " + direccion;
    }

    public static void main(String[] args) {
        Persona p = new Persona("Ana", "Gran Vía 1", "Madrid", 28013);
        System.out.println(p);
    }
}

abstract class Figura {
    abstract double calcularArea();
    @Override public String toString() {
        return getClass().getSimpleName() + " → Área: " + String.format("%.2f", calcularArea());
    }
}
class Circulo extends Figura {
    double radio;
    Circulo(double r) { radio = r; }
    double calcularArea() { return Math.PI * radio * radio; }
}
class Rectangulo extends Figura {
    double base, altura;
    Rectangulo(double b, double h) { base = b; altura = h; }
    double calcularArea() { return base * altura; }
}
class Triangulo extends Figura {
    double base, altura;
    Triangulo(double b, double h) { base = b; altura = h; }
    double calcularArea() { return base * altura / 2; }
}

public class TestFiguras {
    public static void main(String[] args) {
        Figura[] figuras = { new Circulo(5), new Rectangulo(4, 6), new Triangulo(3, 8) };
        double total = 0;
        for (Figura f : figuras) {
            System.out.println(f);
            total += f.calcularArea(); // Polimorfismo en acción
        }
        System.out.printf("Área total: %.2f%n", total);
    }
}

interface Imprimible {
    void imprimir();
    default String formato() { return "Texto plano"; }
}

class Factura implements Imprimible {
    private double total;
    Factura(double total) { this.total = total; }
    public void imprimir() {
        System.out.printf("FACTURA — Total: %.2f€ [%s]%n", total, formato());
    }
}

class Informe implements Imprimible {
    private String titulo;
    Informe(String t) { titulo = t; }
    public void imprimir() { System.out.println("INFORME: " + titulo); }
    public String formato() { return "PDF"; }
}

public class TestImprimible {
    static void enviarAImpresora(Imprimible doc) { doc.imprimir(); }

    public static void main(String[] args) {
        enviarAImpresora(new Factura(150.50));
        enviarAImpresora(new Informe("Ventas Q1"));
    }
}

abstract class ProcesadorPedido {
    public final void procesar() { // Template method
        validar(); calcularTotal(); enviar();
        System.out.println("Pedido procesado ✓\n");
    }
    abstract void validar();
    abstract void calcularTotal();
    abstract void enviar();
}

class PedidoOnline extends ProcesadorPedido {
    void validar() { System.out.println("Validando tarjeta de crédito..."); }
    void calcularTotal() { System.out.println("Calculando total + envío..."); }
    void enviar() { System.out.println("Enviando confirmación por email..."); }
}

class PedidoTienda extends ProcesadorPedido {
    void validar() { System.out.println("Verificando stock en tienda..."); }
    void calcularTotal() { System.out.println("Calculando total con IVA..."); }
    void enviar() { System.out.println("Imprimiendo ticket..."); }
}

public class TestPedidos {
    public static void main(String[] args) {
        new PedidoOnline().procesar();
        new PedidoTienda().procesar();
    }
}

sealed interface MedioPago permits Tarjeta, Efectivo, Bizum {
    String descripcion();
}

record Tarjeta(String numero) implements MedioPago {
    public String descripcion() { return "Tarjeta ***" + numero.substring(numero.length() - 4); }
}
record Efectivo(double importe) implements MedioPago {
    public String descripcion() { return "Efectivo: " + importe + "€"; }
}
record Bizum(String telefono) implements MedioPago {
    public String descripcion() { return "Bizum a " + telefono; }
}

public class TestPagos {
    public static void main(String[] args) {
        MedioPago[] pagos = { new Tarjeta("4111222233334444"), new Efectivo(50), new Bizum("600123456") };
        for (MedioPago p : pagos) System.out.println(p.descripcion());
    }
}

import java.util.*;

public class OrdenarEmpleados {
    record Empleado(String nombre, double salario) {}

    public static void main(String[] args) {
        List<Empleado> emp = new ArrayList<>(List.of(
            new Empleado("Ana", 45000), new Empleado("Luis", 38000),
            new Empleado("Marta", 52000)));

        // Lambda
        emp.sort((a, b) -> Double.compare(b.salario(), a.salario()));

        // Equivalente con Comparator.comparing
        // emp.sort(Comparator.comparingDouble(Empleado::salario).reversed());

        emp.forEach(e -> System.out.printf("%-8s %.0f€%n", e.nombre(), e.salario()));
    }
}

public class DivisionSegura {
    static int dividir(String sA, String sB) {
        try {
            int a = Integer.parseInt(sA);
            int b = Integer.parseInt(sB);
            return a / b;
        } catch (NumberFormatException e) {
            System.out.println("Error: entrada no numérica → " + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("Error: división por cero");
        } finally {
            System.out.println("Bloque finally ejecutado siempre");
        }
        return 0;
    }

    public static void main(String[] args) {
        System.out.println(dividir("10", "3"));
        System.out.println(dividir("10", "0"));
        System.out.println(dividir("abc", "5"));
    }
}

class SaldoInsuficienteException extends Exception {
    private double deficit;
    SaldoInsuficienteException(double deficit) {
        super("Faltan " + String.format("%.2f€", deficit));
        this.deficit = deficit;
    }
    public double getDeficit() { return deficit; }
}

class Cuenta {
    private double saldo;
    Cuenta(double saldo) { this.saldo = saldo; }

    void retirar(double cantidad) throws SaldoInsuficienteException {
        if (cantidad > saldo)
            throw new SaldoInsuficienteException(cantidad - saldo);
        saldo -= cantidad;
    }
}

public class TestExcepcion {
    public static void main(String[] args) {
        Cuenta c = new Cuenta(100);
        try {
            c.retirar(150);
        } catch (SaldoInsuficienteException e) {
            System.out.println("Operación rechazada: " + e.getMessage());
        }
    }
}

import java.io.*;
import java.nio.file.*;

public class LeerArchivo {
    public static void main(String[] args) {
        Path ruta = Path.of("datos.txt");

        try (BufferedReader br = Files.newBufferedReader(ruta)) {
            String linea;
            int num = 1;
            while ((linea = br.readLine()) != null) {
                System.out.printf("%3d: %s%n", num++, linea);
            }
        } catch (NoSuchFileException e) {
            System.out.println("Archivo no encontrado: " + ruta);
        } catch (IOException e) {
            System.out.println("Error de lectura: " + e.getMessage());
        }
        // br se cierra automáticamente aquí
    }
}

public class MultiCatchDemo {
    static void procesarDato(String dato) {
        try {
            int num = Integer.parseInt(dato);
            int[] arr = new int[5];
            arr[num] = 42;
        } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
            throw new RuntimeException("Error procesando '" + dato + "'", e);
        }
    }

    public static void main(String[] args) {
        try {
            procesarDato("10");
        } catch (RuntimeException e) {
            System.out.println("Excepción: " + e.getMessage());
            System.out.println("Causa: " + e.getCause());
        }
    }
}

import java.util.*;

public class OptionalDemo {
    static Optional<String> buscarUsuario(int id) {
        Map<Integer, String> db = Map.of(1, "Ana", 2, "Pedro", 3, "Laura");
        return Optional.ofNullable(db.get(id));
    }

    public static void main(String[] args) {
        // Forma segura — sin NullPointerException
        String nombre = buscarUsuario(1).orElse("Desconocido");
        System.out.println("Usuario 1: " + nombre);

        buscarUsuario(99).ifPresentOrElse(
            n -> System.out.println("Encontrado: " + n),
            () -> System.out.println("Usuario 99 no existe")
        );
    }
}

import java.util.*;

public class Inventario {
    private Map<String, Integer> stock = new HashMap<>();

    void anadir(String producto, int cantidad) {
        stock.merge(producto, cantidad, Integer::sum);
    }

    boolean vender(String producto, int cantidad) {
        int actual = stock.getOrDefault(producto, 0);
        if (actual < cantidad) return false;
        stock.put(producto, actual - cantidad);
        return true;
    }

    void alertaBajoStock(int umbral) {
        stock.entrySet().stream()
            .filter(e -> e.getValue() <= umbral)
            .sorted(Map.Entry.comparingByValue())
            .forEach(e -> System.out.printf("⚠️ %s: %d uds%n", e.getKey(), e.getValue()));
    }

    public static void main(String[] args) {
        Inventario inv = new Inventario();
        inv.anadir("Teclado", 50); inv.anadir("Ratón", 5); inv.anadir("Monitor", 3);
        inv.vender("Teclado", 48);
        inv.alertaBajoStock(5);
    }
}

import java.util.*;
import java.util.stream.*;

public class AgruparPalabras {
    public static void main(String[] args) {
        List<String> palabras = List.of(
            "Java", "es", "un", "lenguaje", "de",
            "programación", "muy", "poderoso", "y", "versátil");

        Map<Integer, List<String>> porLongitud = palabras.stream()
            .collect(Collectors.groupingBy(String::length));

        porLongitud.forEach((lon, lista) ->
            System.out.printf("%2d letras: %s%n", lon, lista));
    }
}

import java.util.*;

public class Urgencias {
    record Paciente(String nombre, int gravedad) {} // 1=leve, 5=crítico

    public static void main(String[] args) {
        PriorityQueue<Paciente> cola = new PriorityQueue<>(
            Comparator.comparingInt(Paciente::gravedad).reversed());

        cola.add(new Paciente("María", 2));
        cola.add(new Paciente("Pedro", 5));
        cola.add(new Paciente("Ana", 3));
        cola.add(new Paciente("Luis", 1));

        System.out.println("Orden de atención:");
        while (!cola.isEmpty()) {
            Paciente p = cola.poll();
            System.out.printf("  [Gravedad %d] %s%n", p.gravedad(), p.nombre());
        }
    }
}

import java.util.*;
import java.util.stream.*;

public class AnalisisVentas {
    record Venta(String categoria, double importe) {}

    public static void main(String[] args) {
        List<Venta> ventas = List.of(
            new Venta("Electrónica", 599), new Venta("Ropa", 45),
            new Venta("Electrónica", 1200), new Venta("Hogar", 89),
            new Venta("Ropa", 120), new Venta("Hogar", 350),
            new Venta("Electrónica", 25), new Venta("Ropa", 200));

        Map<String, Double> totales = ventas.stream()
            .filter(v -> v.importe() >= 50)
            .collect(Collectors.groupingBy(
                Venta::categoria,
                Collectors.summingDouble(Venta::importe)));

        totales.entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .forEach(e -> System.out.printf("%-15s %,.2f€%n", e.getKey(), e.getValue()));
    }
}

import java.util.*;

public class CacheLRU<K, V> extends LinkedHashMap<K, V> {
    private final int capacidad;

    public CacheLRU(int capacidad) {
        super(capacidad, 0.75f, true); // true = access order
        this.capacidad = capacidad;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacidad;
    }

    public static void main(String[] args) {
        CacheLRU<String, Integer> cache = new CacheLRU<>(3);
        cache.put("A", 1); cache.put("B", 2); cache.put("C", 3);
        System.out.println(cache); // {A=1, B=2, C=3}

        cache.get("A");   // A se vuelve reciente
        cache.put("D", 4); // B es eliminado (más antiguo)
        System.out.println(cache); // {C=3, A=1, D=4}
    }
}

import java.util.*;
import java.util.stream.*;
import java.time.*;

// --- Excepción personalizada ---
class LibroNoDisponibleException extends Exception {
    LibroNoDisponibleException(String isbn) {
        super("Libro con ISBN " + isbn + " no disponible");
    }
}

// --- Entidades ---
enum EstadoLibro { DISPONIBLE, PRESTADO }

class Libro {
    private final String isbn, titulo, autor;
    private EstadoLibro estado = EstadoLibro.DISPONIBLE;

    Libro(String isbn, String titulo, String autor) {
        this.isbn = isbn; this.titulo = titulo; this.autor = autor;
    }
    String getIsbn() { return isbn; }
    String getTitulo() { return titulo; }
    String getAutor() { return autor; }
    EstadoLibro getEstado() { return estado; }
    void setEstado(EstadoLibro e) { estado = e; }

    @Override public String toString() {
        return String.format("[%s] \"%s\" de %s (%s)", isbn, titulo, autor, estado);
    }
}

record Socio(String id, String nombre) {}

record Prestamo(Libro libro, Socio socio, LocalDate fecha) {}

// --- Sistema principal ---
public class Biblioteca {
    private final Map<String, Libro> libros = new HashMap<>();
    private final Map<String, Socio> socios = new HashMap<>();
    private final List<Prestamo> prestamos = new ArrayList<>();
    private static final int MAX_PRESTAMOS = 3;

    void registrarLibro(Libro libro) { libros.put(libro.getIsbn(), libro); }
    void registrarSocio(Socio socio) { socios.put(socio.id(), socio); }

    void prestar(String isbn, String idSocio) throws LibroNoDisponibleException {
        Libro libro = Optional.ofNullable(libros.get(isbn))
            .orElseThrow(() -> new LibroNoDisponibleException(isbn));

        if (libro.getEstado() != EstadoLibro.DISPONIBLE)
            throw new LibroNoDisponibleException(isbn);

        long activos = prestamos.stream()
            .filter(p -> p.socio().id().equals(idSocio)).count();
        if (activos >= MAX_PRESTAMOS)
            throw new RuntimeException("Límite de préstamos alcanzado");

        libro.setEstado(EstadoLibro.PRESTADO);
        prestamos.add(new Prestamo(libro, socios.get(idSocio), LocalDate.now()));
    }

    List<Libro> buscarPorAutor(String autor) {
        return libros.values().stream()
            .filter(l -> l.getAutor().toLowerCase().contains(autor.toLowerCase()))
            .toList();
    }

    void estadisticas() {
        System.out.printf("Libros: %d | Socios: %d | Préstamos activos: %d%n",
            libros.size(), socios.size(), prestamos.size());

        prestamos.stream()
            .collect(Collectors.groupingBy(p -> p.socio().nombre(), Collectors.counting()))
            .forEach((nombre, n) -> System.out.printf("  %s: %d préstamos%n", nombre, n));
    }

    public static void main(String[] args) {
        Biblioteca bib = new Biblioteca();

        bib.registrarLibro(new Libro("978-0", "El Quijote", "Cervantes"));
        bib.registrarLibro(new Libro("978-1", "Clean Code", "Robert Martin"));
        bib.registrarLibro(new Libro("978-2", "Effective Java", "Joshua Bloch"));
        bib.registrarSocio(new Socio("S001", "Ana"));

        try {
            bib.prestar("978-1", "S001");
            bib.prestar("978-2", "S001");
        } catch (LibroNoDisponibleException e) {
            System.out.println(e.getMessage());
        }

        System.out.println("Libros de 'Martin': " + bib.buscarPorAutor("Martin"));
        bib.estadisticas();
    }
}