List<Llibre> cataleg = List.of(
        new Llibre("978-0000000001", "Java Eficac", 412, true),
        new Llibre("978-0000000002", "Patrons de Disseny", 395, false));

Stream<Llibre> flux = cataleg.stream();

long quants = flux.count();                   // primera operacio terminal: OK
List<Llibre> llista = flux.toList();          // segona: 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 quants = cataleg.stream().count();
List<Llibre> llista = cataleg.stream().toList();

// ABANS (modul 5): imperatiu. Descriu COM.
List<String> resultat = new ArrayList<>();
for (Llibre llibre : cataleg) {
    if (llibre.getPagines() > 400 && llibre.estaPrestat()) {
        resultat.add(llibre.getTitol());
    }
}
Collections.sort(resultat);

// ARA: declaratiu. Descriu QUE.
List<String> resultat = cataleg.stream()
        .filter(llibre -> llibre.getPagines() > 400)
        .filter(Llibre::estaPrestat)
        .map(Llibre::getTitol)
        .sorted()
        .toList();

// Aixo NO IMPRIMEIX RES i NO RECORRE RES
cataleg.stream()
        .filter(l -> l.getPagines() > 400)
        .map(Llibre::getTitol);

(no hi ha sortida)

package com.nexussoftware.bibliotech;

import java.util.List;

public class DemostracioMandra {

    public static void main(String[] args) {

        List<Llibre> cataleg = List.of(
                new Llibre("978-0000000001", "Java Eficac",        412),
                new Llibre("978-0000000002", "Patrons de Disseny",  395),
                new Llibre("978-0000000003", "Refactoritzacio",     448),
                new Llibre("978-0000000004", "Codi Net",            464));

        System.out.println("--- Muntant la canonada ---");

        List<String> resultat = cataleg.stream()
                .filter(llibre -> {
                    System.out.println("  filter(" + llibre.getTitol() + ")");
                    return llibre.getPagines() > 400;
                })
                .map(llibre -> {
                    System.out.println("    map(" + llibre.getTitol() + ")");
                    return llibre.getTitol().toUpperCase();
                })
                .limit(2)
                .toList();

        System.out.println("--- Resultat: " + resultat + " ---");
    }
}

--- Muntant la canonada ---
  filter(Java Eficac)
    map(Java Eficac)
  filter(Patrons de Disseny)
  filter(Refactoritzacio)
    map(Refactoritzacio)
--- Resultat: [JAVA EFICAC, REFACTORITZACIO] ---

// El que NO fa el stream: tres recorreguts i dues llistes temporals
List<Llibre> filtrats = new ArrayList<>();
for (Llibre l : cataleg) if (l.getPagines() > 400) filtrats.add(l);

List<String> mapejats = new ArrayList<>();
for (Llibre l : filtrats) mapejats.add(l.getTitol().toUpperCase());

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

// Stream.iterate genera elements SENSE FI
List<String> referencies = Stream.iterate(1, n -> n + 1)
        .map(n -> String.format("PR-2026-%04d", n))
        .limit(5)
        .toList();

System.out.println(referencies);

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

// Colleccions
Stream<Llibre> s1 = cataleg.stream();
Stream<String> s2 = new HashSet<>(List.of("a", "b")).stream();

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

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

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

// Amb condicio de parada (Java 9): ja no necessita limit
Stream<Integer> s7 = Stream.iterate(1, n -> n <= 100, n -> n * 2);

// Rang d enters
IntStream s8 = IntStream.rangeClosed(1, 12);   // 1..12

// Mapa: sempre per les seves entrades
Map<String, Integer> prestecsPerEmpleat = Map.of("Marta Ruiz", 4, "Diego Alonso", 2);
Stream<Map.Entry<String, Integer>> s9 = prestecsPerEmpleat.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 ImportadorCataleg {

    /**
     * Llegeix un CSV de cataleg amb processament MANDROS.
     *
     * try-with-resources (06-06) es OBLIGATORI: Files.lines mante
     * obert un descriptor de fitxer fins que el stream es tanca.
     */
    public List<Llibre> importar(Path fitxer) throws IOException {

        try (Stream<String> linies = Files.lines(fitxer, StandardCharsets.UTF_8)) {

            return linies
                    .skip(1)                                    // saltar la capcalera
                    .map(String::strip)
                    .filter(linia -> !linia.isBlank())          // ignorar linies buides
                    .filter(linia -> !linia.startsWith("#"))    // ignorar comentaris
                    .map(this::analitzar)
                    .filter(java.util.Objects::nonNull)         // descartar les mal formades
                    .toList();
        }
    }

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

    /** Compta linies d un fitxer de 2 GB sense carregar lo a memoria. */
    public long comptarPrestecsDe(Path fitxer, String empleat) throws IOException {
        try (Stream<String> linies = Files.lines(fitxer, StandardCharsets.UTF_8)) {
            return linies.filter(l -> l.contains(empleat)).count();
        }
    }
}

/** Els tres fitxers de resguard mes recents d un directori. */
public List<Path> resguardsRecents(Path directori) throws IOException {
    try (Stream<Path> camins = Files.walk(directori, 2)) {   // profunditat maxima 2
        return camins
                .filter(Files::isRegularFile)
                .filter(p -> p.getFileName().toString().endsWith(".bak"))
                .sorted(Comparator.comparing(this::dataDeModificacio).reversed())
                .limit(3)
                .toList();
    }
}

Stream<Llibre> filter(Predicate<? super T> criteri)

List<Llibre> prestats = cataleg.stream()
        .filter(Llibre::estaPrestat)
        .toList();

// Els predicats es poden compondre (04-06)
Predicate<Llibre> llarg      = l -> l.getPagines() > 400;
Predicate<Llibre> disponible = l -> !l.estaPrestat();

List<Llibre> llargsDisponibles = cataleg.stream()
        .filter(llarg.and(disponible))
        .toList();

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

List<String> titols = cataleg.stream()
        .map(Llibre::getTitol)          // Stream<Llibre> -> Stream<String>
        .toList();

// Encadenant transformacions
List<Integer> longituds = cataleg.stream()
        .map(Llibre::getTitol)          // Stream<String>
        .map(String::length)            // Stream<Integer>
        .toList();

// A un record (04-07)
List<Fitxa> fitxes = cataleg.stream()
        .map(l -> new Fitxa(l.getIsbn(), l.getTitol(), !l.estaPrestat()))
        .toList();

// Objecte -> primitiu
int totalPagines = cataleg.stream()
        .mapToInt(Llibre::getPagines)     // Stream<Llibre> -> IntStream
        .sum();                           // sum() NOMES existeix a IntStream

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

List<String> empleatsUnics = prestecs.stream()
        .map(Prestec::getEmpleat)
        .distinct()
        .toList();

// Ordre natural: exigeix que T implementi Comparable (10-01)
List<String> ordenats = titols.stream().sorted().toList();

// Amb Comparator (05-09)
List<Llibre> perPagines = cataleg.stream()
        .sorted(Comparator.comparingInt(Llibre::getPagines).reversed())
        .toList();

// Ordenacio composta
List<Prestec> ordenats = prestecs.stream()
        .sorted(Comparator.comparing(Prestec::getEmpleat)
                          .thenComparing(Prestec::getDiaPrestec)
                          .reversed())
        .toList();

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

List<String> resultat = cataleg.stream()
        .peek(l -> System.out.println("entra: " + l.getTitol()))
        .filter(l -> l.getPagines() > 400)
        .peek(l -> System.out.println("  passa el filtre: " + l.getTitol()))
        .map(Llibre::getTitol)
        .toList();

List<Llibre> primers3 = cataleg.stream().limit(3).toList();
List<Llibre> saltats2 = cataleg.stream().skip(2).toList();

// Paginacio: pagina 3 amb 10 elements per pagina
int pagina = 3, mida = 10;
List<Llibre> paginaActual = cataleg.stream()
        .skip((long) (pagina - 1) * mida)
        .limit(mida)
        .toList();

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

public class Empleat {
    private final String nom;
    private final List<Prestec> prestecs;

    public List<Prestec> getPrestecs() { return prestecs; }
    public String getNom() { return nom; }
}

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

// AMB map: no es el que vols
Stream<List<Prestec>> ambMap = plantilla.stream().map(Empleat::getPrestecs);
List<List<Prestec>> imbricada = ambMap.toList();
System.out.println(imbricada.size());     // 3: una llista per empleat

// AMB flatMap: aplanat
List<Prestec> tots = plantilla.stream()
        .flatMap(empleat -> empleat.getPrestecs().stream())   // compte amb el .stream()!
        .toList();
System.out.println(tots.size());          // 6: tots els prestecs

.flatMap(e -> e.getPrestecs().stream())       // BE
.flatMap(Empleat::getPrestecs)                // NO COMPILA: retorna List, no Stream

// Tots els prestecs amb retard de tota la biblioteca, ordenats
List<Prestec> ambRetard = plantilla.stream()
        .flatMap(e -> e.getPrestecs().stream())
        .filter(Prestec::teRetard)
        .sorted(Comparator.comparingInt(Prestec::getDiesDeRetard).reversed())
        .toList();

// Totes les incidencies de tots els prestecs de tots els empleats: DOS nivells
List<Prestec.Incidencia> totesLesIncidencies = plantilla.stream()
        .flatMap(e -> e.getPrestecs().stream())
        .flatMap(p -> p.getIncidencies().stream())
        .toList();

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

// Aplanar un Map<String, List<Prestec>>
List<Prestec> plans = perEmpleat.values().stream()
        .flatMap(List::stream)
        .toList();

// Amb Optional (Java 9): descartar els buits de cop
List<Llibre> trobats = isbns.stream()
        .map(cataleg::cercarPerIsbn)       // Stream<Optional<Llibre>>
        .flatMap(Optional::stream)          // Stream<Llibre>, sense els buits
        .toList();

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

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

[500, 480, 450, 420]      filter: TOTS els majors de 400
[500, 480, 450]           takeWhile: para al 380
[380, 420, 300]           dropWhile: descarta fins al 380, despres tot

// Log ordenat per data: llegir nomes fins a sortir del rang, sense recorrer un fitxer de 2 GB
try (Stream<String> linies = Files.lines(logPath, StandardCharsets.UTF_8)) {
    List<String> avui = linies
            .dropWhile(l -> !l.startsWith("2026-08-05"))    // saltar dies anteriors
            .takeWhile(l ->  l.startsWith("2026-08-05"))    // parar en arribar a dema
            .toList();
}

cataleg.stream()
        .filter(Llibre::estaPrestat)
        .forEach(l -> System.out.println(l.getTitol()));

cataleg.parallelStream().forEach(System.out::println);         // ordre impredictible
cataleg.parallelStream().forEachOrdered(System.out::println);  // ordre de l origen

// Java 16+: la forma curta. Retorna una llista NO MODIFICABLE.
List<String> titols = cataleg.stream().map(Llibre::getTitol).toList();

// La forma classica, amb Collectors
List<String> titols2 = cataleg.stream().map(Llibre::getTitol)
        .collect(Collectors.toList());       // modificable, sense garantia de tipus

// Si necessites una llista modificable d un tipus concret
List<String> modificable = cataleg.stream().map(Llibre::getTitol)
        .collect(Collectors.toCollection(ArrayList::new));

long prestats = cataleg.stream().filter(Llibre::estaPrestat).count();

long n = cataleg.stream()
        .peek(l -> System.out.println("vist: " + l.getTitol()))
        .count();
// No imprimeix res: count() sap la mida de la llista sense recorrer la

Optional<Llibre> mesLlarg = cataleg.stream()
        .max(Comparator.comparingInt(Llibre::getPagines));

mesLlarg.ifPresent(l -> System.out.println("El mes llarg: " + l.getTitol()));

// Amb valor per defecte
String titol = cataleg.stream()
        .min(Comparator.comparing(Llibre::getTitol))
        .map(Llibre::getTitol)
        .orElse("(cataleg buit)");

boolean hiHaAlgunPrestat  = cataleg.stream().anyMatch(Llibre::estaPrestat);
boolean totsDisponibles   = cataleg.stream().allMatch(l -> !l.estaPrestat());
boolean capSenseTitol     = cataleg.stream().noneMatch(l -> l.getTitol().isBlank());

System.out.println(cataleg.stream()
        .peek(l -> System.out.println("comprovant: " + l.getTitol()))
        .anyMatch(l -> l.getPagines() > 400));

comprovant: Java Eficac
true

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

Optional<Llibre> primer = cataleg.stream()
        .filter(l -> l.getPagines() > 400)
        .findFirst();

Optional<Llibre> qualsevol = cataleg.parallelStream()
        .filter(l -> l.getPagines() > 400)
        .findAny();

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

Optional<Integer> totalPagines = cataleg.stream()
        .map(Llibre::getPagines)
        .reduce((a, b) -> a + b);

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

pas 1: acumulador = 412           (primer element)
pas 2: acumulador = 412 + 395 = 807
pas 3: acumulador = 807 + 448 = 1255
resultat: Optional[1255]

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

int totalPagines = cataleg.stream()
        .map(Llibre::getPagines)
        .reduce(0, Integer::sum);         // 0 es la identitat

String totsElsTitols = cataleg.stream()
        .map(Llibre::getTitol)
        .reduce("", (a, b) -> a.isEmpty() ? b : a + " | " + b);

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

int sumaParallela = Stream.of(1, 2, 3, 4).parallel().reduce(10, Integer::sum);
System.out.println(sumaParallela);                     // 50! el 10 es va sumar a cada particio

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

// Sumar les pagines d objectes Llibre produint un int
int totalPagines = cataleg.parallelStream()
        .reduce(0,                                    // identitat: un int
                (suma, llibre) -> suma + llibre.getPagines(),  // acumular Llibre en int
                Integer::sum);                        // fondre dos int parcials

List<String> llista = cataleg.stream().map(Llibre::getTitol).collect(Collectors.toList());
Set<String> conjunt = cataleg.stream().map(Llibre::getAutor).collect(Collectors.toSet());

// toMap: clau i valor
Map<String, Llibre> perIsbn = cataleg.stream()
        .collect(Collectors.toMap(Llibre::getIsbn, llibre -> llibre));

Map<String, String> titolPerIsbn = cataleg.stream()
        .collect(Collectors.toMap(Llibre::getIsbn, Llibre::getTitol));

// Dos llibres del mateix autor
Map<String, String> perAutor = cataleg.stream()
        .collect(Collectors.toMap(Llibre::getAutor, Llibre::getTitol));

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

// Quedar se amb el primer
Map<String, String> primer = cataleg.stream()
        .collect(Collectors.toMap(Llibre::getAutor, Llibre::getTitol,
                                  (existent, nou) -> existent));

// Quedar se amb l ultim
Map<String, String> ultim = cataleg.stream()
        .collect(Collectors.toMap(Llibre::getAutor, Llibre::getTitol,
                                  (existent, nou) -> nou));

// Combinar
Map<String, String> combinat = cataleg.stream()
        .collect(Collectors.toMap(Llibre::getAutor, Llibre::getTitol,
                                  (a, b) -> a + "; " + b));

// I amb un quart argument es tria la implementacio del Map
Map<String, String> ordenat = cataleg.stream()
        .collect(Collectors.toMap(Llibre::getIsbn, Llibre::getTitol,
                                  (a, b) -> a, TreeMap::new));

String titols = cataleg.stream()
        .map(Llibre::getTitol)
        .collect(Collectors.joining(", "));
// Java Eficac, Patrons de Disseny, Refactoritzacio

String ambVoreres = cataleg.stream()
        .map(Llibre::getTitol)
        .collect(Collectors.joining(", ", "Cataleg [", "]"));
// Cataleg [Java Eficac, Patrons de Disseny, Refactoritzacio]

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

int pagines = cataleg.stream().collect(Collectors.summingInt(Llibre::getPagines));
double mitjana = cataleg.stream().collect(Collectors.averagingInt(Llibre::getPagines));
double sumaValoracions = cataleg.stream().collect(Collectors.summingDouble(Llibre::getValoracio));
double mitjanaValoracions = cataleg.stream().collect(Collectors.averagingDouble(Llibre::getValoracio));

// Tot de cop, en un sol recorregut
IntSummaryStatistics stats = cataleg.stream()
        .collect(Collectors.summarizingInt(Llibre::getPagines));

System.out.println("Llibres: " + stats.getCount());
System.out.println("Total:   " + stats.getSum());
System.out.println("Mitjana: " + stats.getAverage());
System.out.println("Minim:   " + stats.getMin());
System.out.println("Maxim:   " + stats.getMax());

Llibres: 4
Total:   1719
Mitjana: 429.75
Minim:   395
Maxim:   464

Map<TipusMaterial, List<Material>> perTipus = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus));

{LLIBRE=[Java Eficac, Patrons de Disseny, Refactoritzacio],
 REVISTA=[Java Magazine],
 DVD=[Curs de Spring]}

Map<TipusMaterial, List<Material>> perTipus = new HashMap<>();
for (Material m : inventari) {
    perTipus.computeIfAbsent(m.getTipus(), t -> new ArrayList<>()).add(m);
}

// Quants materials de cada tipus
Map<TipusMaterial, Long> recomptePerTipus = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus, Collectors.counting()));
// {LLIBRE=3, REVISTA=1, DVD=1}

// Pagines totals per tipus
Map<TipusMaterial, Integer> paginesPerTipus = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus,
                                       Collectors.summingInt(Material::getPagines)));

// Valoracio mitjana per tipus
Map<TipusMaterial, Double> mitjanaPerTipus = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus,
                                       Collectors.averagingDouble(Material::getValoracio)));

// Nomes els TITOLS de cada grup: mapping transforma abans d acumular
Map<TipusMaterial, List<String>> titolsPerTipus = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus,
                                       Collectors.mapping(Material::getTitol,
                                                          Collectors.toList())));

// El mes valorat de cada tipus: retorna Optional dins del mapa
Map<TipusMaterial, Optional<Material>> millorPerTipus = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus,
                 Collectors.maxBy(Comparator.comparingDouble(Material::getValoracio))));

// Sense l Optional, amb maxBy reduit (Java 9)
Map<TipusMaterial, Material> millorPerTipus2 = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus,
                 Collectors.collectingAndThen(
                     Collectors.maxBy(Comparator.comparingDouble(Material::getValoracio)),
                     opt -> opt.orElse(null))));

// Estadistiques completes per tipus
Map<TipusMaterial, IntSummaryStatistics> statsPerTipus = inventari.stream()
        .collect(Collectors.groupingBy(Material::getTipus,
                                       Collectors.summarizingInt(Material::getPagines)));

// Amb TreeMap perque les claus surtin ordenades
Map<String, Long> perAutorOrdenat = cataleg.stream()
        .collect(Collectors.groupingBy(Llibre::getAutor, TreeMap::new, Collectors.counting()));

// Prestecs per empleat i, a dins, per tipus de material
Map<String, Map<TipusMaterial, List<Prestec>>> perEmpleatITipus = prestecs.stream()
        .collect(Collectors.groupingBy(
                Prestec::getEmpleat,
                Collectors.groupingBy(p -> p.getMaterial().getTipus())));

// I amb recompte al nivell interior
Map<String, Map<TipusMaterial, Long>> recomptePerEmpleatITipus = prestecs.stream()
        .collect(Collectors.groupingBy(
                Prestec::getEmpleat,
                Collectors.groupingBy(p -> p.getMaterial().getTipus(),
                                      Collectors.counting())));

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

Map<Boolean, List<Llibre>> perDisponibilitat = cataleg.stream()
        .collect(Collectors.partitioningBy(Llibre::estaPrestat));

List<Llibre> prestats    = perDisponibilitat.get(true);
List<Llibre> disponibles = perDisponibilitat.get(false);

// Amb downstream
Map<Boolean, Long> recompte = cataleg.stream()
        .collect(Collectors.partitioningBy(l -> l.getPagines() > 400,
                                           Collectors.counting()));

record ResumCataleg(long total, double mitjanaPagines) { }

ResumCataleg resum = cataleg.stream()
        .collect(Collectors.teeing(
                Collectors.counting(),
                Collectors.averagingInt(Llibre::getPagines),
                ResumCataleg::new));

// Suma sense autoboxing
int totalPagines = cataleg.stream()
        .mapToInt(Llibre::getPagines)
        .sum();

// Mitjana: retorna OptionalDouble, perque un stream buit no te mitjana
OptionalDouble mitjana = cataleg.stream()
        .mapToInt(Llibre::getPagines)
        .average();

System.out.printf("Mitjana: %.1f pagines%n", mitjana.orElse(0.0));

// Estadistiques de cop
IntSummaryStatistics stats = cataleg.stream()
        .mapToInt(Llibre::getPagines)
        .summaryStatistics();

// Rangs
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

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

// Caracters d una cadena
long vocals = "Java Eficac".chars()
        .filter(c -> "aeiouAEIOU".indexOf(c) >= 0)
        .count();

OptionalDouble mitjana = cataleg.stream().mapToInt(Llibre::getPagines).average();

String text = mitjana.isPresent()
        ? String.format("%.1f", mitjana.getAsDouble())
        : "sense dades";

// O convertint a Optional<Double>
String text2 = mitjana.stream().boxed().findFirst()
        .map(d -> String.format("%.1f", d))
        .orElse("sense dades");

List<Llibre> resultat = cataleg.parallelStream()       // des de la colleccio
        .filter(l -> l.getPagines() > 400)
        .toList();

List<Llibre> resultat2 = cataleg.stream()
        .parallel()                                    // des d un stream existent
        .filter(l -> l.getPagines() > 400)
        .toList();

System.out.println("Parallelisme: " + ForkJoinPool.getCommonPoolParallelism());
System.out.println("Nuclis:       " + Runtime.getRuntime().availableProcessors());

Parallelisme: 7
Nuclis:       8

ForkJoinPool poolPropi = new ForkJoinPool(4);
try {
    List<Llibre> resultat = poolPropi.submit(() ->
            cataleg.parallelStream().filter(...).toList()).get();
} finally {
    poolPropi.shutdown();
}

package com.nexussoftware.bibliotech;

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

public class MesuraParallela {

    public static void main(String[] args) {

        // ADVERTIMENT: aixo es un mesurament CASOLA. Els nombres son
        // orientatius; per mesurar de debo cal JMH (10-07).

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

        escalfar(gran);

        mesurar("1.000 elements, suma trivial, sequencial",
                () -> petita.stream().mapToLong(Integer::longValue).sum());
        mesurar("1.000 elements, suma trivial, PARALLEL  ",
                () -> petita.parallelStream().mapToLong(Integer::longValue).sum());

        mesurar("10M elements, suma trivial, sequencial  ",
                () -> gran.stream().mapToLong(Integer::longValue).sum());
        mesurar("10M elements, suma trivial, PARALLEL    ",
                () -> gran.parallelStream().mapToLong(Integer::longValue).sum());

        mesurar("10M elements, calcul car, sequencial    ",
                () -> gran.stream().mapToLong(MesuraParallela::car).sum());
        mesurar("10M elements, calcul car, PARALLEL      ",
                () -> gran.parallelStream().mapToLong(MesuraParallela::car).sum());

        // LinkedList: particio cara
        List<Integer> enllacada = new LinkedList<>(IntStream.range(0, 1_000_000).boxed().toList());
        mesurar("1M en LinkedList, sequencial            ",
                () -> enllacada.stream().mapToLong(Integer::longValue).sum());
        mesurar("1M en LinkedList, PARALLEL              ",
                () -> enllacada.parallelStream().mapToLong(Integer::longValue).sum());
    }

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

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

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

1.000 elements, suma trivial, sequencial ->      0 ms  (resultat: 499500)
1.000 elements, suma trivial, PARALLEL   ->      2 ms  (resultat: 499500)
10M elements, suma trivial, sequencial   ->     58 ms  (resultat: 49999995000000)
10M elements, suma trivial, PARALLEL     ->     21 ms  (resultat: 49999995000000)
10M elements, calcul car, sequencial     ->    712 ms  (resultat: -1583)
10M elements, calcul car, PARALLEL       ->    134 ms  (resultat: -1583)
1M en LinkedList, sequencial             ->     11 ms  (resultat: 499999500000)
1M en LinkedList, PARALLEL               ->     34 ms  (resultat: 499999500000)

// CATASTROFIC: ArrayList no es segur entre fils (08-06)
List<String> resultat = new ArrayList<>();
cataleg.parallelStream().forEach(l -> resultat.add(l.getTitol()));

// CORRECTE: collect gestiona la combinacio per tu
List<String> resultat = cataleg.parallelStream()
        .map(Llibre::getTitol)
        .toList();

package com.nexussoftware.bibliotech.servei;

import java.util.*;

/** VERSIO ANTIGA: la del modul 5. */
public class EstadistiquesBiblioTechAntic {

    public Map<TipusMaterial, Long> recomptePerTipus(List<Material> inventari) {
        Map<TipusMaterial, Long> resultat = new HashMap<>();
        for (Material m : inventari) {
            Long actual = resultat.get(m.getTipus());
            resultat.put(m.getTipus(), actual == null ? 1L : actual + 1);
        }
        return resultat;
    }

    public Map<String, List<String>> titolsPerEmpleat(List<Prestec> prestecs) {
        Map<String, List<String>> resultat = new HashMap<>();
        for (Prestec p : prestecs) {
            List<String> llista = resultat.get(p.getEmpleat());
            if (llista == null) {
                llista = new ArrayList<>();
                resultat.put(p.getEmpleat(), llista);
            }
            llista.add(p.getMaterial().getTitol());
        }
        for (List<String> llista : resultat.values()) {
            Collections.sort(llista);
        }
        return resultat;
    }

    public String empleatAmbMesPrestecs(List<Prestec> prestecs) {
        Map<String, Integer> recompte = new HashMap<>();
        for (Prestec p : prestecs) {
            Integer actual = recompte.get(p.getEmpleat());
            recompte.put(p.getEmpleat(), actual == null ? 1 : actual + 1);
        }
        String millor = null;
        int maxim = -1;
        for (Map.Entry<String, Integer> e : recompte.entrySet()) {
            if (e.getValue() > maxim) {
                maxim = e.getValue();
                millor = e.getKey();
            }
        }
        return millor;                   // null si la llista era buida
    }

    public double mitjanaPaginesDelsPrestats(List<Material> inventari) {
        int suma = 0;
        int compte = 0;
        for (Material m : inventari) {
            if (m.estaPrestat() && m instanceof Llibre) {
                suma += ((Llibre) m).getPagines();
                compte++;
            }
        }
        return compte == 0 ? 0.0 : (double) suma / compte;
    }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.*;

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

/**
 * VERSIO AMB STREAMS. Mateix comportament, un terc del codi,
 * i cada metode es llegeix com la frase que el descriu.
 */
public class EstadistiquesBiblioTech {

    /** Quants materials hi ha de cada tipus. */
    public Map<TipusMaterial, Long> recomptePerTipus(List<Material> inventari) {
        return inventari.stream()
                .collect(Collectors.groupingBy(Material::getTipus, Collectors.counting()));
    }

    /** Titols prestats a cada empleat, ordenats alfabeticament. */
    public Map<String, List<String>> titolsPerEmpleat(List<Prestec> prestecs) {
        return prestecs.stream()
                .collect(Collectors.groupingBy(
                        Prestec::getEmpleat,
                        TreeMap::new,
                        Collectors.mapping(p -> p.getMaterial().getTitol(),
                                           Collectors.collectingAndThen(
                                                   Collectors.toList(),
                                                   llista -> { llista.sort(null); return llista; }))));
    }

    /** L empleat amb mes prestecs. Optional en lloc de null. */
    public Optional<String> empleatAmbMesPrestecs(List<Prestec> prestecs) {
        return prestecs.stream()
                .collect(Collectors.groupingBy(Prestec::getEmpleat, Collectors.counting()))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey);
    }

    /** Mitjana de pagines dels llibres prestats. */
    public OptionalDouble mitjanaPaginesDelsPrestats(List<Material> inventari) {
        return inventari.stream()
                .filter(Material::estaPrestat)
                .filter(Llibre.class::isInstance)        // l instanceof de 10-03
                .map(Llibre.class::cast)
                .mapToInt(Llibre::getPagines)
                .average();
    }

    /** Informe complet per tipus: compte, pagines i valoracio mitjana. */
    public Map<TipusMaterial, ResumTipus> informeComplet(List<Material> inventari) {
        return inventari.stream()
                .collect(Collectors.groupingBy(
                        Material::getTipus,
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                llista -> new ResumTipus(
                                        llista.size(),
                                        llista.stream().mapToInt(Material::getPagines).sum(),
                                        llista.stream().mapToDouble(Material::getValoracio)
                                              .average().orElse(0.0)))));
    }

    public record ResumTipus(int quants, int paginesTotals, double valoracioMitjana) { }

    /** Prestecs per empleat i tipus: l informe de dos nivells. */
    public Map<String, Map<TipusMaterial, Long>> matriuEmpleatTipus(List<Prestec> prestecs) {
        return prestecs.stream()
                .collect(Collectors.groupingBy(
                        Prestec::getEmpleat,
                        TreeMap::new,
                        Collectors.groupingBy(p -> p.getMaterial().getTipus(),
                                              () -> new EnumMap<>(TipusMaterial.class),
                                              Collectors.counting())));
    }

    /** Els N materials mes valorats. */
    public List<Material> topValorats(List<Material> inventari, int n) {
        return inventari.stream()
                .sorted(Comparator.comparingDouble(Material::getValoracio).reversed())
                .limit(n)
                .toList();
    }

    /** Totes les incidencies de tots els prestecs, agrupades per gravetat. */
    public Map<Gravetat, List<String>> incidenciesPerGravetat(List<Prestec> prestecs) {
        return prestecs.stream()
                .flatMap(p -> p.getIncidencies().stream())
                .collect(Collectors.groupingBy(
                        Prestec.Incidencia::gravetat,
                        () -> new EnumMap<>(Gravetat.class),
                        Collectors.mapping(Prestec.Incidencia::descripcio,
                                           Collectors.toList())));
    }

    /** Linia de resum per al tauler de la biblioteca. */
    public String resumEnUnaLinia(List<Material> inventari) {
        return inventari.stream()
                .collect(Collectors.groupingBy(Material::getTipus,
                         () -> new EnumMap<>(TipusMaterial.class),
                         Collectors.counting()))
                .entrySet().stream()
                .map(e -> e.getKey() + "=" + e.getValue())
                .collect(Collectors.joining(", ", "Inventari [", "]"));
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domini.*;
import com.nexussoftware.bibliotech.servei.EstadistiquesBiblioTech;

import java.util.List;

public class InformeBiblioTech {

    public static void main(String[] args) {

        List<Material> inventari = DadesDeProva.inventari();
        List<Prestec> prestecs   = DadesDeProva.prestecs();

        EstadistiquesBiblioTech stats = new EstadistiquesBiblioTech();

        System.out.println("=== INFORME BIBLIOTECH ===");
        System.out.println(stats.resumEnUnaLinia(inventari));
        System.out.println();

        System.out.println("--- Materials per tipus ---");
        stats.informeComplet(inventari).forEach((tipus, r) ->
                System.out.printf("  %-8s %2d unitats, %5d pagines, valoracio %.2f%n",
                        tipus, r.quants(), r.paginesTotals(), r.valoracioMitjana()));

        System.out.println();
        System.out.println("--- Prestecs per empleat i tipus ---");
        stats.matriuEmpleatTipus(prestecs).forEach((empleat, perTipus) ->
                System.out.printf("  %-14s %s%n", empleat, perTipus));

        System.out.println();
        System.out.println("--- Titols per empleat ---");
        stats.titolsPerEmpleat(prestecs).forEach((empleat, titols) ->
                System.out.printf("  %-14s %s%n", empleat, titols));

        System.out.println();
        stats.empleatAmbMesPrestecs(prestecs)
             .ifPresentOrElse(e -> System.out.println("Qui mes llegeix: " + e),
                              () -> System.out.println("No hi ha prestecs registrats"));

        System.out.printf("Mitjana de pagines del prestat: %.1f%n",
                stats.mitjanaPaginesDelsPrestats(inventari).orElse(0.0));

        System.out.println();
        System.out.println("--- Top 3 mes valorats ---");
        stats.topValorats(inventari, 3)
             .forEach(m -> System.out.printf("  %.2f  %s%n", m.getValoracio(), m.getTitol()));
    }
}

=== INFORME BIBLIOTECH ===
Inventari [LLIBRE=5, REVISTA=2, DVD=1]

--- Materials per tipus ---
  LLIBRE    5 unitats,  2119 pagines, valoracio 4,62
  REVISTA   2 unitats,   140 pagines, valoracio 3,90
  DVD       1 unitats,     0 pagines, valoracio 4,10

--- Prestecs per empleat i tipus ---
  Diego Alonso   {LLIBRE=1, REVISTA=2}
  Marta Ruiz     {LLIBRE=3, DVD=1}
  Nuria Vidal    {LLIBRE=2}

--- Titols per empleat ---
  Diego Alonso   [Java Magazine 04, Java Magazine 05, Refactoritzacio]
  Marta Ruiz     [Codi Net, Curs de Spring, Java Eficac, Patrons de Disseny]
  Nuria Vidal    [Domain-Driven Design, Java Eficac]

Qui mes llegeix: Marta Ruiz
Mitjana de pagines del prestat: 428,3
--- Top 3 mes valorats ---
  4,85  Java Eficac
  4,72  Refactoritzacio
  4,60  Patrons de Disseny

public Prestec cercarPerReferencia(String referencia) {
    for (Prestec p : prestecs) {
        if (p.getReferencia().equals(referencia)) {
            return p;
        }
    }
    return null;                       // "no trobat"
}

Prestec p = registre.cercarPerReferencia("PR-2026-0041");
System.out.println(p.getEmpleat());        // NullPointerException si no existeix

public Optional<Prestec> cercarPerReferencia(String referencia) {
    for (Prestec p : prestecs) {
        if (p.getReferencia().equals(referencia)) {
            return Optional.of(p);
        }
    }
    return Optional.empty();
}

Optional<Prestec> p = registre.cercarPerReferencia("PR-2026-0041");
// p.getEmpleat();       // NO COMPILA: Optional no te getEmpleat()

String empleat = p.map(Prestec::getEmpleat).orElse("(sense prestec)");

// of: el valor NO pot ser null. Si ho es, NullPointerException immediata.
Optional<Llibre> a = Optional.of(llibre);

// ofNullable: accepta null i produeix un Optional buit
Optional<Llibre> b = Optional.ofNullable(potSerNull);

// empty: explicitament buit
Optional<Llibre> c = Optional.empty();

// MALAMENT: si el mapa no te la clau, aixo llanca NullPointerException
Optional<Llibre> llibre = Optional.of(mapa.get(isbn));

// BE
Optional<Llibre> llibre = Optional.ofNullable(mapa.get(isbn));

// map: transforma el valor si existeix. Si esta buit, continua buit.
Optional<String> titol = cataleg.cercarPerIsbn(isbn).map(Llibre::getTitol);

// Encadenant
String majuscules = cataleg.cercarPerIsbn(isbn)
        .map(Llibre::getTitol)
        .map(String::toUpperCase)
        .orElse("DESCONEGUT");

// filter: buida l Optional si no compleix
Optional<Llibre> llargIDisponible = cataleg.cercarPerIsbn(isbn)
        .filter(l -> l.getPagines() > 400)
        .filter(l -> !l.estaPrestat());

public class Llibre {
    public Optional<String> getEditorial() { ... }   // pot no tenir ne
}

// Amb map: et queden Optionals imbricats
Optional<Optional<String>> malament = cataleg.cercarPerIsbn(isbn).map(Llibre::getEditorial);

// Amb flatMap: aplanat
Optional<String> be = cataleg.cercarPerIsbn(isbn).flatMap(Llibre::getEditorial);

// orElse: valor per defecte
String titol = opt.map(Llibre::getTitol).orElse("(desconegut)");

// orElseGet: valor per defecte CALCULAT MANDROSAMENT (apartat 18)
Llibre llibre = opt.orElseGet(() -> carregarDeLaXarxa(isbn));

// orElseThrow: llancar si no n hi ha
Llibre llibre2 = opt.orElseThrow(() ->
        new BiblioTechException("No existeix el material " + isbn));

// orElseThrow() sense arguments (Java 10): llanca NoSuchElementException
Llibre llibre3 = opt.orElseThrow();

// or: un altre Optional si aquest esta buit (Java 9)
Optional<Llibre> trobat = catalegLocal.cercarPerIsbn(isbn)
        .or(() -> catalegRemot.cercarPerIsbn(isbn))
        .or(() -> catalegHistoric.cercarPerIsbn(isbn));

// ifPresent: fer alguna cosa si hi ha valor
cataleg.cercarPerIsbn(isbn).ifPresent(l -> System.out.println("Trobat: " + l.getTitol()));

// ifPresentOrElse: i si no, una altra cosa (Java 9)
cataleg.cercarPerIsbn(isbn).ifPresentOrElse(
        l  -> System.out.println("Trobat: " + l.getTitol()),
        () -> System.out.println("No hi ha cap material amb ISBN " + isbn));

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

// ABANS de Java 9: dos passos
List<Llibre> trobats1 = isbns.stream()
        .map(cataleg::cercarPerIsbn)       // Stream<Optional<Llibre>>
        .filter(Optional::isPresent)
        .map(Optional::get)
        .toList();

// DES DE Java 9: un pas
List<Llibre> trobats2 = isbns.stream()
        .map(cataleg::cercarPerIsbn)       // Stream<Optional<Llibre>>
        .flatMap(Optional::stream)          // Stream<Llibre>, sense els buits
        .toList();

T orElse(T altre)                              // rep un VALOR ja calculat
T orElseGet(Supplier<? extends T> proveidor)   // rep una FUNCIO que el calcula

package com.nexussoftware.bibliotech;

import java.util.Optional;

public class OrElseEnfrontDeOrElseGet {

    private static Llibre carregarDeLaXarxa(String isbn) {
        System.out.println("  >>> CONSULTANT LA XARXA per a " + isbn + " (300 ms)");
        return new Llibre(isbn, "Recuperat de la xarxa");
    }

    public static void main(String[] args) {

        Optional<Llibre> ambValor = Optional.of(new Llibre("978-0000000001", "Java Eficac"));

        System.out.println("--- orElse amb valor present ---");
        Llibre a = ambValor.orElse(carregarDeLaXarxa("978-0000000001"));
        System.out.println("Resultat: " + a.getTitol());

        System.out.println();
        System.out.println("--- orElseGet amb valor present ---");
        Llibre b = ambValor.orElseGet(() -> carregarDeLaXarxa("978-0000000001"));
        System.out.println("Resultat: " + b.getTitol());

        System.out.println();
        System.out.println("--- orElseGet amb Optional buit ---");
        Llibre c = Optional.<Llibre>empty().orElseGet(() -> carregarDeLaXarxa("978-9999999999"));
        System.out.println("Resultat: " + c.getTitol());
    }
}

--- orElse amb valor present ---
  >>> CONSULTANT LA XARXA per a 978-0000000001 (300 ms)
Resultat: Java Eficac

--- orElseGet amb valor present ---
Resultat: Java Eficac

--- orElseGet amb Optional buit ---
  >>> CONSULTANT LA XARXA per a 978-9999999999 (300 ms)
Resultat: Recuperat de la xarxa

// Un comptador que s incrementa encara que el valor existeixi
int seguentId = opt.orElse(generarNouId());        // genera un ID sempre!

// Un Optional buit que produeix NullPointerException
String s = opt.orElse(altre.getTitol());           // si altre es null, explota sempre

// BE: constant
String titol = opt.map(Llibre::getTitol).orElse("(sense titol)");

// BE: calcul car, avaluat nomes si cal
Llibre llibre = opt.orElseGet(() -> carregarDeLaXarxa(isbn));

// BE: excepcio construida nomes si cal
// (construir una excepcio captura la traca de pila, que no es gratis)
Llibre llibre2 = opt.orElseThrow(() -> new BiblioTechException("No existeix " + isbn));

// MALAMENT: es un if disfressat, amb mes soroll que el null original
Optional<Llibre> opt = cataleg.cercarPerIsbn(isbn);
if (opt.isPresent()) {
    System.out.println(opt.get().getTitol());
} else {
    System.out.println("No trobat");
}

// BE
cataleg.cercarPerIsbn(isbn).ifPresentOrElse(
        l  -> System.out.println(l.getTitol()),
        () -> System.out.println("No trobat"));

// O si necessites el valor
String titol = cataleg.cercarPerIsbn(isbn)
        .map(Llibre::getTitol)
        .orElse("No trobat");

// MALAMENT
public List<Llibre> cercar(String text, Optional<TipusMaterial> tipus) { ... }

// BE
public List<Llibre> cercar(String text) {
    return cercar(text, null);
}

public List<Llibre> cercar(String text, TipusMaterial tipus) { ... }

// MALAMENT
public class Llibre {
    private Optional<String> editorial;      // NO
}

// BE: el camp es null; l ACCESSOR retorna Optional
public class Llibre {

    private String editorial;                // pot ser null

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

// MALAMENT
public Optional<List<Prestec>> prestecsDe(String empleat) { ... }

// BE: una llista buida JA significa "no hi ha res"
public List<Prestec> prestecsDe(String empleat) {
    return prestecs.stream()
            .filter(p -> p.getEmpleat().equals(empleat))
            .toList();                       // buida si no n hi ha cap
}

// MALAMENT: NullPointerException garantida
return Optional.of(mapa.get(clau));

// PITJOR: un metode que retorna Optional i de vegades retorna null
public Optional<Llibre> cercar(String isbn) {
    if (isbn == null) return null;           // destrueix tot el proposit!
    ...
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.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;

/**
 * Repositori generic (10-01) amb API de streams i Optional (10-04).
 */
public class Repositori<T extends Identificable> {

    private final Map<String, T> perId = new ConcurrentHashMap<>();
    private final String nom;

    public Repositori(String nom) {
        this.nom = Objects.requireNonNull(nom, "nom");
    }

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

    /** La signatura DIU que pot no trobar res. */
    public Optional<T> cercarPerId(String id) {
        return Optional.ofNullable(perId.get(id));
    }

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

    /**
     * Exposa un stream en lloc d una copia de la llista.
     * Qui crida decideix que fer sense que el repositori
     * hagi d oferir un metode per cada consulta.
     */
    public Stream<T> flux() {
        return perId.values().stream();
    }

    /** Mai null: una llista buida ja significa "cap". */
    public List<T> cercar(Predicate<? super T> criteri) {
        return flux().filter(criteri).toList();
    }

    /** El primer que compleixi, o buit. */
    public Optional<T> cercarPrimer(Predicate<? super T> criteri) {
        return flux().filter(criteri).findFirst();
    }

    public List<T> llistarOrdenat(Comparator<? super T> ordre) {
        return flux().sorted(ordre).toList();
    }

    public long comptar(Predicate<? super T> criteri) {
        return flux().filter(criteri).count();
    }

    public boolean existeixAlgun(Predicate<? super T> criteri) {
        return flux().anyMatch(criteri);
    }

    /** Indexa per qualsevol clau derivada. */
    public <K> Map<K, List<T>> agrupar(Function<? super T, ? extends K> classificador) {
        return flux().collect(Collectors.groupingBy(classificador));
    }

    public int mida() {
        return perId.size();
    }

    @Override
    public String toString() {
        return "Repositori[" + nom + ", " + perId.size() + " entitats]";
    }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.anotacions.Auditable;
import com.nexussoftware.bibliotech.domini.*;

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

public class GestorPrestecs implements ServeiPrestecs {

    private final Repositori<Material> cataleg;
    private final Repositori<Prestec> prestecs;

    public GestorPrestecs(Repositori<Material> cataleg, Repositori<Prestec> prestecs) {
        this.cataleg = cataleg;
        this.prestecs = prestecs;
    }

    /**
     * ABANS: cercarPerId retornava null i calia comprovar ho.
     * ARA: l absencia s encadena i produeix la fallada correcta.
     */
    @Override
    @Auditable(value = "prestar", nivell = Gravetat.ALTA, registrarArguments = true)
    public Resultat<Prestec> prestar(String isbn, String empleat) {

        return cataleg.cercarPerId(isbn)
                .map(material -> registrar(material, empleat))
                .orElseGet(() -> Resultat.fallada("No existeix cap material amb ISBN " + isbn));
    }

    private Resultat<Prestec> registrar(Material material, String empleat) {
        if (material.estaPrestat()) {
            return Resultat.fallada("El material '" + material.getTitol() + "' ja esta prestat");
        }
        material.marcarPrestat(empleat);
        Prestec prestec = new Prestec(seguentReferencia(), material.getId(), empleat);
        prestecs.guardar(prestec);
        return Resultat.exit(prestec);
    }

    /** Llista buida, mai null. */
    @Override
    public List<Prestec> prestecsDe(String empleat) {
        return prestecs.cercar(p -> p.getEmpleat().equals(empleat));
    }

    /** Optional en lloc de null. */
    @Override
    public Optional<Prestec> cercarPerReferencia(String referencia) {
        return prestecs.cercarPerId(referencia);
    }

    /** El titol del material prestat a un empleat que mes retard porta. */
    public Optional<String> materialMesRetardatDe(String empleat) {
        return prestecs.flux()
                .filter(p -> p.getEmpleat().equals(empleat))
                .filter(Prestec::teRetard)
                .max(Comparator.comparingInt(Prestec::getDiesDeRetard))
                .flatMap(p -> cataleg.cercarPerId(p.getIsbn()))    // flatMap: retorna Optional
                .map(Material::getTitol);
    }

    /** Deute total de multes per empleat, nomes dels qui deuen alguna cosa. */
    public Map<String, Double> deutePerEmpleat(CalculadoraMultes calculadora) {
        return prestecs.flux()
                .filter(Prestec::teRetard)
                .collect(Collectors.groupingBy(
                        Prestec::getEmpleat,
                        TreeMap::new,
                        Collectors.summingDouble(p -> calculadora.calcular(p.getDiesDeRetard()))));
    }

    private String seguentReferencia() {
        return String.format("PR-2026-%04d", prestecs.mida() + 1);
    }
}

gestor.prestar("978-0000000001", "Marta Ruiz")
      .map(Prestec::getId)
      .map(id -> "Prestec registrat: " + id)
      .ifPresent(System.out::println);

gestor.materialMesRetardatDe("Diego Alonso")
      .ifPresentOrElse(
              t  -> System.out.println("Retornar urgentment: " + t),
              () -> System.out.println("Diego Alonso no te retards"));

gestor.deutePerEmpleat(calculadora)
      .forEach((empleat, deute) -> System.out.printf("  %-14s %.2f €%n", empleat, deute));

Prestec registrat: PR-2026-0009
Retornar urgentment: Refactoritzacio
  Diego Alonso   3,25 €
  Marta Ruiz     1,50 €

Predicate<Llibre> esLlargIEstaPrestat = l -> l.getPagines() > 400 && l.estaPrestat();
List<Llibre> resultat = cataleg.stream().filter(esLlargIEstaPrestat).toList();

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

package com.nexussoftware.bibliotech.presentacio;

import com.nexussoftware.bibliotech.domini.*;

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

/**
 * Tauler de la biblioteca generat enterament amb streams.
 * Ni un for, ni un null, ni un Optional.get().
 */
public class TaulerBiblioTech {

    private final List<Material> inventari;
    private final List<Prestec> prestecs;

    public TaulerBiblioTech(List<Material> inventari, List<Prestec> prestecs) {
        this.inventari = List.copyOf(inventari);
        this.prestecs  = List.copyOf(prestecs);
    }

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

        seccioInventari(sb);
        seccioTop(sb);
        seccioPrestecs(sb);
        seccioRanquing(sb);
        seccioPagines(sb);
        seccioMaiPrestats(sb);
        seccioHistograma(sb);

        return sb.toString();
    }

    // --- 1. Inventari per tipus ---
    private void seccioInventari(StringBuilder sb) {
        Map<TipusMaterial, Long> perTipus = inventari.stream()
                .collect(Collectors.groupingBy(Material::getTipus,
                         () -> new EnumMap<>(TipusMaterial.class),
                         Collectors.counting()));

        sb.append("\n1. INVENTARI (").append(inventari.size()).append(" materials)\n");
        perTipus.forEach((tipus, n) ->
                sb.append(String.format("   %-10s %3d  %s%n", tipus, n, "#".repeat(n.intValue()))));
    }

    // --- 2. Top 3 mes valorats ---
    private void seccioTop(StringBuilder sb) {
        sb.append("\n2. MILLOR VALORATS\n");
        inventari.stream()
                .sorted(Comparator.comparingDouble(Material::getValoracio).reversed())
                .limit(3)
                .forEach(m -> sb.append(String.format("   %.2f  %s%n",
                        m.getValoracio(), m.getTitol())));
    }

    // --- 3. Prestecs per empleat ---
    private void seccioPrestecs(StringBuilder sb) {
        Map<String, List<String>> perEmpleat = prestecs.stream()
                .collect(Collectors.groupingBy(
                        Prestec::getEmpleat,
                        TreeMap::new,
                        Collectors.mapping(Prestec::getTitolMaterial,
                                Collectors.collectingAndThen(
                                        Collectors.toList(),
                                        llista -> llista.stream().sorted().toList()))));

        sb.append("\n3. PRESTECS ACTIUS\n");
        perEmpleat.forEach((empleat, titols) -> {
            sb.append(String.format("   %-14s (%d)%n", empleat, titols.size()));
            titols.forEach(t -> sb.append("      - ").append(t).append('\n'));
        });
    }

    // --- 4. Ranquings, amb Optional ---
    private void seccioRanquing(StringBuilder sb) {
        sb.append("\n4. RANQUINGS\n");

        Optional<String> mesPrestecs = prestecs.stream()
                .collect(Collectors.groupingBy(Prestec::getEmpleat, Collectors.counting()))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey);

        sb.append("   Mes prestecs:   ")
          .append(mesPrestecs.orElse("(no hi ha prestecs)")).append('\n');

        Optional<String> mesRetard = prestecs.stream()
                .filter(Prestec::teRetard)
                .collect(Collectors.groupingBy(Prestec::getEmpleat,
                         Collectors.summingInt(Prestec::getDiesDeRetard)))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(e -> e.getKey() + " (" + e.getValue() + " dies)");

        sb.append("   Mes retard:     ")
          .append(mesRetard.orElse("(ningu amb retard)")).append('\n');
    }

    // --- 5. Estadistiques de pagines en UN recorregut ---
    private void seccioPagines(StringBuilder sb) {
        IntSummaryStatistics stats = inventari.stream()
                .filter(Llibre.class::isInstance)
                .map(Llibre.class::cast)
                .mapToInt(Llibre::getPagines)
                .summaryStatistics();

        sb.append("\n5. PAGINES DELS LLIBRES\n");
        sb.append(String.format("   llibres=%d  mitjana=%.1f  min=%d  max=%d  total=%d%n",
                stats.getCount(), stats.getAverage(),
                // Amb 0 llibres, getMin() retorna MAX_VALUE: cal contemplar ho
                stats.getCount() == 0 ? 0 : stats.getMin(),
                stats.getCount() == 0 ? 0 : stats.getMax(),
                stats.getSum()));
    }

    // --- 6. Mai prestats ---
    private void seccioMaiPrestats(StringBuilder sb) {
        // Conjunt d ISBN prestats alguna vegada: la cerca passa a O(1)
        Set<String> prestatsAlgunaVegada = prestecs.stream()
                .map(Prestec::getIsbn)
                .collect(Collectors.toSet());

        List<String> mai = inventari.stream()
                .filter(m -> !prestatsAlgunaVegada.contains(m.getId()))
                .map(Material::getTitol)
                .sorted()
                .toList();

        sb.append("\n6. MAI PRESTATS (").append(mai.size()).append(")\n");
        sb.append(mai.isEmpty()
                ? "   (tot el cataleg ha sortit alguna vegada)\n"
                : mai.stream().collect(Collectors.joining("\n   ", "   ", "\n")));
    }

    // --- 7. Histograma per dia de la setmana ---
    private void seccioHistograma(StringBuilder sb) {
        String[] dies = { "Dilluns", "Dimarts", "Dimecres", "Dijous", "Divendres", "Dissabte", "Diumenge" };

        Map<Integer, Long> perDia = prestecs.stream()
                .collect(Collectors.groupingBy(p -> p.getDiaPrestec() % 7,
                                               Collectors.counting()));

        long maxim = perDia.values().stream().mapToLong(Long::longValue).max().orElse(1);

        sb.append("\n7. PRESTECS PER DIA DE LA SETMANA\n");
        IntStream.range(0, 7).forEach(i -> {
            long n = perDia.getOrDefault(i, 0L);
            int barra = (int) (n * 30 / maxim);
            sb.append(String.format("   %-10s %3d %s%n", dies[i], n, "█".repeat(barra)));
        });
    }
}

==========================================================
       TAULER DE BIBLIOTECH -- Nexus Software
==========================================================

1. INVENTARI (8 materials)
   LLIBRE       5  #####
   REVISTA      2  ##
   DVD          1  #

2. MILLOR VALORATS
   4,85  Java Eficac
   4,72  Refactoritzacio
   4,60  Patrons de Disseny

3. PRESTECS ACTIUS
   Diego Alonso   (3)
      - Java Magazine 04
      - Java Magazine 05
      - Refactoritzacio
   Marta Ruiz     (4)
      - Codi Net
      - Curs de Spring
      - Java Eficac
      - Patrons de Disseny
   Nuria Vidal    (2)
      - Domain-Driven Design
      - Java Eficac

4. RANQUINGS
   Mes prestecs:   Marta Ruiz
   Mes retard:     Diego Alonso (23 dies)

5. PAGINES DELS LLIBRES
   llibres=5  mitjana=423.8  min=380  max=464  total=2119

6. MAI PRESTATS (1)
   UML Destillat

7. PRESTECS PER DIA DE LA SETMANA
   Dilluns      3 ██████████████████████████████
   Dimarts      1 ██████████
   Dimecres     2 ████████████████████
   Dijous       0
   Divendres    2 ████████████████████
   Dissabte     1 ██████████
   Diumenge     0

package com.nexussoftware.bibliotech.servei;

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;

/**
 * Analitza el log de BiblioTech amb streams mandrosos.
 * MAI carrega el fitxer a memoria: un log de 2 GB es processa igual.
 */
public class AnalitzadorLog {

    /** Una linia valida del log. Optional per a l analisi (04-07 + 10-04). */
    public record LiniaLog(String data, String nivell, String operacio,
                           String empleat, long millisegons) {

        static Optional<LiniaLog> analitzar(String linia) {
            String[] c = linia.split("\\|", -1);
            if (c.length != 5) {
                return Optional.empty();
            }
            try {
                return Optional.of(new LiniaLog(
                        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> perNivell,
                          List<LiniaLog> mesLentes,
                          Map<String, Double> mitjanaPerOperacio,
                          List<String> empleatsAmbErrors,
                          double percentatgeLentes,
                          long totalValides,
                          long totalCorruptes) { }

    private final Path fitxer;

    public AnalitzadorLog(Path fitxer) {
        this.fitxer = fitxer;
    }

    /**
     * UN SOL recorregut del fitxer: es materialitzen les linies valides
     * a memoria una vegada i se n deriven tots els agregats.
     * Per a fitxers que no caben a memoria, cada agregat necessitaria
     * el seu propi recorregut mandros.
     */
    public Informe analitzar() throws IOException {

        List<LiniaLog> valides;
        long total;

        try (Stream<String> linies = Files.lines(fitxer, StandardCharsets.UTF_8)) {
            valides = linies
                    .filter(l -> !l.isBlank())
                    .map(LiniaLog::analitzar)
                    .flatMap(Optional::stream)      // descarta les buides sense get()
                    .toList();
        }
        total = comptarLiniesNoBuides();

        Map<String, Long> perNivell = valides.stream()
                .collect(Collectors.groupingBy(LiniaLog::nivell,
                         TreeMap::new, Collectors.counting()));

        List<LiniaLog> mesLentes = valides.stream()
                .sorted(Comparator.comparingLong(LiniaLog::millisegons).reversed())
                .limit(5)
                .toList();

        Map<String, Double> mitjanaPerOperacio = valides.stream()
                .collect(Collectors.groupingBy(LiniaLog::operacio,
                         TreeMap::new,
                         Collectors.averagingLong(LiniaLog::millisegons)));

        List<String> empleatsAmbErrors = valides.stream()
                .filter(l -> "SEVERE".equals(l.nivell()))
                .map(LiniaLog::empleat)
                .distinct()
                .sorted()
                .toList();

        long lentes = valides.stream().filter(l -> l.millisegons() > 200).count();
        double percentatge = valides.isEmpty() ? 0.0 : lentes * 100.0 / valides.size();

        return new Informe(perNivell, mesLentes, mitjanaPerOperacio, empleatsAmbErrors,
                           percentatge, valides.size(), total - valides.size());
    }

    /** La primera linia corrupta, amb processament MANDROS: para en trobar la. */
    public Optional<String> primeraCorrupta() throws IOException {
        try (Stream<String> linies = Files.lines(fitxer, StandardCharsets.UTF_8)) {
            return linies
                    .filter(l -> !l.isBlank())
                    .filter(l -> LiniaLog.analitzar(l).isEmpty())
                    .findFirst();       // CURTCIRCUITA: no llegeix la resta del fitxer
        }
    }

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

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

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

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

        AnalitzadorLog analitzador = new AnalitzadorLog(log);
        Informe informe = analitzador.analitzar();

        System.out.println("=== ANALISI DEL LOG ===");
        System.out.printf("Linies valides: %d, corruptes: %d%n%n",
                informe.totalValides(), informe.totalCorruptes());

        System.out.println("Operacions per nivell:");
        informe.perNivell().forEach((n, c) -> System.out.printf("  %-8s %6d%n", n, c));

        System.out.println("\nLes 5 mes lentes:");
        informe.mesLentes().forEach(l -> System.out.printf("  %6d ms  %-10s %s%n",
                l.millisegons(), l.operacio(), l.empleat()));

        System.out.println("\nDuracio mitjana per operacio:");
        informe.mitjanaPerOperacio().forEach((op, ms) ->
                System.out.printf("  %-12s %7.1f ms%n", op, ms));

        System.out.println("\nEmpleats amb errors greus: " + informe.empleatsAmbErrors());
        System.out.printf("Operacions per sobre de 200 ms: %.2f %%%n",
                informe.percentatgeLentes());

        analitzador.primeraCorrupta().ifPresentOrElse(
                l  -> System.out.println("\nPrimera linia corrupta: \"" + l + "\""),
                () -> System.out.println("\nNo hi ha linies corruptes"));
    }

    /** Genera el fitxer de prova, tambe amb streams. */
    private static void generarLogDeProva(Path desti, int linies) throws IOException {
        String[] nivells    = { "INFO", "INFO", "INFO", "WARNING", "SEVERE" };
        String[] operacions = { "prestar", "retornar", "cercar", "exportar", "renovar" };
        String[] empleats   = { "Marta Ruiz", "Diego Alonso", "Nuria Vidal" };
        Random atzar = new Random(42);         // llavor fixa: sortida reproduible

        List<String> contingut = java.util.stream.IntStream.rangeClosed(1, linies)
                .mapToObj(i -> {
                    if (i % 9_999 == 0) {
                        return "2026-08-05|LINIA CORRUPTA SENSE CAMPS";
                    }
                    return String.format("2026-08-%02d|%s|%s|%s|%d",
                            1 + atzar.nextInt(28),
                            nivells[atzar.nextInt(nivells.length)],
                            operacions[atzar.nextInt(operacions.length)],
                            empleats[atzar.nextInt(empleats.length)],
                            1 + atzar.nextInt(500));
                })
                .toList();

        Files.write(desti, contingut, StandardCharsets.UTF_8);
    }
}

=== ANALISI DEL LOG ===
Linies valides: 49995, corruptes: 5

Operacions per nivell:
  INFO      30012
  SEVERE     9981
  WARNING   10002

Les 5 mes lentes:
     500 ms  cercar     Nuria Vidal
     500 ms  prestar    Marta Ruiz
     500 ms  renovar    Diego Alonso
     500 ms  retornar   Marta Ruiz
     500 ms  exportar   Nuria Vidal

Duracio mitjana per operacio:
  cercar         250.9 ms
  exportar       250.4 ms
  prestar        250.7 ms
  renovar        250.3 ms
  retornar       250.1 ms

Empleats amb errors greus: [Diego Alonso, Marta Ruiz, Nuria Vidal]
Operacions per sobre de 200 ms: 59.94 %

Primera linia corrupta: "2026-08-05|LINIA CORRUPTA SENSE CAMPS"

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Fitxa;

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

/**
 * Cache de fitxes amb API basada en Optional i streams.
 */
public class CacheFitxes {

    private final Map<String, Fitxa> cache = new ConcurrentHashMap<>();
    private long encerts = 0;
    private long fallades = 0;

    /** Optional en lloc de null: la signatura diu que pot no hi ser. */
    public Optional<Fitxa> cercar(String isbn) {
        Optional<Fitxa> resultat = Optional.ofNullable(cache.get(isbn));
        if (resultat.isPresent()) { encerts++; } else { fallades++; }
        return resultat;
    }

    /** Retorna la que hi ha a la memoria cau o la calcula i la guarda. */
    public Fitxa obtenirOCalcular(String isbn, Function<String, Fitxa> calcul) {
        return cache.computeIfAbsent(isbn, clau -> {
            fallades++;
            return calcul.apply(clau);
        });
    }

    public void guardar(Fitxa fitxa) {
        cache.put(fitxa.isbn(), fitxa);
    }

    /** Nomes les trobades, sense isPresent() ni get(). */
    public List<Fitxa> cercarTotes(Collection<String> isbns) {
        return isbns.stream()
                .map(cache::get)
                .filter(Objects::nonNull)
                .toList();
    }

    /** Versio equivalent passant per Optional, per veure l idioma. */
    public List<Fitxa> cercarTotesAmbOptional(Collection<String> isbns) {
        return isbns.stream()
                .map(isbn -> Optional.ofNullable(cache.get(isbn)))
                .flatMap(Optional::stream)
                .toList();
    }

    /** true = a la memoria cau, false = cal calcular les. SEMPRE les dues claus. */
    public Map<Boolean, List<String>> classificar(Collection<String> isbns) {
        return isbns.stream()
                .collect(Collectors.partitioningBy(cache::containsKey));
    }

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

    public double taxaEncerts() {
        long total = encerts + fallades;
        return total == 0 ? 0.0 : (double) encerts / total;
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domini.Fitxa;

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

public class BancDeProvesParallel {

    /** Calcul car que simula generar una fitxa. */
    private static Fitxa calcularFitxa(String isbn) {
        double acumulat = 0;
        for (int i = 1; i <= 2_000; i++) {
            acumulat += Math.sqrt(i) * Math.log(i + isbn.hashCode() % 7 + 8);
        }
        return new Fitxa(isbn, "Fitxa " + isbn + " (" + (long) acumulat + ")", true);
    }

    public static void main(String[] args) {

        System.out.println("Nuclis disponibles: " + Runtime.getRuntime().availableProcessors());
        System.out.println("Parallelisme del commonPool: "
                + ForkJoinPool.getCommonPoolParallelism());
        System.out.println();

        System.out.printf("%-12s %14s %14s %10s%n",
                "MIDA", "SEQUENCIAL", "PARALLEL", "MILLORA");
        System.out.println("-".repeat(54));

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

            // ESCALFAMENT: sense aixo es mesura l interpret, no el codi compilat (10-07)
            escalfar(isbns.subList(0, Math.min(500, mida)));

            long sequencial = mesurarMediana(() ->
                    isbns.stream().map(BancDeProvesParallel::calcularFitxa).count());

            long parallel = mesurarMediana(() ->
                    isbns.parallelStream().map(BancDeProvesParallel::calcularFitxa).count());

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

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

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

    private static void escalfar(List<String> mostra) {
        for (int i = 0; i < 3; i++) {
            mostra.stream().map(BancDeProvesParallel::calcularFitxa).count();
            mostra.parallelStream().map(BancDeProvesParallel::calcularFitxa).count();
        }
    }

    /** Mediana de 5 repeticions: menys sensible a un pic puntual que la mitjana. */
    private static long mesurarMediana(Runnable tasca) {
        long[] temps = new long[5];
        for (int i = 0; i < temps.length; i++) {
            long inici = System.nanoTime();
            tasca.run();
            temps[i] = (System.nanoTime() - inici) / 1_000_000;
        }
        Arrays.sort(temps);
        return temps[temps.length / 2];
    }

    /** Per que MAI s acumula en una colleccio no segura des d un stream parallel. */
    private static void demostrarCorrupcioParallela() {

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

        System.out.println("--- Acumular en ArrayList des de parallelStream ---");
        for (int intent = 1; intent <= 3; intent++) {
            List<String> desti = new ArrayList<>();        // NO es segur entre fils
            try {
                isbns.parallelStream().forEach(desti::add);
                System.out.printf("  intent %d: esperats 100000, obtinguts %d%s%n",
                        intent, desti.size(),
                        desti.size() == 100_000 ? "" : "   <-- ELEMENTS PERDUTS");
            } catch (Exception e) {
                System.out.printf("  intent %d: %s%n", intent, e.getClass().getSimpleName());
            }
        }

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

Nuclis disponibles: 8
Parallelisme del commonPool: 7

MIDA             SEQUENCIAL       PARALLEL    MILLORA
------------------------------------------------------
100                       3 ms           2 ms      1,50x
10000                   287 ms          49 ms      5,86x
1000000               28640 ms        4712 ms      6,08x

--- Acumular en ArrayList des de parallelStream ---
  intent 1: esperats 100000, obtinguts 87423   <-- ELEMENTS PERDUTS
  intent 2: ArrayIndexOutOfBoundsException
  intent 3: esperats 100000, obtinguts 92108   <-- ELEMENTS PERDUTS
--- La forma correcta: collect ---
  collect: 100000 elements, sempre