List<Libro> catalogo = List.of(
        new Libro("978-0000000001", "Java Efectivo", 412, true),
        new Libro("978-0000000002", "Patrones de Diseño", 395, false));

Stream<Libro> flujo = catalogo.stream();

long cuantos = flujo.count();                 // primera operacion terminal: OK
List<Libro> lista = flujo.toList();           // segunda: EXPLOTA

Exception in thread "main" java.lang.IllegalStateException:
    stream has already been operated upon or closed
    at java.base/java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)

long cuantos = catalogo.stream().count();
List<Libro> lista = catalogo.stream().toList();

// ANTES (modulo 5): imperativo. Describe COMO.
List<String> resultado = new ArrayList<>();
for (Libro libro : catalogo) {
    if (libro.getPaginas() > 400 && libro.estaPrestado()) {
        resultado.add(libro.getTitulo());
    }
}
Collections.sort(resultado);

// AHORA: declarativo. Describe QUE.
List<String> resultado = catalogo.stream()
        .filter(libro -> libro.getPaginas() > 400)
        .filter(Libro::estaPrestado)
        .map(Libro::getTitulo)
        .sorted()
        .toList();

// Esto NO IMPRIME NADA y NO RECORRE NADA
catalogo.stream()
        .filter(l -> l.getPaginas() > 400)
        .map(Libro::getTitulo);

(no hay salida)

package com.nexussoftware.bibliotech;

import java.util.List;

public class DemostracionPereza {

    public static void main(String[] args) {

        List<Libro> catalogo = List.of(
                new Libro("978-0000000001", "Java Efectivo",      412),
                new Libro("978-0000000002", "Patrones de Diseño",  395),
                new Libro("978-0000000003", "Refactorización",     448),
                new Libro("978-0000000004", "Código Limpio",       464));

        System.out.println("--- Montando la tubería ---");

        List<String> resultado = catalogo.stream()
                .filter(libro -> {
                    System.out.println("  filter(" + libro.getTitulo() + ")");
                    return libro.getPaginas() > 400;
                })
                .map(libro -> {
                    System.out.println("    map(" + libro.getTitulo() + ")");
                    return libro.getTitulo().toUpperCase();
                })
                .limit(2)
                .toList();

        System.out.println("--- Resultado: " + resultado + " ---");
    }
}

--- Montando la tubería ---
  filter(Java Efectivo)
    map(Java Efectivo)
  filter(Patrones de Diseño)
  filter(Refactorización)
    map(Refactorización)
--- Resultado: [JAVA EFECTIVO, REFACTORIZACIÓN] ---

// Lo que NO hace el stream: tres recorridos y dos listas temporales
List<Libro> filtrados = new ArrayList<>();
for (Libro l : catalogo) if (l.getPaginas() > 400) filtrados.add(l);

List<String> mapeados = new ArrayList<>();
for (Libro l : filtrados) mapeados.add(l.getTitulo().toUpperCase());

List<String> limitados = mapeados.subList(0, Math.min(2, mapeados.size()));

// Stream.iterate genera elementos SIN FIN
List<String> referencias = Stream.iterate(1, n -> n + 1)
        .map(n -> String.format("PR-2026-%04d", n))
        .limit(5)
        .toList();

System.out.println(referencias);

[PR-2026-0001, PR-2026-0002, PR-2026-0003, PR-2026-0004, PR-2026-0005]

// Colecciones
Stream<Libro> s1 = catalogo.stream();
Stream<String> s2 = new HashSet<>(List.of("a", "b")).stream();

// Arrays
String[] empleados = { "Marta Ruiz", "Diego Alonso", "Nuria Vidal" };
Stream<String> s3 = Arrays.stream(empleados);

// Valores sueltos
Stream<String> s4 = Stream.of("978-0000000001", "978-0000000002");

// Infinitos, acotados con limit
Stream<Integer> s5 = Stream.iterate(1, n -> n * 2).limit(10);
Stream<Double> s6 = Stream.generate(Math::random).limit(5);

// Con condicion de parada (Java 9): ya no necesita limit
Stream<Integer> s7 = Stream.iterate(1, n -> n <= 100, n -> n * 2);

// Rango de enteros
IntStream s8 = IntStream.rangeClosed(1, 12);   // 1..12

// Mapa: siempre por sus entradas
Map<String, Integer> prestamosPorEmpleado = Map.of("Marta Ruiz", 4, "Diego Alonso", 2);
Stream<Map.Entry<String, Integer>> s9 = prestamosPorEmpleado.entrySet().stream();

package com.nexussoftware.bibliotech.persistencia;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.List;
import java.util.stream.Stream;

public class ImportadorCatalogo {

    /**
     * Lee un CSV de catalogo con procesamiento PEREZOSO.
     *
     * try-with-resources (06-06) es OBLIGATORIO: Files.lines mantiene
     * abierto un descriptor de fichero hasta que el stream se cierra.
     */
    public List<Libro> importar(Path fichero) throws IOException {

        try (Stream<String> lineas = Files.lines(fichero, StandardCharsets.UTF_8)) {

            return lineas
                    .skip(1)                                    // saltar la cabecera
                    .map(String::strip)
                    .filter(linea -> !linea.isBlank())          // ignorar lineas vacias
                    .filter(linea -> !linea.startsWith("#"))    // ignorar comentarios
                    .map(this::parsear)
                    .filter(java.util.Objects::nonNull)         // descartar las mal formadas
                    .toList();
        }
    }

    private Libro parsear(String linea) {
        String[] campos = linea.split(";", -1);
        if (campos.length < 4) {
            return null;
        }
        try {
            return new Libro(campos[0], campos[1], campos[2], Integer.parseInt(campos[3]));
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /** Cuenta lineas de un fichero de 2 GB sin cargarlo en memoria. */
    public long contarPrestamosDe(Path fichero, String empleado) throws IOException {
        try (Stream<String> lineas = Files.lines(fichero, StandardCharsets.UTF_8)) {
            return lineas.filter(l -> l.contains(empleado)).count();
        }
    }
}

/** Los tres ficheros de respaldo mas recientes de un directorio. */
public List<Path> respaldosRecientes(Path directorio) throws IOException {
    try (Stream<Path> rutas = Files.walk(directorio, 2)) {   // profundidad maxima 2
        return rutas
                .filter(Files::isRegularFile)
                .filter(p -> p.getFileName().toString().endsWith(".bak"))
                .sorted(Comparator.comparing(this::fechaDeModificacion).reversed())
                .limit(3)
                .toList();
    }
}

Stream<Libro> filter(Predicate<? super T> criterio)

List<Libro> prestados = catalogo.stream()
        .filter(Libro::estaPrestado)
        .toList();

// Los predicados se pueden componer (04-06)
Predicate<Libro> largo     = l -> l.getPaginas() > 400;
Predicate<Libro> disponible = l -> !l.estaPrestado();

List<Libro> largosDisponibles = catalogo.stream()
        .filter(largo.and(disponible))
        .toList();

<R> Stream<R> map(Function<? super T, ? extends R> transformacion)

List<String> titulos = catalogo.stream()
        .map(Libro::getTitulo)          // Stream<Libro> -> Stream<String>
        .toList();

// Encadenando transformaciones
List<Integer> longitudes = catalogo.stream()
        .map(Libro::getTitulo)          // Stream<String>
        .map(String::length)            // Stream<Integer>
        .toList();

// A un record (04-07)
List<Ficha> fichas = catalogo.stream()
        .map(l -> new Ficha(l.getIsbn(), l.getTitulo(), !l.estaPrestado()))
        .toList();

// Objeto -> primitivo
int totalPaginas = catalogo.stream()
        .mapToInt(Libro::getPaginas)      // Stream<Libro> -> IntStream
        .sum();                           // sum() SOLO existe en IntStream

// Primitivo -> objeto
List<String> referencias = IntStream.rangeClosed(1, 3)
        .mapToObj(n -> String.format("PR-2026-%04d", n))   // IntStream -> Stream<String>
        .toList();

List<String> empleadosUnicos = prestamos.stream()
        .map(Prestamo::getEmpleado)
        .distinct()
        .toList();

// Orden natural: exige que T implemente Comparable (10-01)
List<String> ordenados = titulos.stream().sorted().toList();

// Con Comparator (05-09)
List<Libro> porPaginas = catalogo.stream()
        .sorted(Comparator.comparingInt(Libro::getPaginas).reversed())
        .toList();

// Ordenacion compuesta
List<Prestamo> ordenados = prestamos.stream()
        .sorted(Comparator.comparing(Prestamo::getEmpleado)
                          .thenComparing(Prestamo::getDiaPrestamo)
                          .reversed())
        .toList();

Stream<T> peek(Consumer<? super T> accion)

List<String> resultado = catalogo.stream()
        .peek(l -> System.out.println("entra: " + l.getTitulo()))
        .filter(l -> l.getPaginas() > 400)
        .peek(l -> System.out.println("  pasa el filtro: " + l.getTitulo()))
        .map(Libro::getTitulo)
        .toList();

List<Libro> primeros3 = catalogo.stream().limit(3).toList();
List<Libro> saltados2 = catalogo.stream().skip(2).toList();

// Paginacion: pagina 3 con 10 elementos por pagina
int pagina = 3, tamano = 10;
List<Libro> paginaActual = catalogo.stream()
        .skip((long) (pagina - 1) * tamano)
        .limit(tamano)
        .toList();

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> transformacion)

public class Empleado {
    private final String nombre;
    private final List<Prestamo> prestamos;

    public List<Prestamo> getPrestamos() { return prestamos; }
    public String getNombre() { return nombre; }
}

List<Empleado> plantilla = List.of(
        new Empleado("Marta Ruiz",   List.of(p1, p2, p3)),
        new Empleado("Diego Alonso", List.of(p4)),
        new Empleado("Nuria Vidal",  List.of(p5, p6)));

// CON map: no es lo que quieres
Stream<List<Prestamo>> conMap = plantilla.stream().map(Empleado::getPrestamos);
List<List<Prestamo>> anidada = conMap.toList();
System.out.println(anidada.size());       // 3: una lista por empleado

// CON flatMap: aplanado
List<Prestamo> todos = plantilla.stream()
        .flatMap(empleado -> empleado.getPrestamos().stream())   // ¡ojo al .stream()!
        .toList();
System.out.println(todos.size());         // 6: todos los prestamos

.flatMap(e -> e.getPrestamos().stream())      // BIEN
.flatMap(Empleado::getPrestamos)              // NO COMPILA: devuelve List, no Stream

// Todos los prestamos con retraso de toda la biblioteca, ordenados
List<Prestamo> conRetraso = plantilla.stream()
        .flatMap(e -> e.getPrestamos().stream())
        .filter(Prestamo::tieneRetraso)
        .sorted(Comparator.comparingInt(Prestamo::getDiasDeRetraso).reversed())
        .toList();

// Todas las incidencias de todos los prestamos de todos los empleados: DOS niveles
List<Prestamo.Incidencia> todasLasIncidencias = plantilla.stream()
        .flatMap(e -> e.getPrestamos().stream())
        .flatMap(p -> p.getIncidencias().stream())
        .toList();

// Partir cadenas en palabras
List<String> palabras = titulos.stream()
        .flatMap(t -> Arrays.stream(t.split("\\s+")))
        .map(String::toLowerCase)
        .distinct()
        .sorted()
        .toList();

// Aplanar un Map<String, List<Prestamo>>
List<Prestamo> planos = porEmpleado.values().stream()
        .flatMap(List::stream)
        .toList();

// Con Optional (Java 9): descartar los vacios de golpe
List<Libro> encontrados = isbns.stream()
        .map(catalogo::buscarPorIsbn)      // Stream<Optional<Libro>>
        .flatMap(Optional::stream)          // Stream<Libro>, sin los vacios
        .toList();

List<Integer> paginas = List.of(500, 480, 450, 380, 420, 300);

System.out.println(paginas.stream().filter(p -> p > 400).toList());
System.out.println(paginas.stream().takeWhile(p -> p > 400).toList());
System.out.println(paginas.stream().dropWhile(p -> p > 400).toList());

[500, 480, 450, 420]      filter: TODOS los mayores de 400
[500, 480, 450]           takeWhile: para en el 380
[380, 420, 300]           dropWhile: descarta hasta el 380, luego todo

// Log ordenado por fecha: leer solo hasta salir del rango, sin recorrer un fichero de 2 GB
try (Stream<String> lineas = Files.lines(logPath, StandardCharsets.UTF_8)) {
    List<String> deHoy = lineas
            .dropWhile(l -> !l.startsWith("2026-08-05"))    // saltar dias anteriores
            .takeWhile(l ->  l.startsWith("2026-08-05"))    // parar al llegar a mañana
            .toList();
}

catalogo.stream()
        .filter(Libro::estaPrestado)
        .forEach(l -> System.out.println(l.getTitulo()));

catalogo.parallelStream().forEach(System.out::println);         // orden impredecible
catalogo.parallelStream().forEachOrdered(System.out::println);  // orden del origen

// Java 16+: la forma corta. Devuelve una lista INMODIFICABLE.
List<String> titulos = catalogo.stream().map(Libro::getTitulo).toList();

// La forma clasica, con Collectors
List<String> titulos2 = catalogo.stream().map(Libro::getTitulo)
        .collect(Collectors.toList());       // modificable, sin garantia de tipo

// Si necesitas una lista modificable de un tipo concreto
List<String> modificable = catalogo.stream().map(Libro::getTitulo)
        .collect(Collectors.toCollection(ArrayList::new));

long prestados = catalogo.stream().filter(Libro::estaPrestado).count();

long n = catalogo.stream()
        .peek(l -> System.out.println("visto: " + l.getTitulo()))
        .count();
// No imprime nada: count() sabe el tamaño de la lista sin recorrerla

Optional<Libro> masLargo = catalogo.stream()
        .max(Comparator.comparingInt(Libro::getPaginas));

masLargo.ifPresent(l -> System.out.println("El más largo: " + l.getTitulo()));

// Con valor por defecto
String titulo = catalogo.stream()
        .min(Comparator.comparing(Libro::getTitulo))
        .map(Libro::getTitulo)
        .orElse("(catálogo vacío)");

boolean hayAlgunoPrestado  = catalogo.stream().anyMatch(Libro::estaPrestado);
boolean todosDisponibles   = catalogo.stream().allMatch(l -> !l.estaPrestado());
boolean ningunoSinTitulo   = catalogo.stream().noneMatch(l -> l.getTitulo().isBlank());

System.out.println(catalogo.stream()
        .peek(l -> System.out.println("comprobando: " + l.getTitulo()))
        .anyMatch(l -> l.getPaginas() > 400));

comprobando: Java Efectivo
true

List<Libro> vacio = List.of();
System.out.println(vacio.stream().anyMatch(l -> true));    // false
System.out.println(vacio.stream().allMatch(l -> false));   // ¡true!
System.out.println(vacio.stream().noneMatch(l -> true));   // true

Optional<Libro> primero = catalogo.stream()
        .filter(l -> l.getPaginas() > 400)
        .findFirst();

Optional<Libro> cualquiera = catalogo.parallelStream()
        .filter(l -> l.getPaginas() > 400)
        .findAny();

Optional<T> reduce(BinaryOperator<T> acumulador)

Optional<Integer> totalPaginas = catalogo.stream()
        .map(Libro::getPaginas)
        .reduce((a, b) -> a + b);

System.out.println(totalPaginas.orElse(0));

paso 1: acumulador = 412           (primer elemento)
paso 2: acumulador = 412 + 395 = 807
paso 3: acumulador = 807 + 448 = 1255
resultado: Optional[1255]

T reduce(T identidad, BinaryOperator<T> acumulador)

int totalPaginas = catalogo.stream()
        .map(Libro::getPaginas)
        .reduce(0, Integer::sum);         // 0 es la identidad

String todosLosTitulos = catalogo.stream()
        .map(Libro::getTitulo)
        .reduce("", (a, b) -> a.isEmpty() ? b : a + " | " + b);

// MAL: identidad incorrecta
int suma = Stream.of(1, 2, 3, 4).reduce(10, Integer::sum);
System.out.println(suma);                              // 20, no 10

int sumaParalela = Stream.of(1, 2, 3, 4).parallel().reduce(10, Integer::sum);
System.out.println(sumaParalela);                      // ¡50! el 10 se sumo en cada particion

<U> U reduce(U identidad, BiFunction<U, ? super T, U> acumulador, BinaryOperator<U> combinador)

// Sumar las paginas de objetos Libro produciendo un int
int totalPaginas = catalogo.parallelStream()
        .reduce(0,                                  // identidad: un int
                (suma, libro) -> suma + libro.getPaginas(),   // acumular Libro en int
                Integer::sum);                      // fundir dos int parciales

List<String> lista = catalogo.stream().map(Libro::getTitulo).collect(Collectors.toList());
Set<String> conjunto = catalogo.stream().map(Libro::getAutor).collect(Collectors.toSet());

// toMap: clave y valor
Map<String, Libro> porIsbn = catalogo.stream()
        .collect(Collectors.toMap(Libro::getIsbn, libro -> libro));

Map<String, String> tituloPorIsbn = catalogo.stream()
        .collect(Collectors.toMap(Libro::getIsbn, Libro::getTitulo));

// Dos libros del mismo autor
Map<String, String> porAutor = catalogo.stream()
        .collect(Collectors.toMap(Libro::getAutor, Libro::getTitulo));

Exception in thread "main" java.lang.IllegalStateException:
    Duplicate key Martin Fowler (attempted merging values Refactorización and UML Destilado)
    at java.base/java.util.stream.Collectors.duplicateKeyException(Collectors.java:135)

// Quedarse con el primero
Map<String, String> primero = catalogo.stream()
        .collect(Collectors.toMap(Libro::getAutor, Libro::getTitulo,
                                  (existente, nuevo) -> existente));

// Quedarse con el ultimo
Map<String, String> ultimo = catalogo.stream()
        .collect(Collectors.toMap(Libro::getAutor, Libro::getTitulo,
                                  (existente, nuevo) -> nuevo));

// Combinar
Map<String, String> combinado = catalogo.stream()
        .collect(Collectors.toMap(Libro::getAutor, Libro::getTitulo,
                                  (a, b) -> a + "; " + b));

// Y con un cuarto argumento se elige la implementacion del Map
Map<String, String> ordenado = catalogo.stream()
        .collect(Collectors.toMap(Libro::getIsbn, Libro::getTitulo,
                                  (a, b) -> a, TreeMap::new));

String titulos = catalogo.stream()
        .map(Libro::getTitulo)
        .collect(Collectors.joining(", "));
// Java Efectivo, Patrones de Diseño, Refactorización

String conBordes = catalogo.stream()
        .map(Libro::getTitulo)
        .collect(Collectors.joining(", ", "Catálogo [", "]"));
// Catálogo [Java Efectivo, Patrones de Diseño, Refactorización]

long total = catalogo.stream().collect(Collectors.counting());

int paginas = catalogo.stream().collect(Collectors.summingInt(Libro::getPaginas));
double media = catalogo.stream().collect(Collectors.averagingInt(Libro::getPaginas));
double sumaValoraciones = catalogo.stream().collect(Collectors.summingDouble(Libro::getValoracion));
double mediaValoraciones = catalogo.stream().collect(Collectors.averagingDouble(Libro::getValoracion));

// Todo de golpe, en un solo recorrido
IntSummaryStatistics stats = catalogo.stream()
        .collect(Collectors.summarizingInt(Libro::getPaginas));

System.out.println("Libros:  " + stats.getCount());
System.out.println("Total:   " + stats.getSum());
System.out.println("Media:   " + stats.getAverage());
System.out.println("Mínimo:  " + stats.getMin());
System.out.println("Máximo:  " + stats.getMax());

Libros:  4
Total:   1719
Media:   429.75
Mínimo:  395
Máximo:  464

Map<TipoMaterial, List<Material>> porTipo = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo));

{LIBRO=[Java Efectivo, Patrones de Diseño, Refactorización],
 REVISTA=[Java Magazine],
 DVD=[Curso de Spring]}

Map<TipoMaterial, List<Material>> porTipo = new HashMap<>();
for (Material m : inventario) {
    porTipo.computeIfAbsent(m.getTipo(), t -> new ArrayList<>()).add(m);
}

// Cuantos materiales de cada tipo
Map<TipoMaterial, Long> conteoPorTipo = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo, Collectors.counting()));
// {LIBRO=3, REVISTA=1, DVD=1}

// Paginas totales por tipo
Map<TipoMaterial, Integer> paginasPorTipo = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo,
                                       Collectors.summingInt(Material::getPaginas)));

// Valoracion media por tipo
Map<TipoMaterial, Double> mediaPorTipo = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo,
                                       Collectors.averagingDouble(Material::getValoracion)));

// Solo los TITULOS de cada grupo: mapping transforma antes de acumular
Map<TipoMaterial, List<String>> titulosPorTipo = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo,
                                       Collectors.mapping(Material::getTitulo,
                                                          Collectors.toList())));

// El mas valorado de cada tipo: devuelve Optional dentro del mapa
Map<TipoMaterial, Optional<Material>> mejorPorTipo = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo,
                 Collectors.maxBy(Comparator.comparingDouble(Material::getValoracion))));

// Sin el Optional, con maxBy reducido (Java 9)
Map<TipoMaterial, Material> mejorPorTipo2 = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo,
                 Collectors.collectingAndThen(
                     Collectors.maxBy(Comparator.comparingDouble(Material::getValoracion)),
                     opt -> opt.orElse(null))));

// Estadisticas completas por tipo
Map<TipoMaterial, IntSummaryStatistics> statsPorTipo = inventario.stream()
        .collect(Collectors.groupingBy(Material::getTipo,
                                       Collectors.summarizingInt(Material::getPaginas)));

// Con TreeMap para que las claves salgan ordenadas
Map<String, Long> porAutorOrdenado = catalogo.stream()
        .collect(Collectors.groupingBy(Libro::getAutor, TreeMap::new, Collectors.counting()));

// Prestamos por empleado y, dentro, por tipo de material
Map<String, Map<TipoMaterial, List<Prestamo>>> porEmpleadoYTipo = prestamos.stream()
        .collect(Collectors.groupingBy(
                Prestamo::getEmpleado,
                Collectors.groupingBy(p -> p.getMaterial().getTipo())));

// Y con conteo en el nivel interior
Map<String, Map<TipoMaterial, Long>> conteoPorEmpleadoYTipo = prestamos.stream()
        .collect(Collectors.groupingBy(
                Prestamo::getEmpleado,
                Collectors.groupingBy(p -> p.getMaterial().getTipo(),
                                      Collectors.counting())));

{Marta Ruiz={LIBRO=3, DVD=1},
 Diego Alonso={LIBRO=1, REVISTA=2},
 Nuria Vidal={LIBRO=2}}

Map<Boolean, List<Libro>> porDisponibilidad = catalogo.stream()
        .collect(Collectors.partitioningBy(Libro::estaPrestado));

List<Libro> prestados   = porDisponibilidad.get(true);
List<Libro> disponibles = porDisponibilidad.get(false);

// Con downstream
Map<Boolean, Long> conteo = catalogo.stream()
        .collect(Collectors.partitioningBy(l -> l.getPaginas() > 400,
                                           Collectors.counting()));

record ResumenCatalogo(long total, double mediaPaginas) { }

ResumenCatalogo resumen = catalogo.stream()
        .collect(Collectors.teeing(
                Collectors.counting(),
                Collectors.averagingInt(Libro::getPaginas),
                ResumenCatalogo::new));

// Suma sin autoboxing
int totalPaginas = catalogo.stream()
        .mapToInt(Libro::getPaginas)
        .sum();

// Media: devuelve OptionalDouble, porque un stream vacio no tiene media
OptionalDouble media = catalogo.stream()
        .mapToInt(Libro::getPaginas)
        .average();

System.out.printf("Media: %.1f páginas%n", media.orElse(0.0));

// Estadisticas de golpe
IntSummaryStatistics stats = catalogo.stream()
        .mapToInt(Libro::getPaginas)
        .summaryStatistics();

// Rangos
IntStream.range(0, 5).forEach(System.out::println);        // 0,1,2,3,4
IntStream.rangeClosed(1, 5).forEach(System.out::println);  // 1,2,3,4,5

// Volver a objetos
List<Integer> lista = IntStream.rangeClosed(1, 5).boxed().toList();
List<String> refs = IntStream.rangeClosed(1, 3)
        .mapToObj(n -> String.format("PR-2026-%04d", n))
        .toList();

// Caracteres de una cadena
long vocales = "Java Efectivo".chars()
        .filter(c -> "aeiouAEIOU".indexOf(c) >= 0)
        .count();

OptionalDouble media = catalogo.stream().mapToInt(Libro::getPaginas).average();

String texto = media.isPresent()
        ? String.format("%.1f", media.getAsDouble())
        : "sin datos";

// O convirtiendo a Optional<Double>
String texto2 = media.stream().boxed().findFirst()
        .map(d -> String.format("%.1f", d))
        .orElse("sin datos");

List<Libro> resultado = catalogo.parallelStream()      // desde la coleccion
        .filter(l -> l.getPaginas() > 400)
        .toList();

List<Libro> resultado2 = catalogo.stream()
        .parallel()                                    // desde un stream existente
        .filter(l -> l.getPaginas() > 400)
        .toList();

System.out.println("Paralelismo: " + ForkJoinPool.getCommonPoolParallelism());
System.out.println("Núcleos:     " + Runtime.getRuntime().availableProcessors());

Paralelismo: 7
Núcleos:     8

ForkJoinPool poolPropio = new ForkJoinPool(4);
try {
    List<Libro> resultado = poolPropio.submit(() ->
            catalogo.parallelStream().filter(...).toList()).get();
} finally {
    poolPropio.shutdown();
}

package com.nexussoftware.bibliotech;

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

public class MedicionParalela {

    public static void main(String[] args) {

        // ADVERTENCIA: esto es una medicion CASERA. Los numeros son
        // orientativos; para medir de verdad hace falta JMH (10-07).

        List<Integer> pequena = IntStream.range(0, 1_000).boxed().toList();
        List<Integer> grande  = IntStream.range(0, 10_000_000).boxed().toList();

        calentar(grande);

        medir("1.000 elementos, suma trivial, secuencial",
              () -> pequena.stream().mapToLong(Integer::longValue).sum());
        medir("1.000 elementos, suma trivial, PARALELO   ",
              () -> pequena.parallelStream().mapToLong(Integer::longValue).sum());

        medir("10M elementos, suma trivial, secuencial   ",
              () -> grande.stream().mapToLong(Integer::longValue).sum());
        medir("10M elementos, suma trivial, PARALELO     ",
              () -> grande.parallelStream().mapToLong(Integer::longValue).sum());

        medir("10M elementos, calculo caro, secuencial   ",
              () -> grande.stream().mapToLong(MedicionParalela::caro).sum());
        medir("10M elementos, calculo caro, PARALELO     ",
              () -> grande.parallelStream().mapToLong(MedicionParalela::caro).sum());

        // LinkedList: particion cara
        List<Integer> enlazada = new LinkedList<>(IntStream.range(0, 1_000_000).boxed().toList());
        medir("1M en LinkedList, secuencial              ",
              () -> enlazada.stream().mapToLong(Integer::longValue).sum());
        medir("1M en LinkedList, PARALELO                ",
              () -> enlazada.parallelStream().mapToLong(Integer::longValue).sum());
    }

    private static long caro(int n) {
        return (long) (Math.sqrt(n) * Math.log(n + 1) * Math.sin(n));
    }

    private static void calentar(List<Integer> datos) {
        for (int i = 0; i < 5; i++) {
            datos.stream().mapToLong(Integer::longValue).sum();
            datos.parallelStream().mapToLong(Integer::longValue).sum();
        }
    }

    private static void medir(String etiqueta, java.util.function.LongSupplier tarea) {
        long inicio = System.nanoTime();
        long resultado = tarea.getAsLong();
        long ms = (System.nanoTime() - inicio) / 1_000_000;
        System.out.printf("%s -> %6d ms  (resultado: %d)%n", etiqueta, ms, resultado);
    }
}

1.000 elementos, suma trivial, secuencial ->      0 ms  (resultado: 499500)
1.000 elementos, suma trivial, PARALELO    ->      2 ms  (resultado: 499500)
10M elementos, suma trivial, secuencial    ->     58 ms  (resultado: 49999995000000)
10M elementos, suma trivial, PARALELO      ->     21 ms  (resultado: 49999995000000)
10M elementos, cálculo caro, secuencial    ->    712 ms  (resultado: -1583)
10M elementos, cálculo caro, PARALELO      ->    134 ms  (resultado: -1583)
1M en LinkedList, secuencial               ->     11 ms  (resultado: 499999500000)
1M en LinkedList, PARALELO                 ->     34 ms  (resultado: 499999500000)

// CATASTROFICO: ArrayList no es seguro entre hilos (08-06)
List<String> resultado = new ArrayList<>();
catalogo.parallelStream().forEach(l -> resultado.add(l.getTitulo()));

// CORRECTO: collect gestiona la combinacion por ti
List<String> resultado = catalogo.parallelStream()
        .map(Libro::getTitulo)
        .toList();

package com.nexussoftware.bibliotech.servicio;

import java.util.*;

/** VERSION ANTIGUA: la del modulo 5. */
public class EstadisticasBiblioTechAntiguo {

    public Map<TipoMaterial, Long> conteoPorTipo(List<Material> inventario) {
        Map<TipoMaterial, Long> resultado = new HashMap<>();
        for (Material m : inventario) {
            Long actual = resultado.get(m.getTipo());
            resultado.put(m.getTipo(), actual == null ? 1L : actual + 1);
        }
        return resultado;
    }

    public Map<String, List<String>> titulosPorEmpleado(List<Prestamo> prestamos) {
        Map<String, List<String>> resultado = new HashMap<>();
        for (Prestamo p : prestamos) {
            List<String> lista = resultado.get(p.getEmpleado());
            if (lista == null) {
                lista = new ArrayList<>();
                resultado.put(p.getEmpleado(), lista);
            }
            lista.add(p.getMaterial().getTitulo());
        }
        for (List<String> lista : resultado.values()) {
            Collections.sort(lista);
        }
        return resultado;
    }

    public String empleadoConMasPrestamos(List<Prestamo> prestamos) {
        Map<String, Integer> conteo = new HashMap<>();
        for (Prestamo p : prestamos) {
            Integer actual = conteo.get(p.getEmpleado());
            conteo.put(p.getEmpleado(), actual == null ? 1 : actual + 1);
        }
        String mejor = null;
        int maximo = -1;
        for (Map.Entry<String, Integer> e : conteo.entrySet()) {
            if (e.getValue() > maximo) {
                maximo = e.getValue();
                mejor = e.getKey();
            }
        }
        return mejor;                    // null si la lista estaba vacia
    }

    public double mediaPaginasDeLosPrestados(List<Material> inventario) {
        int suma = 0;
        int cuenta = 0;
        for (Material m : inventario) {
            if (m.estaPrestado() && m instanceof Libro) {
                suma += ((Libro) m).getPaginas();
                cuenta++;
            }
        }
        return cuenta == 0 ? 0.0 : (double) suma / cuenta;
    }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.*;

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

/**
 * VERSION CON STREAMS. Mismo comportamiento, un tercio del codigo,
 * y cada metodo se lee como la frase que lo describe.
 */
public class EstadisticasBiblioTech {

    /** Cuantos materiales hay de cada tipo. */
    public Map<TipoMaterial, Long> conteoPorTipo(List<Material> inventario) {
        return inventario.stream()
                .collect(Collectors.groupingBy(Material::getTipo, Collectors.counting()));
    }

    /** Titulos prestados a cada empleado, ordenados alfabeticamente. */
    public Map<String, List<String>> titulosPorEmpleado(List<Prestamo> prestamos) {
        return prestamos.stream()
                .collect(Collectors.groupingBy(
                        Prestamo::getEmpleado,
                        TreeMap::new,
                        Collectors.mapping(p -> p.getMaterial().getTitulo(),
                                           Collectors.collectingAndThen(
                                                   Collectors.toList(),
                                                   lista -> { lista.sort(null); return lista; }))));
    }

    /** El empleado con mas prestamos. Optional en lugar de null. */
    public Optional<String> empleadoConMasPrestamos(List<Prestamo> prestamos) {
        return prestamos.stream()
                .collect(Collectors.groupingBy(Prestamo::getEmpleado, Collectors.counting()))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey);
    }

    /** Media de paginas de los libros prestados. */
    public OptionalDouble mediaPaginasDeLosPrestados(List<Material> inventario) {
        return inventario.stream()
                .filter(Material::estaPrestado)
                .filter(Libro.class::isInstance)         // el instanceof de 10-03
                .map(Libro.class::cast)
                .mapToInt(Libro::getPaginas)
                .average();
    }

    /** Informe completo por tipo: cuenta, paginas y valoracion media. */
    public Map<TipoMaterial, ResumenTipo> informeCompleto(List<Material> inventario) {
        return inventario.stream()
                .collect(Collectors.groupingBy(
                        Material::getTipo,
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                lista -> new ResumenTipo(
                                        lista.size(),
                                        lista.stream().mapToInt(Material::getPaginas).sum(),
                                        lista.stream().mapToDouble(Material::getValoracion)
                                             .average().orElse(0.0)))));
    }

    public record ResumenTipo(int cuantos, int paginasTotales, double valoracionMedia) { }

    /** Prestamos por empleado y tipo: el informe de dos niveles. */
    public Map<String, Map<TipoMaterial, Long>> matrizEmpleadoTipo(List<Prestamo> prestamos) {
        return prestamos.stream()
                .collect(Collectors.groupingBy(
                        Prestamo::getEmpleado,
                        TreeMap::new,
                        Collectors.groupingBy(p -> p.getMaterial().getTipo(),
                                              () -> new EnumMap<>(TipoMaterial.class),
                                              Collectors.counting())));
    }

    /** Los N materiales mas valorados. */
    public List<Material> topValorados(List<Material> inventario, int n) {
        return inventario.stream()
                .sorted(Comparator.comparingDouble(Material::getValoracion).reversed())
                .limit(n)
                .toList();
    }

    /** Todas las incidencias de todos los prestamos, agrupadas por gravedad. */
    public Map<Gravedad, List<String>> incidenciasPorGravedad(List<Prestamo> prestamos) {
        return prestamos.stream()
                .flatMap(p -> p.getIncidencias().stream())
                .collect(Collectors.groupingBy(
                        Prestamo.Incidencia::gravedad,
                        () -> new EnumMap<>(Gravedad.class),
                        Collectors.mapping(Prestamo.Incidencia::descripcion,
                                           Collectors.toList())));
    }

    /** Linea de resumen para el panel de la biblioteca. */
    public String resumenEnUnaLinea(List<Material> inventario) {
        return inventario.stream()
                .collect(Collectors.groupingBy(Material::getTipo,
                         () -> new EnumMap<>(TipoMaterial.class),
                         Collectors.counting()))
                .entrySet().stream()
                .map(e -> e.getKey() + "=" + e.getValue())
                .collect(Collectors.joining(", ", "Inventario [", "]"));
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.dominio.*;
import com.nexussoftware.bibliotech.servicio.EstadisticasBiblioTech;

import java.util.List;

public class InformeBiblioTech {

    public static void main(String[] args) {

        List<Material> inventario = DatosDePrueba.inventario();
        List<Prestamo> prestamos  = DatosDePrueba.prestamos();

        EstadisticasBiblioTech stats = new EstadisticasBiblioTech();

        System.out.println("=== INFORME BIBLIOTECH ===");
        System.out.println(stats.resumenEnUnaLinea(inventario));
        System.out.println();

        System.out.println("--- Materiales por tipo ---");
        stats.informeCompleto(inventario).forEach((tipo, r) ->
                System.out.printf("  %-8s %2d unidades, %5d páginas, valoración %.2f%n",
                        tipo, r.cuantos(), r.paginasTotales(), r.valoracionMedia()));

        System.out.println();
        System.out.println("--- Préstamos por empleado y tipo ---");
        stats.matrizEmpleadoTipo(prestamos).forEach((empleado, porTipo) ->
                System.out.printf("  %-14s %s%n", empleado, porTipo));

        System.out.println();
        System.out.println("--- Títulos por empleado ---");
        stats.titulosPorEmpleado(prestamos).forEach((empleado, titulos) ->
                System.out.printf("  %-14s %s%n", empleado, titulos));

        System.out.println();
        stats.empleadoConMasPrestamos(prestamos)
             .ifPresentOrElse(e -> System.out.println("Quien más lee: " + e),
                              () -> System.out.println("No hay préstamos registrados"));

        System.out.printf("Media de páginas de lo prestado: %.1f%n",
                stats.mediaPaginasDeLosPrestados(inventario).orElse(0.0));

        System.out.println();
        System.out.println("--- Top 3 más valorados ---");
        stats.topValorados(inventario, 3)
             .forEach(m -> System.out.printf("  %.2f  %s%n", m.getValoracion(), m.getTitulo()));
    }
}

=== INFORME BIBLIOTECH ===
Inventario [LIBRO=5, REVISTA=2, DVD=1]

--- Materiales por tipo ---
  LIBRO     5 unidades,  2119 páginas, valoración 4,62
  REVISTA   2 unidades,   140 páginas, valoración 3,90
  DVD       1 unidades,     0 páginas, valoración 4,10

--- Préstamos por empleado y tipo ---
  Diego Alonso   {LIBRO=1, REVISTA=2}
  Marta Ruiz     {LIBRO=3, DVD=1}
  Nuria Vidal    {LIBRO=2}

--- Títulos por empleado ---
  Diego Alonso   [Java Magazine 04, Java Magazine 05, Refactorización]
  Marta Ruiz     [Código Limpio, Curso de Spring, Java Efectivo, Patrones de Diseño]
  Nuria Vidal    [Domain-Driven Design, Java Efectivo]

Quien más lee: Marta Ruiz
Media de páginas de lo prestado: 428,3
--- Top 3 más valorados ---
  4,85  Java Efectivo
  4,72  Refactorización
  4,60  Patrones de Diseño

public Prestamo buscarPorReferencia(String referencia) {
    for (Prestamo p : prestamos) {
        if (p.getReferencia().equals(referencia)) {
            return p;
        }
    }
    return null;                       // "no encontrado"
}

Prestamo p = registro.buscarPorReferencia("PR-2026-0041");
System.out.println(p.getEmpleado());       // NullPointerException si no existe

public Optional<Prestamo> buscarPorReferencia(String referencia) {
    for (Prestamo p : prestamos) {
        if (p.getReferencia().equals(referencia)) {
            return Optional.of(p);
        }
    }
    return Optional.empty();
}

Optional<Prestamo> p = registro.buscarPorReferencia("PR-2026-0041");
// p.getEmpleado();       // NO COMPILA: Optional no tiene getEmpleado()

String empleado = p.map(Prestamo::getEmpleado).orElse("(sin préstamo)");

// of: el valor NO puede ser null. Si lo es, NullPointerException inmediata.
Optional<Libro> a = Optional.of(libro);

// ofNullable: acepta null y produce un Optional vacio
Optional<Libro> b = Optional.ofNullable(puedeSerNull);

// empty: explicitamente vacio
Optional<Libro> c = Optional.empty();

// MAL: si el mapa no tiene la clave, esto lanza NullPointerException
Optional<Libro> libro = Optional.of(mapa.get(isbn));

// BIEN
Optional<Libro> libro = Optional.ofNullable(mapa.get(isbn));

// map: transforma el valor si existe. Si esta vacio, sigue vacio.
Optional<String> titulo = catalogo.buscarPorIsbn(isbn).map(Libro::getTitulo);

// Encadenando
String mayusculas = catalogo.buscarPorIsbn(isbn)
        .map(Libro::getTitulo)
        .map(String::toUpperCase)
        .orElse("DESCONOCIDO");

// filter: vacia el Optional si no cumple
Optional<Libro> largoYDisponible = catalogo.buscarPorIsbn(isbn)
        .filter(l -> l.getPaginas() > 400)
        .filter(l -> !l.estaPrestado());

public class Libro {
    public Optional<String> getEditorial() { ... }   // puede no tenerla
}

// Con map: te quedan Optionals anidados
Optional<Optional<String>> mal = catalogo.buscarPorIsbn(isbn).map(Libro::getEditorial);

// Con flatMap: aplanado
Optional<String> bien = catalogo.buscarPorIsbn(isbn).flatMap(Libro::getEditorial);

// orElse: valor por defecto
String titulo = opt.map(Libro::getTitulo).orElse("(desconocido)");

// orElseGet: valor por defecto CALCULADO PEREZOSAMENTE (apartado 18)
Libro libro = opt.orElseGet(() -> cargarDesdeRed(isbn));

// orElseThrow: lanzar si no hay
Libro libro2 = opt.orElseThrow(() ->
        new BiblioTechException("No existe el material " + isbn));

// orElseThrow() sin argumentos (Java 10): lanza NoSuchElementException
Libro libro3 = opt.orElseThrow();

// or: otro Optional si este esta vacio (Java 9)
Optional<Libro> encontrado = catalogoLocal.buscarPorIsbn(isbn)
        .or(() -> catalogoRemoto.buscarPorIsbn(isbn))
        .or(() -> catalogoHistorico.buscarPorIsbn(isbn));

// ifPresent: hacer algo si hay valor
catalogo.buscarPorIsbn(isbn).ifPresent(l -> System.out.println("Encontrado: " + l.getTitulo()));

// ifPresentOrElse: y si no, otra cosa (Java 9)
catalogo.buscarPorIsbn(isbn).ifPresentOrElse(
        l  -> System.out.println("Encontrado: " + l.getTitulo()),
        () -> System.out.println("No hay ningún material con ISBN " + isbn));

List<String> isbns = List.of("978-0000000001", "978-9999999999", "978-0000000003");

// ANTES de Java 9: dos pasos
List<Libro> encontrados1 = isbns.stream()
        .map(catalogo::buscarPorIsbn)      // Stream<Optional<Libro>>
        .filter(Optional::isPresent)
        .map(Optional::get)
        .toList();

// DESDE Java 9: un paso
List<Libro> encontrados2 = isbns.stream()
        .map(catalogo::buscarPorIsbn)      // Stream<Optional<Libro>>
        .flatMap(Optional::stream)          // Stream<Libro>, sin los vacios
        .toList();

T orElse(T otro)                    // recibe un VALOR ya calculado
T orElseGet(Supplier<? extends T> proveedor)   // recibe una FUNCION que lo calcula

package com.nexussoftware.bibliotech;

import java.util.Optional;

public class OrElseFrenteAOrElseGet {

    private static Libro cargarDesdeRed(String isbn) {
        System.out.println("  >>> CONSULTANDO LA RED para " + isbn + " (300 ms)");
        return new Libro(isbn, "Recuperado de la red");
    }

    public static void main(String[] args) {

        Optional<Libro> conValor = Optional.of(new Libro("978-0000000001", "Java Efectivo"));

        System.out.println("--- orElse con valor presente ---");
        Libro a = conValor.orElse(cargarDesdeRed("978-0000000001"));
        System.out.println("Resultado: " + a.getTitulo());

        System.out.println();
        System.out.println("--- orElseGet con valor presente ---");
        Libro b = conValor.orElseGet(() -> cargarDesdeRed("978-0000000001"));
        System.out.println("Resultado: " + b.getTitulo());

        System.out.println();
        System.out.println("--- orElseGet con Optional vacío ---");
        Libro c = Optional.<Libro>empty().orElseGet(() -> cargarDesdeRed("978-9999999999"));
        System.out.println("Resultado: " + c.getTitulo());
    }
}

--- orElse con valor presente ---
  >>> CONSULTANDO LA RED para 978-0000000001 (300 ms)
Resultado: Java Efectivo

--- orElseGet con valor presente ---
Resultado: Java Efectivo

--- orElseGet con Optional vacío ---
  >>> CONSULTANDO LA RED para 978-9999999999 (300 ms)
Resultado: Recuperado de la red

// Un contador que se incrementa aunque el valor exista
int siguienteId = opt.orElse(generarNuevoId());     // ¡genera un ID siempre!

// Un Optional vacio que produce NullPointerException
String s = opt.orElse(otro.getTitulo());            // si 'otro' es null, explota siempre

// BIEN: constante
String titulo = opt.map(Libro::getTitulo).orElse("(sin título)");

// BIEN: calculo caro, evaluado solo si hace falta
Libro libro = opt.orElseGet(() -> cargarDesdeRed(isbn));

// BIEN: excepcion construida solo si hace falta
// (construir una excepcion captura la traza de pila, que no es gratis)
Libro libro2 = opt.orElseThrow(() -> new BiblioTechException("No existe " + isbn));

// MAL: es un if disfrazado, con mas ruido que el null original
Optional<Libro> opt = catalogo.buscarPorIsbn(isbn);
if (opt.isPresent()) {
    System.out.println(opt.get().getTitulo());
} else {
    System.out.println("No encontrado");
}

// BIEN
catalogo.buscarPorIsbn(isbn).ifPresentOrElse(
        l  -> System.out.println(l.getTitulo()),
        () -> System.out.println("No encontrado"));

// O si necesitas el valor
String titulo = catalogo.buscarPorIsbn(isbn)
        .map(Libro::getTitulo)
        .orElse("No encontrado");

// MAL
public List<Libro> buscar(String texto, Optional<TipoMaterial> tipo) { ... }

// BIEN
public List<Libro> buscar(String texto) {
    return buscar(texto, null);
}

public List<Libro> buscar(String texto, TipoMaterial tipo) { ... }

// MAL
public class Libro {
    private Optional<String> editorial;      // NO
}

// BIEN: el campo es null; el ACCESOR devuelve Optional
public class Libro {

    private String editorial;                // puede ser null

    public Optional<String> getEditorial() {
        return Optional.ofNullable(editorial);
    }
}

// MAL
public Optional<List<Prestamo>> prestamosDe(String empleado) { ... }

// BIEN: una lista vacia YA significa "no hay nada"
public List<Prestamo> prestamosDe(String empleado) {
    return prestamos.stream()
            .filter(p -> p.getEmpleado().equals(empleado))
            .toList();                       // vacia si no hay ninguno
}

// MAL: NullPointerException garantizada
return Optional.of(mapa.get(clave));

// PEOR: un metodo que devuelve Optional y a veces devuelve null
public Optional<Libro> buscar(String isbn) {
    if (isbn == null) return null;           // ¡destruye todo el propósito!
    ...
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Identificable;

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Repositorio generico (10-01) con API de streams y Optional (10-04).
 */
public class Repositorio<T extends Identificable> {

    private final Map<String, T> porId = new ConcurrentHashMap<>();
    private final String nombre;

    public Repositorio(String nombre) {
        this.nombre = Objects.requireNonNull(nombre, "nombre");
    }

    public Optional<T> guardar(T entidad) {
        Objects.requireNonNull(entidad, "entidad");
        return Optional.ofNullable(porId.put(entidad.getId(), entidad));
    }

    /** La firma DICE que puede no encontrar nada. */
    public Optional<T> buscarPorId(String id) {
        return Optional.ofNullable(porId.get(id));
    }

    public Optional<T> eliminar(String id) {
        return Optional.ofNullable(porId.remove(id));
    }

    /**
     * Expone un stream en lugar de una copia de la lista.
     * Quien llama decide que hacer sin que el repositorio
     * tenga que ofrecer un metodo por cada consulta.
     */
    public Stream<T> flujo() {
        return porId.values().stream();
    }

    /** Nunca null: una lista vacia ya significa "ninguno". */
    public List<T> buscar(Predicate<? super T> criterio) {
        return flujo().filter(criterio).toList();
    }

    /** El primero que cumpla, o vacio. */
    public Optional<T> buscarPrimero(Predicate<? super T> criterio) {
        return flujo().filter(criterio).findFirst();
    }

    public List<T> listarOrdenado(Comparator<? super T> orden) {
        return flujo().sorted(orden).toList();
    }

    public long contar(Predicate<? super T> criterio) {
        return flujo().filter(criterio).count();
    }

    public boolean existeAlguno(Predicate<? super T> criterio) {
        return flujo().anyMatch(criterio);
    }

    /** Indexa por cualquier clave derivada. */
    public <K> Map<K, List<T>> agrupar(Function<? super T, ? extends K> clasificador) {
        return flujo().collect(Collectors.groupingBy(clasificador));
    }

    public int tamano() {
        return porId.size();
    }

    @Override
    public String toString() {
        return "Repositorio[" + nombre + ", " + porId.size() + " entidades]";
    }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.anotaciones.Auditable;
import com.nexussoftware.bibliotech.dominio.*;

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

public class GestorPrestamos implements ServicioPrestamos {

    private final Repositorio<Material> catalogo;
    private final Repositorio<Prestamo> prestamos;

    public GestorPrestamos(Repositorio<Material> catalogo, Repositorio<Prestamo> prestamos) {
        this.catalogo = catalogo;
        this.prestamos = prestamos;
    }

    /**
     * ANTES: buscarPorId devolvia null y habia que comprobarlo.
     * AHORA: la ausencia se encadena y produce el fallo correcto.
     */
    @Override
    @Auditable(value = "prestar", nivel = Gravedad.ALTA, registrarArgumentos = true)
    public Resultado<Prestamo> prestar(String isbn, String empleado) {

        return catalogo.buscarPorId(isbn)
                .map(material -> registrar(material, empleado))
                .orElseGet(() -> Resultado.fallo("No existe ningún material con ISBN " + isbn));
    }

    private Resultado<Prestamo> registrar(Material material, String empleado) {
        if (material.estaPrestado()) {
            return Resultado.fallo("El material '" + material.getTitulo() + "' ya está prestado");
        }
        material.marcarPrestado(empleado);
        Prestamo prestamo = new Prestamo(siguienteReferencia(), material.getId(), empleado);
        prestamos.guardar(prestamo);
        return Resultado.exito(prestamo);
    }

    /** Lista vacia, nunca null. */
    @Override
    public List<Prestamo> prestamosDe(String empleado) {
        return prestamos.buscar(p -> p.getEmpleado().equals(empleado));
    }

    /** Optional en lugar de null. */
    @Override
    public Optional<Prestamo> buscarPorReferencia(String referencia) {
        return prestamos.buscarPorId(referencia);
    }

    /** El titulo del material prestado a un empleado que mas retraso lleva. */
    public Optional<String> materialMasRetrasadoDe(String empleado) {
        return prestamos.flujo()
                .filter(p -> p.getEmpleado().equals(empleado))
                .filter(Prestamo::tieneRetraso)
                .max(Comparator.comparingInt(Prestamo::getDiasDeRetraso))
                .flatMap(p -> catalogo.buscarPorId(p.getIsbn()))   // flatMap: devuelve Optional
                .map(Material::getTitulo);
    }

    /** Deuda total de multas por empleado, solo de quienes deben algo. */
    public Map<String, Double> deudaPorEmpleado(CalculadoraMultas calculadora) {
        return prestamos.flujo()
                .filter(Prestamo::tieneRetraso)
                .collect(Collectors.groupingBy(
                        Prestamo::getEmpleado,
                        TreeMap::new,
                        Collectors.summingDouble(p -> calculadora.calcular(p.getDiasDeRetraso()))));
    }

    private String siguienteReferencia() {
        return String.format("PR-2026-%04d", prestamos.tamano() + 1);
    }
}

gestor.prestar("978-0000000001", "Marta Ruiz")
      .map(Prestamo::getId)
      .map(id -> "Préstamo registrado: " + id)
      .ifPresent(System.out::println);

gestor.materialMasRetrasadoDe("Diego Alonso")
      .ifPresentOrElse(
              t  -> System.out.println("Devolver urgentemente: " + t),
              () -> System.out.println("Diego Alonso no tiene retrasos"));

gestor.deudaPorEmpleado(calculadora)
      .forEach((empleado, deuda) -> System.out.printf("  %-14s %.2f €%n", empleado, deuda));

Préstamo registrado: PR-2026-0009
Devolver urgentemente: Refactorización
  Diego Alonso   3,25 €
  Marta Ruiz     1,50 €

Predicate<Libro> esLargoYEstaPrestado = l -> l.getPaginas() > 400 && l.estaPrestado();
List<Libro> resultado = catalogo.stream().filter(esLargoYEstaPrestado).toList();

2026-08-05|INFO|prestar|Marta Ruiz|12
2026-08-05|SEVERE|devolver|Diego Alonso|340

package com.nexussoftware.bibliotech.presentacion;

import com.nexussoftware.bibliotech.dominio.*;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * Panel de la biblioteca generado enteramente con streams.
 * Ni un for, ni un null, ni un Optional.get().
 */
public class PanelBiblioTech {

    private final List<Material> inventario;
    private final List<Prestamo> prestamos;

    public PanelBiblioTech(List<Material> inventario, List<Prestamo> prestamos) {
        this.inventario = List.copyOf(inventario);
        this.prestamos  = List.copyOf(prestamos);
    }

    public String generar() {
        StringBuilder sb = new StringBuilder();
        sb.append("=".repeat(58)).append('\n');
        sb.append("        PANEL DE BIBLIOTECH -- Nexus Software\n");
        sb.append("=".repeat(58)).append('\n');

        seccionInventario(sb);
        seccionTop(sb);
        seccionPrestamos(sb);
        seccionRanking(sb);
        seccionPaginas(sb);
        seccionNuncaPrestados(sb);
        seccionHistograma(sb);

        return sb.toString();
    }

    // --- 1. Inventario por tipo ---
    private void seccionInventario(StringBuilder sb) {
        Map<TipoMaterial, Long> porTipo = inventario.stream()
                .collect(Collectors.groupingBy(Material::getTipo,
                         () -> new EnumMap<>(TipoMaterial.class),
                         Collectors.counting()));

        sb.append("\n1. INVENTARIO (").append(inventario.size()).append(" materiales)\n");
        porTipo.forEach((tipo, n) ->
                sb.append(String.format("   %-10s %3d  %s%n", tipo, n, "#".repeat(n.intValue()))));
    }

    // --- 2. Top 3 mas valorados ---
    private void seccionTop(StringBuilder sb) {
        sb.append("\n2. MEJOR VALORADOS\n");
        inventario.stream()
                .sorted(Comparator.comparingDouble(Material::getValoracion).reversed())
                .limit(3)
                .forEach(m -> sb.append(String.format("   %.2f  %s%n",
                        m.getValoracion(), m.getTitulo())));
    }

    // --- 3. Prestamos por empleado ---
    private void seccionPrestamos(StringBuilder sb) {
        Map<String, List<String>> porEmpleado = prestamos.stream()
                .collect(Collectors.groupingBy(
                        Prestamo::getEmpleado,
                        TreeMap::new,
                        Collectors.mapping(Prestamo::getTituloMaterial,
                                Collectors.collectingAndThen(
                                        Collectors.toList(),
                                        lista -> lista.stream().sorted().toList()))));

        sb.append("\n3. PRÉSTAMOS ACTIVOS\n");
        porEmpleado.forEach((empleado, titulos) -> {
            sb.append(String.format("   %-14s (%d)%n", empleado, titulos.size()));
            titulos.forEach(t -> sb.append("      - ").append(t).append('\n'));
        });
    }

    // --- 4. Rankings, con Optional ---
    private void seccionRanking(StringBuilder sb) {
        sb.append("\n4. RANKINGS\n");

        Optional<String> masPrestamos = prestamos.stream()
                .collect(Collectors.groupingBy(Prestamo::getEmpleado, Collectors.counting()))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey);

        sb.append("   Más préstamos:  ")
          .append(masPrestamos.orElse("(no hay préstamos)")).append('\n');

        Optional<String> masRetraso = prestamos.stream()
                .filter(Prestamo::tieneRetraso)
                .collect(Collectors.groupingBy(Prestamo::getEmpleado,
                         Collectors.summingInt(Prestamo::getDiasDeRetraso)))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(e -> e.getKey() + " (" + e.getValue() + " días)");

        sb.append("   Más retraso:    ")
          .append(masRetraso.orElse("(nadie con retraso)")).append('\n');
    }

    // --- 5. Estadisticas de paginas en UN recorrido ---
    private void seccionPaginas(StringBuilder sb) {
        IntSummaryStatistics stats = inventario.stream()
                .filter(Libro.class::isInstance)
                .map(Libro.class::cast)
                .mapToInt(Libro::getPaginas)
                .summaryStatistics();

        sb.append("\n5. PÁGINAS DE LOS LIBROS\n");
        sb.append(String.format("   libros=%d  media=%.1f  mín=%d  máx=%d  total=%d%n",
                stats.getCount(), stats.getAverage(),
                // Con 0 libros, getMin() devuelve MAX_VALUE: hay que contemplarlo
                stats.getCount() == 0 ? 0 : stats.getMin(),
                stats.getCount() == 0 ? 0 : stats.getMax(),
                stats.getSum()));
    }

    // --- 6. Nunca prestados ---
    private void seccionNuncaPrestados(StringBuilder sb) {
        // Conjunto de ISBN prestados alguna vez: la busqueda pasa a O(1)
        Set<String> prestadosAlgunaVez = prestamos.stream()
                .map(Prestamo::getIsbn)
                .collect(Collectors.toSet());

        List<String> nunca = inventario.stream()
                .filter(m -> !prestadosAlgunaVez.contains(m.getId()))
                .map(Material::getTitulo)
                .sorted()
                .toList();

        sb.append("\n6. NUNCA PRESTADOS (").append(nunca.size()).append(")\n");
        sb.append(nunca.isEmpty()
                ? "   (todo el catálogo ha salido alguna vez)\n"
                : nunca.stream().collect(Collectors.joining("\n   ", "   ", "\n")));
    }

    // --- 7. Histograma por dia de la semana ---
    private void seccionHistograma(StringBuilder sb) {
        String[] dias = { "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo" };

        Map<Integer, Long> porDia = prestamos.stream()
                .collect(Collectors.groupingBy(p -> p.getDiaPrestamo() % 7,
                                               Collectors.counting()));

        long maximo = porDia.values().stream().mapToLong(Long::longValue).max().orElse(1);

        sb.append("\n7. PRÉSTAMOS POR DÍA DE LA SEMANA\n");
        IntStream.range(0, 7).forEach(i -> {
            long n = porDia.getOrDefault(i, 0L);
            int barra = (int) (n * 30 / maximo);
            sb.append(String.format("   %-10s %3d %s%n", dias[i], n, "█".repeat(barra)));
        });
    }
}

==========================================================
        PANEL DE BIBLIOTECH -- Nexus Software
==========================================================

1. INVENTARIO (8 materiales)
   LIBRO        5  #####
   REVISTA      2  ##
   DVD          1  #

2. MEJOR VALORADOS
   4,85  Java Efectivo
   4,72  Refactorización
   4,60  Patrones de Diseño

3. PRÉSTAMOS ACTIVOS
   Diego Alonso   (3)
      - Java Magazine 04
      - Java Magazine 05
      - Refactorización
   Marta Ruiz     (4)
      - Código Limpio
      - Curso de Spring
      - Java Efectivo
      - Patrones de Diseño
   Nuria Vidal    (2)
      - Domain-Driven Design
      - Java Efectivo

4. RANKINGS
   Más préstamos:  Marta Ruiz
   Más retraso:    Diego Alonso (23 días)

5. PÁGINAS DE LOS LIBROS
   libros=5  media=423.8  mín=380  máx=464  total=2119

6. NUNCA PRESTADOS (1)
   UML Destilado

7. PRÉSTAMOS POR DÍA DE LA SEMANA
   Lunes        3 ██████████████████████████████
   Martes       1 ██████████
   Miércoles    2 ████████████████████
   Jueves       0
   Viernes      2 ████████████████████
   Sábado       1 ██████████
   Domingo      0

package com.nexussoftware.bibliotech.servicio;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Analiza el log de BiblioTech con streams perezosos.
 * NUNCA carga el fichero en memoria: un log de 2 GB se procesa igual.
 */
public class AnalizadorLog {

    /** Una linea valida del log. Optional para el parseo (04-07 + 10-04). */
    public record LineaLog(String fecha, String nivel, String operacion,
                           String empleado, long milisegundos) {

        static Optional<LineaLog> parsear(String linea) {
            String[] c = linea.split("\\|", -1);
            if (c.length != 5) {
                return Optional.empty();
            }
            try {
                return Optional.of(new LineaLog(
                        c[0].strip(), c[1].strip(), c[2].strip(), c[3].strip(),
                        Long.parseLong(c[4].strip())));
            } catch (NumberFormatException e) {
                return Optional.empty();
            }
        }
    }

    public record Informe(Map<String, Long> porNivel,
                          List<LineaLog> masLentas,
                          Map<String, Double> mediaPorOperacion,
                          List<String> empleadosConErrores,
                          double porcentajeLentas,
                          long totalValidas,
                          long totalCorruptas) { }

    private final Path fichero;

    public AnalizadorLog(Path fichero) {
        this.fichero = fichero;
    }

    /**
     * UN SOLO recorrido del fichero: se materializan las lineas validas
     * en memoria una vez y se derivan todos los agregados de ahi.
     * Para ficheros que no caben en memoria, cada agregado necesitaria
     * su propio recorrido perezoso.
     */
    public Informe analizar() throws IOException {

        List<LineaLog> validas;
        long total;

        try (Stream<String> lineas = Files.lines(fichero, StandardCharsets.UTF_8)) {
            validas = lineas
                    .filter(l -> !l.isBlank())
                    .map(LineaLog::parsear)
                    .flatMap(Optional::stream)      // descarta las vacias sin get()
                    .toList();
        }
        total = contarLineasNoVacias();

        Map<String, Long> porNivel = validas.stream()
                .collect(Collectors.groupingBy(LineaLog::nivel,
                         TreeMap::new, Collectors.counting()));

        List<LineaLog> masLentas = validas.stream()
                .sorted(Comparator.comparingLong(LineaLog::milisegundos).reversed())
                .limit(5)
                .toList();

        Map<String, Double> mediaPorOperacion = validas.stream()
                .collect(Collectors.groupingBy(LineaLog::operacion,
                         TreeMap::new,
                         Collectors.averagingLong(LineaLog::milisegundos)));

        List<String> empleadosConErrores = validas.stream()
                .filter(l -> "SEVERE".equals(l.nivel()))
                .map(LineaLog::empleado)
                .distinct()
                .sorted()
                .toList();

        long lentas = validas.stream().filter(l -> l.milisegundos() > 200).count();
        double porcentaje = validas.isEmpty() ? 0.0 : lentas * 100.0 / validas.size();

        return new Informe(porNivel, masLentas, mediaPorOperacion, empleadosConErrores,
                           porcentaje, validas.size(), total - validas.size());
    }

    /** La primera linea corrupta, con procesamiento PEREZOSO: para al encontrarla. */
    public Optional<String> primeraCorrupta() throws IOException {
        try (Stream<String> lineas = Files.lines(fichero, StandardCharsets.UTF_8)) {
            return lineas
                    .filter(l -> !l.isBlank())
                    .filter(l -> LineaLog.parsear(l).isEmpty())
                    .findFirst();       // CORTOCIRCUITA: no lee el resto del fichero
        }
    }

    private long contarLineasNoVacias() throws IOException {
        try (Stream<String> lineas = Files.lines(fichero, StandardCharsets.UTF_8)) {
            return lineas.filter(l -> !l.isBlank()).count();
        }
    }

    // ------------------------------------------------------------------

    public static void main(String[] args) throws IOException {

        Path log = Path.of("bibliotech.log");
        generarLogDePrueba(log, 50_000);

        AnalizadorLog analizador = new AnalizadorLog(log);
        Informe informe = analizador.analizar();

        System.out.println("=== ANÁLISIS DEL LOG ===");
        System.out.printf("Líneas válidas: %d, corruptas: %d%n%n",
                informe.totalValidas(), informe.totalCorruptas());

        System.out.println("Operaciones por nivel:");
        informe.porNivel().forEach((n, c) -> System.out.printf("  %-8s %6d%n", n, c));

        System.out.println("\nLas 5 más lentas:");
        informe.masLentas().forEach(l -> System.out.printf("  %6d ms  %-10s %s%n",
                l.milisegundos(), l.operacion(), l.empleado()));

        System.out.println("\nDuración media por operación:");
        informe.mediaPorOperacion().forEach((op, ms) ->
                System.out.printf("  %-12s %7.1f ms%n", op, ms));

        System.out.println("\nEmpleados con errores graves: " + informe.empleadosConErrores());
        System.out.printf("Operaciones por encima de 200 ms: %.2f %%%n",
                informe.porcentajeLentas());

        analizador.primeraCorrupta().ifPresentOrElse(
                l  -> System.out.println("\nPrimera línea corrupta: \"" + l + "\""),
                () -> System.out.println("\nNo hay líneas corruptas"));
    }

    /** Genera el fichero de prueba, tambien con streams. */
    private static void generarLogDePrueba(Path destino, int lineas) throws IOException {
        String[] niveles    = { "INFO", "INFO", "INFO", "WARNING", "SEVERE" };
        String[] operaciones = { "prestar", "devolver", "buscar", "exportar", "renovar" };
        String[] empleados  = { "Marta Ruiz", "Diego Alonso", "Nuria Vidal" };
        Random azar = new Random(42);          // semilla fija: salida reproducible

        List<String> contenido = java.util.stream.IntStream.rangeClosed(1, lineas)
                .mapToObj(i -> {
                    if (i % 9_999 == 0) {
                        return "2026-08-05|LÍNEA CORRUPTA SIN CAMPOS";
                    }
                    return String.format("2026-08-%02d|%s|%s|%s|%d",
                            1 + azar.nextInt(28),
                            niveles[azar.nextInt(niveles.length)],
                            operaciones[azar.nextInt(operaciones.length)],
                            empleados[azar.nextInt(empleados.length)],
                            1 + azar.nextInt(500));
                })
                .toList();

        Files.write(destino, contenido, StandardCharsets.UTF_8);
    }
}

=== ANÁLISIS DEL LOG ===
Líneas válidas: 49995, corruptas: 5

Operaciones por nivel:
  INFO      30012
  SEVERE     9981
  WARNING   10002

Las 5 más lentas:
     500 ms  buscar     Nuria Vidal
     500 ms  prestar    Marta Ruiz
     500 ms  renovar    Diego Alonso
     500 ms  devolver   Marta Ruiz
     500 ms  exportar   Nuria Vidal

Duración media por operación:
  buscar         250.9 ms
  devolver       250.1 ms
  exportar       250.4 ms
  prestar        250.7 ms
  renovar        250.3 ms

Empleados con errores graves: [Diego Alonso, Marta Ruiz, Nuria Vidal]
Operaciones por encima de 200 ms: 59.94 %

Primera línea corrupta: "2026-08-05|LÍNEA CORRUPTA SIN CAMPOS"

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Ficha;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Cache de fichas con API basada en Optional y streams.
 */
public class CacheFichas {

    private final Map<String, Ficha> cache = new ConcurrentHashMap<>();
    private long aciertos = 0;
    private long fallos = 0;

    /** Optional en lugar de null: la firma dice que puede no estar. */
    public Optional<Ficha> buscar(String isbn) {
        Optional<Ficha> resultado = Optional.ofNullable(cache.get(isbn));
        if (resultado.isPresent()) { aciertos++; } else { fallos++; }
        return resultado;
    }

    /** Devuelve la cacheada o la calcula y la guarda. */
    public Ficha obtenerOCalcular(String isbn, Function<String, Ficha> calculo) {
        return cache.computeIfAbsent(isbn, clave -> {
            fallos++;
            return calculo.apply(clave);
        });
    }

    public void guardar(Ficha ficha) {
        cache.put(ficha.isbn(), ficha);
    }

    /** Solo las encontradas, sin isPresent() ni get(). */
    public List<Ficha> buscarTodas(Collection<String> isbns) {
        return isbns.stream()
                .map(cache::get)
                .filter(Objects::nonNull)
                .toList();
    }

    /** Version equivalente pasando por Optional, para ver el idioma. */
    public List<Ficha> buscarTodasConOptional(Collection<String> isbns) {
        return isbns.stream()
                .map(isbn -> Optional.ofNullable(cache.get(isbn)))
                .flatMap(Optional::stream)
                .toList();
    }

    /** true = en caché, false = hay que calcularlas. SIEMPRE las dos claves. */
    public Map<Boolean, List<String>> clasificar(Collection<String> isbns) {
        return isbns.stream()
                .collect(Collectors.partitioningBy(cache::containsKey));
    }

    public int tamano() { return cache.size(); }

    public double tasaAciertos() {
        long total = aciertos + fallos;
        return total == 0 ? 0.0 : (double) aciertos / total;
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.dominio.Ficha;

import java.util.*;
import java.util.concurrent.ForkJoinPool;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class BancoDePruebasParalelo {

    /** Calculo caro que simula generar una ficha. */
    private static Ficha calcularFicha(String isbn) {
        double acumulado = 0;
        for (int i = 1; i <= 2_000; i++) {
            acumulado += Math.sqrt(i) * Math.log(i + isbn.hashCode() % 7 + 8);
        }
        return new Ficha(isbn, "Ficha " + isbn + " (" + (long) acumulado + ")", true);
    }

    public static void main(String[] args) {

        System.out.println("Núcleos disponibles: " + Runtime.getRuntime().availableProcessors());
        System.out.println("Paralelismo del commonPool: "
                + ForkJoinPool.getCommonPoolParallelism());
        System.out.println();

        System.out.printf("%-12s %14s %14s %10s%n",
                "TAMAÑO", "SECUENCIAL", "PARALELO", "MEJORA");
        System.out.println("-".repeat(54));

        for (int tamano : new int[] { 100, 10_000, 1_000_000 }) {
            List<String> isbns = generarIsbns(tamano);

            // CALENTAMIENTO: sin esto se mide el interprete, no el codigo compilado (10-07)
            calentar(isbns.subList(0, Math.min(500, tamano)));

            long secuencial = medirMediana(() ->
                    isbns.stream().map(BancoDePruebasParalelo::calcularFicha).count());

            long paralelo = medirMediana(() ->
                    isbns.parallelStream().map(BancoDePruebasParalelo::calcularFicha).count());

            System.out.printf("%-12d %11d ms %11d ms %9.2fx%n",
                    tamano, secuencial, paralelo,
                    paralelo == 0 ? 0.0 : (double) secuencial / paralelo);
        }

        System.out.println();
        demostrarCorrupcionParalela();
    }

    private static List<String> generarIsbns(int cuantos) {
        return IntStream.rangeClosed(1, cuantos)
                .mapToObj(n -> String.format("978-%010d", n))
                .toList();
    }

    private static void calentar(List<String> muestra) {
        for (int i = 0; i < 3; i++) {
            muestra.stream().map(BancoDePruebasParalelo::calcularFicha).count();
            muestra.parallelStream().map(BancoDePruebasParalelo::calcularFicha).count();
        }
    }

    /** Mediana de 5 repeticiones: menos sensible a un pico puntual que la media. */
    private static long medirMediana(Runnable tarea) {
        long[] tiempos = new long[5];
        for (int i = 0; i < tiempos.length; i++) {
            long inicio = System.nanoTime();
            tarea.run();
            tiempos[i] = (System.nanoTime() - inicio) / 1_000_000;
        }
        Arrays.sort(tiempos);
        return tiempos[tiempos.length / 2];
    }

    /** Por que NUNCA se acumula en una coleccion no segura desde un stream paralelo. */
    private static void demostrarCorrupcionParalela() {

        List<String> isbns = generarIsbns(100_000);

        System.out.println("--- Acumular en ArrayList desde parallelStream ---");
        for (int intento = 1; intento <= 3; intento++) {
            List<String> destino = new ArrayList<>();      // NO es seguro entre hilos
            try {
                isbns.parallelStream().forEach(destino::add);
                System.out.printf("  intento %d: esperados 100000, obtenidos %d%s%n",
                        intento, destino.size(),
                        destino.size() == 100_000 ? "" : "   <-- ELEMENTOS PERDIDOS");
            } catch (Exception e) {
                System.out.printf("  intento %d: %s%n", intento, e.getClass().getSimpleName());
            }
        }

        System.out.println("--- La forma correcta: collect ---");
        List<String> correcto = isbns.parallelStream().collect(Collectors.toList());
        System.out.println("  collect: " + correcto.size() + " elementos, siempre");
    }
}

Núcleos disponibles: 8
Paralelismo del commonPool: 7

TAMAÑO           SECUENCIAL       PARALELO     MEJORA
------------------------------------------------------
100                       3 ms           2 ms      1,50x
10000                   287 ms          49 ms      5,86x
1000000               28640 ms        4712 ms      6,08x

--- Acumular en ArrayList desde parallelStream ---
  intento 1: esperados 100000, obtenidos 87423   <-- ELEMENTOS PERDIDOS
  intento 2: ArrayIndexOutOfBoundsException
  intento 3: esperados 100000, obtenidos 92108   <-- ELEMENTOS PERDIDOS
--- La forma correcta: collect ---
  collect: 100000 elementos, siempre