Expresiones lambda en Java

// ❌ Antes de Java 8: clase anónima
Comparator<String> comp1 = new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

// ✅ Con lambda en Java 8+
Comparator<String> comp2 = (a, b) -> a.length() - b.length();

(parámetros) -> expresión
// o bien:
(parámetros) -> { bloque de sentencias; }

// 1. Sin parámetros
Runnable r = () -> System.out.println("Hola");

// 2. Un parámetro (paréntesis opcionales)
Consumer<String> c = s -> System.out.println(s);
Consumer<String> c2 = (s) -> System.out.println(s);  // equivalente

// 3. Múltiples parámetros (paréntesis obligatorios)
BinaryOperator<Integer> suma = (a, b) -> a + b;

// 4. Con tipos explícitos (poco habitual)
BinaryOperator<Integer> suma2 = (Integer a, Integer b) -> a + b;

// 5. Cuerpo con múltiples líneas (llaves + return explícito)
Function<String, Integer> parsear = (texto) -> {
    texto = texto.trim();
    return Integer.parseInt(texto);
};

// 6. Lambda que no devuelve nada
Consumer<String> imprimir = msg -> {
    System.out.println("Mensaje: " + msg);
    System.out.println("Longitud: " + msg.length());
};

@FunctionalInterface
public interface Transformador<T> {
    T transformar(T valor);

    // Métodos default permitidos: no rompen la condición funcional
    default Transformador<T> yLuego(Transformador<T> otra) {
        return valor -> otra.transformar(this.transformar(valor));
    }
}

// Uso con lambda
Transformador<String> aMayusculas = s -> s.toUpperCase();
Transformador<String> sinEspacios = s -> s.trim();

// Composición
Transformador<String> limpiar = sinEspacios.yLuego(aMayusculas);
System.out.println(limpiar.transformar("  hola mundo  "));
// Salida: HOLA MUNDO

import java.util.function.*;

public class InterfacesFuncionalesDemo {
    public static void main(String[] args) {

        // Predicate: ¿es mayor de edad?
        Predicate<Integer> esMayor = edad -> edad >= 18;
        System.out.println(esMayor.test(25));  // true
        System.out.println(esMayor.test(15));  // false

        // Function: convertir nombre a su longitud
        Function<String, Integer> longitud = String::length;
        System.out.println(longitud.apply("Lambda"));  // 6

        // Consumer: imprimir con formato
        Consumer<String> saludar = nombre ->
            System.out.println("¡Hola, " + nombre + "!");
        saludar.accept("Ana");  // ¡Hola, Ana!

        // Supplier: generar un número aleatorio
        Supplier<Double> aleatorio = Math::random;
        System.out.println(aleatorio.get());  // 0.7362... (varía)
    }
}

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

public class StreamsConLambdas {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList(
            "Ana", "Pedro", "María", "Juan", "Alejandra", "Luis"
        );

        // Filtrar, transformar y recolectar en una sola cadena
        List<String> resultado = nombres.stream()
            .filter(n -> n.length() > 4)           // Predicate: más de 4 letras
            .map(String::toUpperCase)                // Function: a mayúsculas
            .sorted()                                // Orden natural
            .collect(Collectors.toList());           // Recoger en lista

        System.out.println(resultado);
        // Salida: [ALEJANDRA, MARÍA, PEDRO]
    }
}

List<Integer> numeros = Arrays.asList(3, 7, 12, 5, 8, 21, 14, 2);

// Suma de los pares
int sumaPares = numeros.stream()
    .filter(n -> n % 2 == 0)
    .reduce(0, Integer::sum);
System.out.println("Suma de pares: " + sumaPares);  // 36

// El mayor de los impares
Optional<Integer> maxImpar = numeros.stream()
    .filter(n -> n % 2 != 0)
    .max(Comparator.naturalOrder());
maxImpar.ifPresent(v -> System.out.println("Mayor impar: " + v));  // 21

// Convertir a strings con formato
String formateados = numeros.stream()
    .map(n -> "[" + n + "]")
    .collect(Collectors.joining(", "));
System.out.println(formateados);  // [3], [7], [12], [5], [8], [21], [14], [2]

List<String> palabras = Arrays.asList("java", "lambda", "stream");

// Lambda explícita
palabras.forEach(p -> System.out.println(p));

// Method reference equivalente (más idiomático)
palabras.forEach(System.out::println);

// Ordenar por longitud — lambda
palabras.sort((a, b) -> Integer.compare(a.length(), b.length()));

// Ordenar por longitud — method reference con Comparator
palabras.sort(Comparator.comparingInt(String::length));

// Convertir strings a enteros — lambda vs method reference
Function<String, Integer> parser1 = s -> Integer.parseInt(s);
Function<String, Integer> parser2 = Integer::parseInt;  // más limpio

public class ClosureDemo {
    private int atributo = 10;  // Los atributos de instancia SÍ pueden cambiar

    public void ejemplo() {
        int multiplicador = 3;  // Effectively final: nunca se reasigna

        // ✅ Correcto: captura variable effectively final
        Function<Integer, Integer> triplicar = n -> n * multiplicador;
        System.out.println(triplicar.apply(5));  // 15

        // ✅ Correcto: captura atributo de instancia (acceso vía this)
        Consumer<Integer> sumar = n -> this.atributo += n;
        sumar.accept(5);
        System.out.println(this.atributo);  // 15

        // ❌ ERROR DE COMPILACIÓN:
        // int contador = 0;
        // Runnable inc = () -> contador++;  // No compila: contador no es effectively final
    }
}

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

// Modelo de datos
class Producto {
    private String nombre;
    private String categoria;
    private double precio;
    private int stock;

    public Producto(String nombre, String categoria, double precio, int stock) {
        this.nombre = nombre;
        this.categoria = categoria;
        this.precio = precio;
        this.stock = stock;
    }

    // Getters
    public String getNombre()    { return nombre; }
    public String getCategoria() { return categoria; }
    public double getPrecio()    { return precio; }
    public int getStock()        { return stock; }

    @Override
    public String toString() {
        return String.format("%s (%.2f€, stock: %d)", nombre, precio, stock);
    }
}

// Motor de búsqueda con lambdas
class BuscadorProductos {

    // Método genérico que acepta cualquier combinación de filtros
    public static List<Producto> buscar(
            List<Producto> catalogo,
            Predicate<Producto> filtro,
            Comparator<Producto> orden,
            int limite) {

        return catalogo.stream()
            .filter(filtro)
            .sorted(orden)
            .limit(limite)
            .collect(Collectors.toList());
    }

    // Fábrica de predicados reutilizables
    public static Predicate<Producto> precioEntre(double min, double max) {
        return p -> p.getPrecio() >= min && p.getPrecio() <= max;
    }

    public static Predicate<Producto> categoriaEs(String cat) {
        return p -> p.getCategoria().equalsIgnoreCase(cat);
    }

    public static Predicate<Producto> conStock() {
        return p -> p.getStock() > 0;
    }
}

// Programa principal
public class TiendaLambda {
    public static void main(String[] args) {
        List<Producto> catalogo = Arrays.asList(
            new Producto("Teclado mecánico",  "Periféricos",  89.99, 15),
            new Producto("Monitor 27\"",      "Monitores",   349.00,  3),
            new Producto("Ratón inalámbrico", "Periféricos",  45.50, 42),
            new Producto("SSD 1TB",           "Almacenamiento", 79.99, 0),
            new Producto("Webcam HD",         "Periféricos",  62.00, 28),
            new Producto("RAM 16GB DDR5",     "Componentes", 125.00, 11),
            new Producto("Monitor 24\"",      "Monitores",   199.00,  7),
            new Producto("Hub USB-C",         "Periféricos",  34.99, 55)
        );

        // Buscar periféricos con stock, entre 30€ y 70€, ordenados por precio
        Predicate<Producto> filtro = BuscadorProductos.categoriaEs("Periféricos")
            .and(BuscadorProductos.conStock())
            .and(BuscadorProductos.precioEntre(30, 70));

        List<Producto> resultados = BuscadorProductos.buscar(
            catalogo,
            filtro,
            Comparator.comparingDouble(Producto::getPrecio),
            10
        );

        System.out.println("=== Periféricos (30-70€, con stock) ===");
        resultados.forEach(System.out::println);

        // Calcular el valor total del stock
        double valorTotal = catalogo.stream()
            .filter(BuscadorProductos.conStock())
            .mapToDouble(p -> p.getPrecio() * p.getStock())
            .sum();
        System.out.printf("\nValor total en stock: %.2f€%n", valorTotal);

        // Resumen por categoría
        Map<String, Long> porCategoria = catalogo.stream()
            .collect(Collectors.groupingBy(
                Producto::getCategoria,
                Collectors.counting()
            ));
        System.out.println("\nProductos por categoría: " + porCategoria);
    }
}

/* Salida esperada:
=== Periféricos (30-70€, con stock) ===
Hub USB-C (34,99€, stock: 55)
Ratón inalámbrico (45,50€, stock: 42)
Webcam HD (62,00€, stock: 28)

Valor total en stock: 14.384,27€

Productos por categoría: {Monitores=2, Almacenamiento=1, Periféricos=4, Componentes=1}
*/

// ❌ No compila: FileReader lanza IOException (checked)
// list.forEach(f -> new FileReader(f));

// ✅ Solución 1: try-catch dentro de la lambda
list.forEach(f -> {
    try {
        new FileReader(f);
    } catch (IOException e) {
        throw new RuntimeException("Error al abrir: " + f, e);
    }
});

// ✅ Solución 2: método wrapper reutilizable
@FunctionalInterface
interface CheckedFunction<T, R> {
    R apply(T t) throws Exception;
}

static <T, R> Function<T, R> unchecked(CheckedFunction<T, R> fn) {
    return t -> {
        try {
            return fn.apply(t);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

// Uso limpio
list.stream()
    .map(unchecked(f -> new FileReader(f)))
    .forEach(System.out::println);