List<Book> catalog = List.of(
        new Book("978-0000000001", "Effective Java", 412, true),
        new Book("978-0000000002", "Design Patterns", 395, false));

Stream<Book> stream = catalog.stream();

long howMany = stream.count();                // first terminal operation: OK
List<Book> list = stream.toList();            // second: BLOWS UP

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 howMany = catalog.stream().count();
List<Book> list = catalog.stream().toList();

// BEFORE (module 5): imperative. It describes HOW.
List<String> result = new ArrayList<>();
for (Book book : catalog) {
    if (book.getPages() > 400 && book.isOnLoan()) {
        result.add(book.getTitle());
    }
}
Collections.sort(result);

// NOW: declarative. It describes WHAT.
List<String> result = catalog.stream()
        .filter(book -> book.getPages() > 400)
        .filter(Book::isOnLoan)
        .map(Book::getTitle)
        .sorted()
        .toList();

// This PRINTS NOTHING and TRAVERSES NOTHING
catalog.stream()
        .filter(b -> b.getPages() > 400)
        .map(Book::getTitle);

(no output)

package com.nexussoftware.bibliotech;

import java.util.List;

public class LazinessDemo {

    public static void main(String[] args) {

        List<Book> catalog = List.of(
                new Book("978-0000000001", "Effective Java",  412),
                new Book("978-0000000002", "Design Patterns", 395),
                new Book("978-0000000003", "Refactoring",     448),
                new Book("978-0000000004", "Clean Code",      464));

        System.out.println("--- Building the pipeline ---");

        List<String> result = catalog.stream()
                .filter(book -> {
                    System.out.println("  filter(" + book.getTitle() + ")");
                    return book.getPages() > 400;
                })
                .map(book -> {
                    System.out.println("    map(" + book.getTitle() + ")");
                    return book.getTitle().toUpperCase();
                })
                .limit(2)
                .toList();

        System.out.println("--- Result: " + result + " ---");
    }
}

--- Building the pipeline ---
  filter(Effective Java)
    map(Effective Java)
  filter(Design Patterns)
  filter(Refactoring)
    map(Refactoring)
--- Result: [EFFECTIVE JAVA, REFACTORING] ---

// What the stream does NOT do: three traversals and two temporary lists
List<Book> filtered = new ArrayList<>();
for (Book b : catalog) if (b.getPages() > 400) filtered.add(b);

List<String> mapped = new ArrayList<>();
for (Book b : filtered) mapped.add(b.getTitle().toUpperCase());

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

// Stream.iterate generates elements ENDLESSLY
List<String> references = Stream.iterate(1, n -> n + 1)
        .map(n -> String.format("LN-2026-%04d", n))
        .limit(5)
        .toList();

System.out.println(references);

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

// Collections
Stream<Book> s1 = catalog.stream();
Stream<String> s2 = new HashSet<>(List.of("a", "b")).stream();

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

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

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

// With a stop condition (Java 9): limit is no longer needed
Stream<Integer> s7 = Stream.iterate(1, n -> n <= 100, n -> n * 2);

// Integer range
IntStream s8 = IntStream.rangeClosed(1, 12);   // 1..12

// Map: always through its entries
Map<String, Integer> loansByEmployee = Map.of("Marta Ruiz", 4, "Diego Alonso", 2);
Stream<Map.Entry<String, Integer>> s9 = loansByEmployee.entrySet().stream();

package com.nexussoftware.bibliotech.persistence;

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

public class CatalogImporter {

    /**
     * Reads a catalogue CSV with LAZY processing.
     *
     * try-with-resources (06-06) is MANDATORY: Files.lines keeps a file
     * descriptor open until the stream is closed.
     */
    public List<Book> importFrom(Path file) throws IOException {

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

            return lines
                    .skip(1)                                    // skip the header
                    .map(String::strip)
                    .filter(line -> !line.isBlank())            // ignore blank lines
                    .filter(line -> !line.startsWith("#"))      // ignore comments
                    .map(this::parse)
                    .filter(java.util.Objects::nonNull)         // drop the malformed ones
                    .toList();
        }
    }

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

    /** Counts lines of a 2 GB file without loading it into memory. */
    public long countLoansOf(Path file, String employee) throws IOException {
        try (Stream<String> lines = Files.lines(file, StandardCharsets.UTF_8)) {
            return lines.filter(l -> l.contains(employee)).count();
        }
    }
}

/** The three most recent backup files in a directory. */
public List<Path> recentBackups(Path directory) throws IOException {
    try (Stream<Path> paths = Files.walk(directory, 2)) {   // maximum depth 2
        return paths
                .filter(Files::isRegularFile)
                .filter(p -> p.getFileName().toString().endsWith(".bak"))
                .sorted(Comparator.comparing(this::lastModified).reversed())
                .limit(3)
                .toList();
    }
}

Stream<Book> filter(Predicate<? super T> criterion)

List<Book> onLoan = catalog.stream()
        .filter(Book::isOnLoan)
        .toList();

// Predicates can be composed (04-06)
Predicate<Book> longBook  = b -> b.getPages() > 400;
Predicate<Book> available = b -> !b.isOnLoan();

List<Book> longAndAvailable = catalog.stream()
        .filter(longBook.and(available))
        .toList();

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

List<String> titles = catalog.stream()
        .map(Book::getTitle)            // Stream<Book> -> Stream<String>
        .toList();

// Chaining transformations
List<Integer> lengths = catalog.stream()
        .map(Book::getTitle)            // Stream<String>
        .map(String::length)            // Stream<Integer>
        .toList();

// Into a record (04-07)
List<Card> cards = catalog.stream()
        .map(b -> new Card(b.getIsbn(), b.getTitle(), !b.isOnLoan()))
        .toList();

// Object -> primitive
int totalPages = catalog.stream()
        .mapToInt(Book::getPages)         // Stream<Book> -> IntStream
        .sum();                           // sum() exists ONLY in IntStream

// Primitive -> object
List<String> references = IntStream.rangeClosed(1, 3)
        .mapToObj(n -> String.format("LN-2026-%04d", n))   // IntStream -> Stream<String>
        .toList();

List<String> uniqueEmployees = loans.stream()
        .map(Loan::getEmployee)
        .distinct()
        .toList();

// Natural order: it requires T to implement Comparable (10-01)
List<String> sortedTitles = titles.stream().sorted().toList();

// With a Comparator (05-09)
List<Book> byPages = catalog.stream()
        .sorted(Comparator.comparingInt(Book::getPages).reversed())
        .toList();

// Composed ordering
List<Loan> sortedLoans = loans.stream()
        .sorted(Comparator.comparing(Loan::getEmployee)
                          .thenComparing(Loan::getLoanDay)
                          .reversed())
        .toList();

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

List<String> result = catalog.stream()
        .peek(b -> System.out.println("in: " + b.getTitle()))
        .filter(b -> b.getPages() > 400)
        .peek(b -> System.out.println("  passes the filter: " + b.getTitle()))
        .map(Book::getTitle)
        .toList();

List<Book> firstThree = catalog.stream().limit(3).toList();
List<Book> skippedTwo = catalog.stream().skip(2).toList();

// Pagination: page 3 with 10 elements per page
int page = 3, size = 10;
List<Book> currentPage = catalog.stream()
        .skip((long) (page - 1) * size)
        .limit(size)
        .toList();

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

public class Employee {
    private final String name;
    private final List<Loan> loans;

    public List<Loan> getLoans() { return loans; }
    public String getName() { return name; }
}

List<Employee> staff = List.of(
        new Employee("Marta Ruiz",   List.of(l1, l2, l3)),
        new Employee("Diego Alonso", List.of(l4)),
        new Employee("Nuria Vidal",  List.of(l5, l6)));

// WITH map: not what you want
Stream<List<Loan>> withMap = staff.stream().map(Employee::getLoans);
List<List<Loan>> nested = withMap.toList();
System.out.println(nested.size());        // 3: one list per employee

// WITH flatMap: flattened
List<Loan> all = staff.stream()
        .flatMap(employee -> employee.getLoans().stream())       // mind the .stream()!
        .toList();
System.out.println(all.size());           // 6: every loan

.flatMap(e -> e.getLoans().stream())          // GOOD
.flatMap(Employee::getLoans)                  // DOES NOT COMPILE: returns List, not Stream

// Every overdue loan in the whole library, sorted
List<Loan> overdue = staff.stream()
        .flatMap(e -> e.getLoans().stream())
        .filter(Loan::isOverdue)
        .sorted(Comparator.comparingInt(Loan::getDaysLate).reversed())
        .toList();

// Every incident of every loan of every employee: TWO levels
List<Loan.Incident> allIncidents = staff.stream()
        .flatMap(e -> e.getLoans().stream())
        .flatMap(l -> l.getIncidents().stream())
        .toList();

// Split strings into words
List<String> words = titles.stream()
        .flatMap(t -> Arrays.stream(t.split("\\s+")))
        .map(String::toLowerCase)
        .distinct()
        .sorted()
        .toList();

// Flatten a Map<String, List<Loan>>
List<Loan> flat = byEmployee.values().stream()
        .flatMap(List::stream)
        .toList();

// With Optional (Java 9): drop the empty ones in one go
List<Book> found = isbns.stream()
        .map(catalog::findByIsbn)          // Stream<Optional<Book>>
        .flatMap(Optional::stream)          // Stream<Book>, without the empties
        .toList();

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

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

[500, 480, 450, 420]      filter: ALL of those over 400
[500, 480, 450]           takeWhile: stops at 380
[380, 420, 300]           dropWhile: discards up to 380, then everything

// Log sorted by date: read only up to leaving the range, without traversing a 2 GB file
try (Stream<String> lines = Files.lines(logPath, StandardCharsets.UTF_8)) {
    List<String> today = lines
            .dropWhile(l -> !l.startsWith("2026-08-05"))    // skip earlier days
            .takeWhile(l ->  l.startsWith("2026-08-05"))    // stop on reaching tomorrow
            .toList();
}

catalog.stream()
        .filter(Book::isOnLoan)
        .forEach(b -> System.out.println(b.getTitle()));

catalog.parallelStream().forEach(System.out::println);         // unpredictable order
catalog.parallelStream().forEachOrdered(System.out::println);  // source order

// Java 16+: the short form. It returns an UNMODIFIABLE list.
List<String> titles = catalog.stream().map(Book::getTitle).toList();

// The classic form, with Collectors
List<String> titles2 = catalog.stream().map(Book::getTitle)
        .collect(Collectors.toList());       // modifiable, with no type guarantee

// If you need a modifiable list of a specific type
List<String> modifiable = catalog.stream().map(Book::getTitle)
        .collect(Collectors.toCollection(ArrayList::new));

long onLoan = catalog.stream().filter(Book::isOnLoan).count();

long n = catalog.stream()
        .peek(b -> System.out.println("seen: " + b.getTitle()))
        .count();
// It prints nothing: count() knows the list's size without traversing it

Optional<Book> longest = catalog.stream()
        .max(Comparator.comparingInt(Book::getPages));

longest.ifPresent(b -> System.out.println("The longest: " + b.getTitle()));

// With a default value
String title = catalog.stream()
        .min(Comparator.comparing(Book::getTitle))
        .map(Book::getTitle)
        .orElse("(empty catalogue)");

boolean anyOnLoan       = catalog.stream().anyMatch(Book::isOnLoan);
boolean allAvailable    = catalog.stream().allMatch(b -> !b.isOnLoan());
boolean noneWithoutName = catalog.stream().noneMatch(b -> b.getTitle().isBlank());

System.out.println(catalog.stream()
        .peek(b -> System.out.println("checking: " + b.getTitle()))
        .anyMatch(b -> b.getPages() > 400));

checking: Effective Java
true

List<Book> empty = List.of();
System.out.println(empty.stream().anyMatch(b -> true));    // false
System.out.println(empty.stream().allMatch(b -> false));   // true!
System.out.println(empty.stream().noneMatch(b -> true));   // true

Optional<Book> first = catalog.stream()
        .filter(b -> b.getPages() > 400)
        .findFirst();

Optional<Book> any = catalog.parallelStream()
        .filter(b -> b.getPages() > 400)
        .findAny();

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

Optional<Integer> totalPages = catalog.stream()
        .map(Book::getPages)
        .reduce((a, b) -> a + b);

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

step 1: accumulator = 412           (first element)
step 2: accumulator = 412 + 395 = 807
step 3: accumulator = 807 + 448 = 1255
result: Optional[1255]

T reduce(T identity, BinaryOperator<T> accumulator)

int totalPages = catalog.stream()
        .map(Book::getPages)
        .reduce(0, Integer::sum);         // 0 is the identity

String allTitles = catalog.stream()
        .map(Book::getTitle)
        .reduce("", (a, b) -> a.isEmpty() ? b : a + " | " + b);

// WRONG: incorrect identity
int sum = Stream.of(1, 2, 3, 4).reduce(10, Integer::sum);
System.out.println(sum);                               // 20, not 10

int parallelSum = Stream.of(1, 2, 3, 4).parallel().reduce(10, Integer::sum);
System.out.println(parallelSum);                       // 50! the 10 was added in every partition

<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)

// Summing the pages of Book objects, producing an int
int totalPages = catalog.parallelStream()
        .reduce(0,                                  // identity: an int
                (sum, book) -> sum + book.getPages(),         // accumulate Book into int
                Integer::sum);                      // merge two partial ints

List<String> list = catalog.stream().map(Book::getTitle).collect(Collectors.toList());
Set<String> set = catalog.stream().map(Book::getAuthor).collect(Collectors.toSet());

// toMap: key and value
Map<String, Book> byIsbn = catalog.stream()
        .collect(Collectors.toMap(Book::getIsbn, book -> book));

Map<String, String> titleByIsbn = catalog.stream()
        .collect(Collectors.toMap(Book::getIsbn, Book::getTitle));

// Two books by the same author
Map<String, String> byAuthor = catalog.stream()
        .collect(Collectors.toMap(Book::getAuthor, Book::getTitle));

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

// Keep the first one
Map<String, String> first = catalog.stream()
        .collect(Collectors.toMap(Book::getAuthor, Book::getTitle,
                                  (existing, replacement) -> existing));

// Keep the last one
Map<String, String> last = catalog.stream()
        .collect(Collectors.toMap(Book::getAuthor, Book::getTitle,
                                  (existing, replacement) -> replacement));

// Combine
Map<String, String> combined = catalog.stream()
        .collect(Collectors.toMap(Book::getAuthor, Book::getTitle,
                                  (a, b) -> a + "; " + b));

// And with a fourth argument you choose the Map implementation
Map<String, String> ordered = catalog.stream()
        .collect(Collectors.toMap(Book::getIsbn, Book::getTitle,
                                  (a, b) -> a, TreeMap::new));

String titles = catalog.stream()
        .map(Book::getTitle)
        .collect(Collectors.joining(", "));
// Effective Java, Design Patterns, Refactoring

String withBorders = catalog.stream()
        .map(Book::getTitle)
        .collect(Collectors.joining(", ", "Catalogue [", "]"));
// Catalogue [Effective Java, Design Patterns, Refactoring]

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

int pages = catalog.stream().collect(Collectors.summingInt(Book::getPages));
double average = catalog.stream().collect(Collectors.averagingInt(Book::getPages));
double ratingSum = catalog.stream().collect(Collectors.summingDouble(Book::getRating));
double ratingAverage = catalog.stream().collect(Collectors.averagingDouble(Book::getRating));

// Everything at once, in a single traversal
IntSummaryStatistics stats = catalog.stream()
        .collect(Collectors.summarizingInt(Book::getPages));

System.out.println("Books:   " + stats.getCount());
System.out.println("Total:   " + stats.getSum());
System.out.println("Average: " + stats.getAverage());
System.out.println("Minimum: " + stats.getMin());
System.out.println("Maximum: " + stats.getMax());

Books:   4
Total:   1719
Average: 429.75
Minimum: 395
Maximum: 464

Map<MaterialType, List<Material>> byType = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType));

{BOOK=[Effective Java, Design Patterns, Refactoring],
 MAGAZINE=[Java Magazine],
 DVD=[Spring Course]}

Map<MaterialType, List<Material>> byType = new HashMap<>();
for (Material m : inventory) {
    byType.computeIfAbsent(m.getType(), t -> new ArrayList<>()).add(m);
}

// How many materials of each type
Map<MaterialType, Long> countByType = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType, Collectors.counting()));
// {BOOK=3, MAGAZINE=1, DVD=1}

// Total pages by type
Map<MaterialType, Integer> pagesByType = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType,
                                       Collectors.summingInt(Material::getPages)));

// Average rating by type
Map<MaterialType, Double> averageByType = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType,
                                       Collectors.averagingDouble(Material::getRating)));

// Only the TITLES of each group: mapping transforms before accumulating
Map<MaterialType, List<String>> titlesByType = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType,
                                       Collectors.mapping(Material::getTitle,
                                                          Collectors.toList())));

// The best rated of each type: it returns Optional inside the map
Map<MaterialType, Optional<Material>> bestByType = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType,
                 Collectors.maxBy(Comparator.comparingDouble(Material::getRating))));

// Without the Optional, with maxBy reduced (Java 9)
Map<MaterialType, Material> bestByType2 = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType,
                 Collectors.collectingAndThen(
                     Collectors.maxBy(Comparator.comparingDouble(Material::getRating)),
                     opt -> opt.orElse(null))));

// Full statistics by type
Map<MaterialType, IntSummaryStatistics> statsByType = inventory.stream()
        .collect(Collectors.groupingBy(Material::getType,
                                       Collectors.summarizingInt(Material::getPages)));

// With a TreeMap so that the keys come out sorted
Map<String, Long> byAuthorSorted = catalog.stream()
        .collect(Collectors.groupingBy(Book::getAuthor, TreeMap::new, Collectors.counting()));

// Loans by employee and, within that, by material type
Map<String, Map<MaterialType, List<Loan>>> byEmployeeAndType = loans.stream()
        .collect(Collectors.groupingBy(
                Loan::getEmployee,
                Collectors.groupingBy(l -> l.getMaterial().getType())));

// And with counting on the inner level
Map<String, Map<MaterialType, Long>> countByEmployeeAndType = loans.stream()
        .collect(Collectors.groupingBy(
                Loan::getEmployee,
                Collectors.groupingBy(l -> l.getMaterial().getType(),
                                      Collectors.counting())));

{Marta Ruiz={BOOK=3, DVD=1},
 Diego Alonso={BOOK=1, MAGAZINE=2},
 Nuria Vidal={BOOK=2}}

Map<Boolean, List<Book>> byAvailability = catalog.stream()
        .collect(Collectors.partitioningBy(Book::isOnLoan));

List<Book> onLoan    = byAvailability.get(true);
List<Book> available = byAvailability.get(false);

// With a downstream
Map<Boolean, Long> count = catalog.stream()
        .collect(Collectors.partitioningBy(b -> b.getPages() > 400,
                                           Collectors.counting()));

record CatalogSummary(long total, double averagePages) { }

CatalogSummary summary = catalog.stream()
        .collect(Collectors.teeing(
                Collectors.counting(),
                Collectors.averagingInt(Book::getPages),
                CatalogSummary::new));

// Sum without autoboxing
int totalPages = catalog.stream()
        .mapToInt(Book::getPages)
        .sum();

// Average: it returns OptionalDouble, because an empty stream has no average
OptionalDouble average = catalog.stream()
        .mapToInt(Book::getPages)
        .average();

System.out.printf("Average: %.1f pages%n", average.orElse(0.0));

// Statistics in one go
IntSummaryStatistics stats = catalog.stream()
        .mapToInt(Book::getPages)
        .summaryStatistics();

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

// Back to objects
List<Integer> list = IntStream.rangeClosed(1, 5).boxed().toList();
List<String> refs = IntStream.rangeClosed(1, 3)
        .mapToObj(n -> String.format("LN-2026-%04d", n))
        .toList();

// Characters of a string
long vowels = "Effective Java".chars()
        .filter(c -> "aeiouAEIOU".indexOf(c) >= 0)
        .count();

OptionalDouble average = catalog.stream().mapToInt(Book::getPages).average();

String text = average.isPresent()
        ? String.format("%.1f", average.getAsDouble())
        : "no data";

// Or by converting to Optional<Double>
String text2 = average.stream().boxed().findFirst()
        .map(d -> String.format("%.1f", d))
        .orElse("no data");

List<Book> result = catalog.parallelStream()          // from the collection
        .filter(b -> b.getPages() > 400)
        .toList();

List<Book> result2 = catalog.stream()
        .parallel()                                    // from an existing stream
        .filter(b -> b.getPages() > 400)
        .toList();

System.out.println("Parallelism: " + ForkJoinPool.getCommonPoolParallelism());
System.out.println("Cores:       " + Runtime.getRuntime().availableProcessors());

Parallelism: 7
Cores:       8

ForkJoinPool ownPool = new ForkJoinPool(4);
try {
    List<Book> result = ownPool.submit(() ->
            catalog.parallelStream().filter(...).toList()).get();
} finally {
    ownPool.shutdown();
}

package com.nexussoftware.bibliotech;

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

public class ParallelMeasurement {

    public static void main(String[] args) {

        // WARNING: this is a HOMEMADE measurement. The numbers are
        // indicative; to measure properly you need JMH (10-07).

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

        warmUp(large);

        measure("1,000 elements, trivial sum, sequential     ",
                () -> small.stream().mapToLong(Integer::longValue).sum());
        measure("1,000 elements, trivial sum, PARALLEL       ",
                () -> small.parallelStream().mapToLong(Integer::longValue).sum());

        measure("10M elements, trivial sum, sequential       ",
                () -> large.stream().mapToLong(Integer::longValue).sum());
        measure("10M elements, trivial sum, PARALLEL         ",
                () -> large.parallelStream().mapToLong(Integer::longValue).sum());

        measure("10M elements, heavy computation, sequential ",
                () -> large.stream().mapToLong(ParallelMeasurement::costly).sum());
        measure("10M elements, heavy computation, PARALLEL   ",
                () -> large.parallelStream().mapToLong(ParallelMeasurement::costly).sum());

        // LinkedList: expensive splitting
        List<Integer> linked = new LinkedList<>(IntStream.range(0, 1_000_000).boxed().toList());
        measure("1M in a LinkedList, sequential              ",
                () -> linked.stream().mapToLong(Integer::longValue).sum());
        measure("1M in a LinkedList, PARALLEL                ",
                () -> linked.parallelStream().mapToLong(Integer::longValue).sum());
    }

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

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

    private static void measure(String label, java.util.function.LongSupplier task) {
        long start = System.nanoTime();
        long result = task.getAsLong();
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("%s -> %6d ms  (result: %d)%n", label, ms, result);
    }
}

1,000 elements, trivial sum, sequential      ->      0 ms  (result: 499500)
1,000 elements, trivial sum, PARALLEL        ->      2 ms  (result: 499500)
10M elements, trivial sum, sequential        ->     58 ms  (result: 49999995000000)
10M elements, trivial sum, PARALLEL          ->     21 ms  (result: 49999995000000)
10M elements, heavy computation, sequential  ->    712 ms  (result: -1583)
10M elements, heavy computation, PARALLEL    ->    134 ms  (result: -1583)
1M in a LinkedList, sequential               ->     11 ms  (result: 499999500000)
1M in a LinkedList, PARALLEL                 ->     34 ms  (result: 499999500000)

// CATASTROPHIC: ArrayList is not thread-safe (08-06)
List<String> result = new ArrayList<>();
catalog.parallelStream().forEach(b -> result.add(b.getTitle()));

// CORRECT: collect handles the combining for you
List<String> result = catalog.parallelStream()
        .map(Book::getTitle)
        .toList();

package com.nexussoftware.bibliotech.service;

import java.util.*;

/** OLD VERSION: the one from module 5. */
public class LegacyBiblioTechStatistics {

    public Map<MaterialType, Long> countByType(List<Material> inventory) {
        Map<MaterialType, Long> result = new HashMap<>();
        for (Material m : inventory) {
            Long current = result.get(m.getType());
            result.put(m.getType(), current == null ? 1L : current + 1);
        }
        return result;
    }

    public Map<String, List<String>> titlesByEmployee(List<Loan> loans) {
        Map<String, List<String>> result = new HashMap<>();
        for (Loan l : loans) {
            List<String> list = result.get(l.getEmployee());
            if (list == null) {
                list = new ArrayList<>();
                result.put(l.getEmployee(), list);
            }
            list.add(l.getMaterial().getTitle());
        }
        for (List<String> list : result.values()) {
            Collections.sort(list);
        }
        return result;
    }

    public String employeeWithMostLoans(List<Loan> loans) {
        Map<String, Integer> count = new HashMap<>();
        for (Loan l : loans) {
            Integer current = count.get(l.getEmployee());
            count.put(l.getEmployee(), current == null ? 1 : current + 1);
        }
        String best = null;
        int maximum = -1;
        for (Map.Entry<String, Integer> e : count.entrySet()) {
            if (e.getValue() > maximum) {
                maximum = e.getValue();
                best = e.getKey();
            }
        }
        return best;                     // null if the list was empty
    }

    public double averagePagesOnLoan(List<Material> inventory) {
        int sum = 0;
        int count = 0;
        for (Material m : inventory) {
            if (m.isOnLoan() && m instanceof Book) {
                sum += ((Book) m).getPages();
                count++;
            }
        }
        return count == 0 ? 0.0 : (double) sum / count;
    }
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.*;

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

/**
 * STREAMS VERSION. Same behaviour, a third of the code,
 * and every method reads like the sentence that describes it.
 */
public class BiblioTechStatistics {

    /** How many materials there are of each type. */
    public Map<MaterialType, Long> countByType(List<Material> inventory) {
        return inventory.stream()
                .collect(Collectors.groupingBy(Material::getType, Collectors.counting()));
    }

    /** Titles lent to each employee, sorted alphabetically. */
    public Map<String, List<String>> titlesByEmployee(List<Loan> loans) {
        return loans.stream()
                .collect(Collectors.groupingBy(
                        Loan::getEmployee,
                        TreeMap::new,
                        Collectors.mapping(l -> l.getMaterial().getTitle(),
                                           Collectors.collectingAndThen(
                                                   Collectors.toList(),
                                                   list -> { list.sort(null); return list; }))));
    }

    /** The employee with the most loans. Optional instead of null. */
    public Optional<String> employeeWithMostLoans(List<Loan> loans) {
        return loans.stream()
                .collect(Collectors.groupingBy(Loan::getEmployee, Collectors.counting()))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey);
    }

    /** Average pages of the books on loan. */
    public OptionalDouble averagePagesOnLoan(List<Material> inventory) {
        return inventory.stream()
                .filter(Material::isOnLoan)
                .filter(Book.class::isInstance)          // the instanceof of 10-03
                .map(Book.class::cast)
                .mapToInt(Book::getPages)
                .average();
    }

    /** Full report by type: count, pages and average rating. */
    public Map<MaterialType, TypeSummary> fullReport(List<Material> inventory) {
        return inventory.stream()
                .collect(Collectors.groupingBy(
                        Material::getType,
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                list -> new TypeSummary(
                                        list.size(),
                                        list.stream().mapToInt(Material::getPages).sum(),
                                        list.stream().mapToDouble(Material::getRating)
                                            .average().orElse(0.0)))));
    }

    public record TypeSummary(int count, int totalPages, double averageRating) { }

    /** Loans by employee and type: the two-level report. */
    public Map<String, Map<MaterialType, Long>> employeeTypeMatrix(List<Loan> loans) {
        return loans.stream()
                .collect(Collectors.groupingBy(
                        Loan::getEmployee,
                        TreeMap::new,
                        Collectors.groupingBy(l -> l.getMaterial().getType(),
                                              () -> new EnumMap<>(MaterialType.class),
                                              Collectors.counting())));
    }

    /** The N best rated materials. */
    public List<Material> topRated(List<Material> inventory, int n) {
        return inventory.stream()
                .sorted(Comparator.comparingDouble(Material::getRating).reversed())
                .limit(n)
                .toList();
    }

    /** Every incident of every loan, grouped by severity. */
    public Map<Severity, List<String>> incidentsBySeverity(List<Loan> loans) {
        return loans.stream()
                .flatMap(l -> l.getIncidents().stream())
                .collect(Collectors.groupingBy(
                        Loan.Incident::severity,
                        () -> new EnumMap<>(Severity.class),
                        Collectors.mapping(Loan.Incident::description,
                                           Collectors.toList())));
    }

    /** Summary line for the library dashboard. */
    public String oneLineSummary(List<Material> inventory) {
        return inventory.stream()
                .collect(Collectors.groupingBy(Material::getType,
                         () -> new EnumMap<>(MaterialType.class),
                         Collectors.counting()))
                .entrySet().stream()
                .map(e -> e.getKey() + "=" + e.getValue())
                .collect(Collectors.joining(", ", "Inventory [", "]"));
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domain.*;
import com.nexussoftware.bibliotech.service.BiblioTechStatistics;

import java.util.List;

public class BiblioTechReport {

    public static void main(String[] args) {

        List<Material> inventory = TestData.inventory();
        List<Loan> loans         = TestData.loans();

        BiblioTechStatistics stats = new BiblioTechStatistics();

        System.out.println("=== BIBLIOTECH REPORT ===");
        System.out.println(stats.oneLineSummary(inventory));
        System.out.println();

        System.out.println("--- Materials by type ---");
        stats.fullReport(inventory).forEach((type, r) ->
                System.out.printf("  %-8s %2d units, %5d pages, rating %.2f%n",
                        type, r.count(), r.totalPages(), r.averageRating()));

        System.out.println();
        System.out.println("--- Loans by employee and type ---");
        stats.employeeTypeMatrix(loans).forEach((employee, byType) ->
                System.out.printf("  %-14s %s%n", employee, byType));

        System.out.println();
        System.out.println("--- Titles by employee ---");
        stats.titlesByEmployee(loans).forEach((employee, titles) ->
                System.out.printf("  %-14s %s%n", employee, titles));

        System.out.println();
        stats.employeeWithMostLoans(loans)
             .ifPresentOrElse(e -> System.out.println("Top reader: " + e),
                              () -> System.out.println("There are no loans on record"));

        System.out.printf("Average pages of what is on loan: %.1f%n",
                stats.averagePagesOnLoan(inventory).orElse(0.0));

        System.out.println();
        System.out.println("--- Top 3 best rated ---");
        stats.topRated(inventory, 3)
             .forEach(m -> System.out.printf("  %.2f  %s%n", m.getRating(), m.getTitle()));
    }
}

=== BIBLIOTECH REPORT ===
Inventory [BOOK=5, MAGAZINE=2, DVD=1]

--- Materials by type ---
  BOOK      5 units,  2119 pages, rating 4.62
  MAGAZINE  2 units,   140 pages, rating 3.90
  DVD       1 units,     0 pages, rating 4.10

--- Loans by employee and type ---
  Diego Alonso   {BOOK=1, MAGAZINE=2}
  Marta Ruiz     {BOOK=3, DVD=1}
  Nuria Vidal    {BOOK=2}

--- Titles by employee ---
  Diego Alonso   [Java Magazine 04, Java Magazine 05, Refactoring]
  Marta Ruiz     [Clean Code, Design Patterns, Effective Java, Spring Course]
  Nuria Vidal    [Domain-Driven Design, Effective Java]

Top reader: Marta Ruiz
Average pages of what is on loan: 428.3
--- Top 3 best rated ---
  4.85  Effective Java
  4.72  Refactoring
  4.60  Design Patterns

public Loan findByReference(String reference) {
    for (Loan l : loans) {
        if (l.getReference().equals(reference)) {
            return l;
        }
    }
    return null;                       // "not found"
}

Loan l = registry.findByReference("LN-2026-0041");
System.out.println(l.getEmployee());       // NullPointerException if it does not exist

public Optional<Loan> findByReference(String reference) {
    for (Loan l : loans) {
        if (l.getReference().equals(reference)) {
            return Optional.of(l);
        }
    }
    return Optional.empty();
}

Optional<Loan> l = registry.findByReference("LN-2026-0041");
// l.getEmployee();       // DOES NOT COMPILE: Optional has no getEmployee()

String employee = l.map(Loan::getEmployee).orElse("(no loan)");

// of: the value CANNOT be null. If it is, an immediate NullPointerException.
Optional<Book> a = Optional.of(book);

// ofNullable: it accepts null and produces an empty Optional
Optional<Book> b = Optional.ofNullable(mayBeNull);

// empty: explicitly empty
Optional<Book> c = Optional.empty();

// WRONG: if the map does not have the key, this throws NullPointerException
Optional<Book> book = Optional.of(map.get(isbn));

// RIGHT
Optional<Book> book = Optional.ofNullable(map.get(isbn));

// map: transforms the value if it exists. If it is empty, it stays empty.
Optional<String> title = catalog.findByIsbn(isbn).map(Book::getTitle);

// Chaining
String uppercase = catalog.findByIsbn(isbn)
        .map(Book::getTitle)
        .map(String::toUpperCase)
        .orElse("UNKNOWN");

// filter: empties the Optional if it does not match
Optional<Book> longAndAvailable = catalog.findByIsbn(isbn)
        .filter(b -> b.getPages() > 400)
        .filter(b -> !b.isOnLoan());

public class Book {
    public Optional<String> getPublisher() { ... }   // it may not have one
}

// With map: you end up with nested Optionals
Optional<Optional<String>> wrong = catalog.findByIsbn(isbn).map(Book::getPublisher);

// With flatMap: flattened
Optional<String> right = catalog.findByIsbn(isbn).flatMap(Book::getPublisher);

// orElse: default value
String title = opt.map(Book::getTitle).orElse("(unknown)");

// orElseGet: default value computed LAZILY (section 18)
Book book = opt.orElseGet(() -> loadFromNetwork(isbn));

// orElseThrow: throw if there is nothing
Book book2 = opt.orElseThrow(() ->
        new BiblioTechException("There is no material " + isbn));

// orElseThrow() with no arguments (Java 10): throws NoSuchElementException
Book book3 = opt.orElseThrow();

// or: another Optional if this one is empty (Java 9)
Optional<Book> found = localCatalog.findByIsbn(isbn)
        .or(() -> remoteCatalog.findByIsbn(isbn))
        .or(() -> archiveCatalog.findByIsbn(isbn));

// ifPresent: do something if there is a value
catalog.findByIsbn(isbn).ifPresent(b -> System.out.println("Found: " + b.getTitle()));

// ifPresentOrElse: and if not, something else (Java 9)
catalog.findByIsbn(isbn).ifPresentOrElse(
        b  -> System.out.println("Found: " + b.getTitle()),
        () -> System.out.println("There is no material with ISBN " + isbn));

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

// BEFORE Java 9: two steps
List<Book> found1 = isbns.stream()
        .map(catalog::findByIsbn)          // Stream<Optional<Book>>
        .filter(Optional::isPresent)
        .map(Optional::get)
        .toList();

// SINCE Java 9: one step
List<Book> found2 = isbns.stream()
        .map(catalog::findByIsbn)          // Stream<Optional<Book>>
        .flatMap(Optional::stream)          // Stream<Book>, without the empties
        .toList();

T orElse(T other)                   // it takes an ALREADY COMPUTED value
T orElseGet(Supplier<? extends T> supplier)     // it takes a FUNCTION that computes it

package com.nexussoftware.bibliotech;

import java.util.Optional;

public class OrElseVsOrElseGet {

    private static Book loadFromNetwork(String isbn) {
        System.out.println("  >>> QUERYING THE NETWORK for " + isbn + " (300 ms)");
        return new Book(isbn, "Retrieved from the network");
    }

    public static void main(String[] args) {

        Optional<Book> withValue = Optional.of(new Book("978-0000000001", "Effective Java"));

        System.out.println("--- orElse with a value present ---");
        Book a = withValue.orElse(loadFromNetwork("978-0000000001"));
        System.out.println("Result: " + a.getTitle());

        System.out.println();
        System.out.println("--- orElseGet with a value present ---");
        Book b = withValue.orElseGet(() -> loadFromNetwork("978-0000000001"));
        System.out.println("Result: " + b.getTitle());

        System.out.println();
        System.out.println("--- orElseGet with an empty Optional ---");
        Book c = Optional.<Book>empty().orElseGet(() -> loadFromNetwork("978-9999999999"));
        System.out.println("Result: " + c.getTitle());
    }
}

--- orElse with a value present ---
  >>> QUERYING THE NETWORK for 978-0000000001 (300 ms)
Result: Effective Java

--- orElseGet with a value present ---
Result: Effective Java

--- orElseGet with an empty Optional ---
  >>> QUERYING THE NETWORK for 978-9999999999 (300 ms)
Result: Retrieved from the network

// A counter that is incremented even when the value exists
int nextId = opt.orElse(generateNewId());          // it always generates an ID!

// An empty Optional that produces NullPointerException
String s = opt.orElse(other.getTitle());           // if 'other' is null, it always blows up

// GOOD: a constant
String title = opt.map(Book::getTitle).orElse("(no title)");

// GOOD: expensive computation, evaluated only if needed
Book book = opt.orElseGet(() -> loadFromNetwork(isbn));

// GOOD: exception built only if needed
// (building an exception captures the stack trace, which is not free)
Book book2 = opt.orElseThrow(() -> new BiblioTechException("There is no " + isbn));

// WRONG: it is an if in disguise, noisier than the original null
Optional<Book> opt = catalog.findByIsbn(isbn);
if (opt.isPresent()) {
    System.out.println(opt.get().getTitle());
} else {
    System.out.println("Not found");
}

// RIGHT
catalog.findByIsbn(isbn).ifPresentOrElse(
        b  -> System.out.println(b.getTitle()),
        () -> System.out.println("Not found"));

// Or if you need the value
String title = catalog.findByIsbn(isbn)
        .map(Book::getTitle)
        .orElse("Not found");

// WRONG
public List<Book> search(String text, Optional<MaterialType> type) { ... }

// RIGHT
public List<Book> search(String text) {
    return search(text, null);
}

public List<Book> search(String text, MaterialType type) { ... }

// WRONG
public class Book {
    private Optional<String> publisher;      // NO
}

// RIGHT: the field is null; the ACCESSOR returns Optional
public class Book {

    private String publisher;                // it can be null

    public Optional<String> getPublisher() {
        return Optional.ofNullable(publisher);
    }
}

// WRONG
public Optional<List<Loan>> loansOf(String employee) { ... }

// RIGHT: an empty list ALREADY means "there is nothing"
public List<Loan> loansOf(String employee) {
    return loans.stream()
            .filter(l -> l.getEmployee().equals(employee))
            .toList();                       // empty if there are none
}

// WRONG: guaranteed NullPointerException
return Optional.of(map.get(key));

// WORSE: a method that returns Optional and sometimes returns null
public Optional<Book> find(String isbn) {
    if (isbn == null) return null;           // it destroys the whole point!
    ...
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.Identifiable;

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;

/**
 * Generic repository (10-01) with a streams and Optional API (10-04).
 */
public class Repository<T extends Identifiable> {

    private final Map<String, T> byId = new ConcurrentHashMap<>();
    private final String name;

    public Repository(String name) {
        this.name = Objects.requireNonNull(name, "name");
    }

    public Optional<T> save(T entity) {
        Objects.requireNonNull(entity, "entity");
        return Optional.ofNullable(byId.put(entity.getId(), entity));
    }

    /** The signature SAYS it may find nothing. */
    public Optional<T> findById(String id) {
        return Optional.ofNullable(byId.get(id));
    }

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

    /**
     * It exposes a stream instead of a copy of the list.
     * The caller decides what to do without the repository
     * having to offer a method for every possible query.
     */
    public Stream<T> stream() {
        return byId.values().stream();
    }

    /** Never null: an empty list already means "none". */
    public List<T> find(Predicate<? super T> criterion) {
        return stream().filter(criterion).toList();
    }

    /** The first one that matches, or empty. */
    public Optional<T> findFirst(Predicate<? super T> criterion) {
        return stream().filter(criterion).findFirst();
    }

    public List<T> listSorted(Comparator<? super T> order) {
        return stream().sorted(order).toList();
    }

    public long count(Predicate<? super T> criterion) {
        return stream().filter(criterion).count();
    }

    public boolean existsAny(Predicate<? super T> criterion) {
        return stream().anyMatch(criterion);
    }

    /** Indexes by any derived key. */
    public <K> Map<K, List<T>> groupBy(Function<? super T, ? extends K> classifier) {
        return stream().collect(Collectors.groupingBy(classifier));
    }

    public int size() {
        return byId.size();
    }

    @Override
    public String toString() {
        return "Repository[" + name + ", " + byId.size() + " entities]";
    }
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.annotations.Auditable;
import com.nexussoftware.bibliotech.domain.*;

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

public class LoanManager implements LoanService {

    private final Repository<Material> catalog;
    private final Repository<Loan> loans;

    public LoanManager(Repository<Material> catalog, Repository<Loan> loans) {
        this.catalog = catalog;
        this.loans = loans;
    }

    /**
     * BEFORE: findById returned null and it had to be checked.
     * NOW: the absence is chained and produces the right failure.
     */
    @Override
    @Auditable(value = "lend", level = Severity.HIGH, logArguments = true)
    public Result<Loan> lend(String isbn, String employee) {

        return catalog.findById(isbn)
                .map(material -> register(material, employee))
                .orElseGet(() -> Result.failure("There is no material with ISBN " + isbn));
    }

    private Result<Loan> register(Material material, String employee) {
        if (material.isOnLoan()) {
            return Result.failure("The material '" + material.getTitle() + "' is already on loan");
        }
        material.markOnLoan(employee);
        Loan loan = new Loan(nextReference(), material.getId(), employee);
        loans.save(loan);
        return Result.success(loan);
    }

    /** An empty list, never null. */
    @Override
    public List<Loan> loansOf(String employee) {
        return loans.find(l -> l.getEmployee().equals(employee));
    }

    /** Optional instead of null. */
    @Override
    public Optional<Loan> findByReference(String reference) {
        return loans.findById(reference);
    }

    /** The title of the material lent to an employee that is most overdue. */
    public Optional<String> mostOverdueMaterialOf(String employee) {
        return loans.stream()
                .filter(l -> l.getEmployee().equals(employee))
                .filter(Loan::isOverdue)
                .max(Comparator.comparingInt(Loan::getDaysLate))
                .flatMap(l -> catalog.findById(l.getIsbn()))       // flatMap: it returns Optional
                .map(Material::getTitle);
    }

    /** Total fine debt by employee, only for those who owe something. */
    public Map<String, Double> debtByEmployee(FineCalculator calculator) {
        return loans.stream()
                .filter(Loan::isOverdue)
                .collect(Collectors.groupingBy(
                        Loan::getEmployee,
                        TreeMap::new,
                        Collectors.summingDouble(l -> calculator.calculate(l.getDaysLate()))));
    }

    private String nextReference() {
        return String.format("LN-2026-%04d", loans.size() + 1);
    }
}

manager.lend("978-0000000001", "Marta Ruiz")
       .map(Loan::getId)
       .map(id -> "Loan registered: " + id)
       .ifPresent(System.out::println);

manager.mostOverdueMaterialOf("Diego Alonso")
       .ifPresentOrElse(
               t  -> System.out.println("Return urgently: " + t),
               () -> System.out.println("Diego Alonso has nothing overdue"));

manager.debtByEmployee(calculator)
       .forEach((employee, debt) -> System.out.printf("  %-14s %.2f EUR%n", employee, debt));

Loan registered: LN-2026-0009
Return urgently: Refactoring
  Diego Alonso   3.25 EUR
  Marta Ruiz     1.50 EUR

Predicate<Book> isLongAndOnLoan = b -> b.getPages() > 400 && b.isOnLoan();
List<Book> result = catalog.stream().filter(isLongAndOnLoan).toList();

2026-08-05|INFO|lend|Marta Ruiz|12
2026-08-05|SEVERE|return|Diego Alonso|340

package com.nexussoftware.bibliotech.presentation;

import com.nexussoftware.bibliotech.domain.*;

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

/**
 * Library dashboard generated entirely with streams.
 * Not one for, not one null, not one Optional.get().
 */
public class BiblioTechDashboard {

    private final List<Material> inventory;
    private final List<Loan> loans;

    public BiblioTechDashboard(List<Material> inventory, List<Loan> loans) {
        this.inventory = List.copyOf(inventory);
        this.loans     = List.copyOf(loans);
    }

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

        inventorySection(sb);
        topSection(sb);
        loansSection(sb);
        rankingSection(sb);
        pagesSection(sb);
        neverLoanedSection(sb);
        histogramSection(sb);

        return sb.toString();
    }

    // --- 1. Inventory by type ---
    private void inventorySection(StringBuilder sb) {
        Map<MaterialType, Long> byType = inventory.stream()
                .collect(Collectors.groupingBy(Material::getType,
                         () -> new EnumMap<>(MaterialType.class),
                         Collectors.counting()));

        sb.append("\n1. INVENTORY (").append(inventory.size()).append(" materials)\n");
        byType.forEach((type, n) ->
                sb.append(String.format("   %-10s %3d  %s%n", type, n, "#".repeat(n.intValue()))));
    }

    // --- 2. Top 3 best rated ---
    private void topSection(StringBuilder sb) {
        sb.append("\n2. BEST RATED\n");
        inventory.stream()
                .sorted(Comparator.comparingDouble(Material::getRating).reversed())
                .limit(3)
                .forEach(m -> sb.append(String.format("   %.2f  %s%n",
                        m.getRating(), m.getTitle())));
    }

    // --- 3. Loans by employee ---
    private void loansSection(StringBuilder sb) {
        Map<String, List<String>> byEmployee = loans.stream()
                .collect(Collectors.groupingBy(
                        Loan::getEmployee,
                        TreeMap::new,
                        Collectors.mapping(Loan::getMaterialTitle,
                                Collectors.collectingAndThen(
                                        Collectors.toList(),
                                        list -> list.stream().sorted().toList()))));

        sb.append("\n3. ACTIVE LOANS\n");
        byEmployee.forEach((employee, titles) -> {
            sb.append(String.format("   %-14s (%d)%n", employee, titles.size()));
            titles.forEach(t -> sb.append("      - ").append(t).append('\n'));
        });
    }

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

        Optional<String> mostLoans = loans.stream()
                .collect(Collectors.groupingBy(Loan::getEmployee, Collectors.counting()))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey);

        sb.append("   Most loans:      ")
          .append(mostLoans.orElse("(there are no loans)")).append('\n');

        Optional<String> mostDaysLate = loans.stream()
                .filter(Loan::isOverdue)
                .collect(Collectors.groupingBy(Loan::getEmployee,
                         Collectors.summingInt(Loan::getDaysLate)))
                .entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(e -> e.getKey() + " (" + e.getValue() + " days)");

        sb.append("   Most days late:  ")
          .append(mostDaysLate.orElse("(nobody is overdue)")).append('\n');
    }

    // --- 5. Page statistics in ONE traversal ---
    private void pagesSection(StringBuilder sb) {
        IntSummaryStatistics stats = inventory.stream()
                .filter(Book.class::isInstance)
                .map(Book.class::cast)
                .mapToInt(Book::getPages)
                .summaryStatistics();

        sb.append("\n5. PAGES OF THE BOOKS\n");
        sb.append(String.format("   books=%d  average=%.1f  min=%d  max=%d  total=%d%n",
                stats.getCount(), stats.getAverage(),
                // With 0 books, getMin() returns MAX_VALUE: it must be handled
                stats.getCount() == 0 ? 0 : stats.getMin(),
                stats.getCount() == 0 ? 0 : stats.getMax(),
                stats.getSum()));
    }

    // --- 6. Never lent ---
    private void neverLoanedSection(StringBuilder sb) {
        // Set of ISBNs ever lent: the lookup becomes O(1)
        Set<String> everLoaned = loans.stream()
                .map(Loan::getIsbn)
                .collect(Collectors.toSet());

        List<String> never = inventory.stream()
                .filter(m -> !everLoaned.contains(m.getId()))
                .map(Material::getTitle)
                .sorted()
                .toList();

        sb.append("\n6. NEVER LENT (").append(never.size()).append(")\n");
        sb.append(never.isEmpty()
                ? "   (the whole catalogue has been out at least once)\n"
                : never.stream().collect(Collectors.joining("\n   ", "   ", "\n")));
    }

    // --- 7. Histogram by day of the week ---
    private void histogramSection(StringBuilder sb) {
        String[] days = { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };

        Map<Integer, Long> byDay = loans.stream()
                .collect(Collectors.groupingBy(l -> l.getLoanDay() % 7,
                                               Collectors.counting()));

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

        sb.append("\n7. LOANS PER DAY OF THE WEEK\n");
        IntStream.range(0, 7).forEach(i -> {
            long n = byDay.getOrDefault(i, 0L);
            int bar = (int) (n * 30 / max);
            sb.append(String.format("   %-10s %3d %s%n", days[i], n, "█".repeat(bar)));
        });
    }
}

==========================================================
        BIBLIOTECH DASHBOARD -- Nexus Software
==========================================================

1. INVENTORY (8 materials)
   BOOK         5  #####
   MAGAZINE     2  ##
   DVD          1  #

2. BEST RATED
   4.85  Effective Java
   4.72  Refactoring
   4.60  Design Patterns

3. ACTIVE LOANS
   Diego Alonso   (3)
      - Java Magazine 04
      - Java Magazine 05
      - Refactoring
   Marta Ruiz     (4)
      - Clean Code
      - Design Patterns
      - Effective Java
      - Spring Course
   Nuria Vidal    (2)
      - Domain-Driven Design
      - Effective Java

4. RANKINGS
   Most loans:      Marta Ruiz
   Most days late:  Diego Alonso (23 days)

5. PAGES OF THE BOOKS
   books=5  average=423.8  min=380  max=464  total=2119

6. NEVER LENT (1)
   UML Distilled

7. LOANS PER DAY OF THE WEEK
   Monday       3 ██████████████████████████████
   Tuesday      1 ██████████
   Wednesday    2 ████████████████████
   Thursday     0
   Friday       2 ████████████████████
   Saturday     1 ██████████
   Sunday       0

package com.nexussoftware.bibliotech.service;

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;

/**
 * Analyses the BiblioTech log with lazy streams.
 * It NEVER loads the file into memory: a 2 GB log is processed the same way.
 */
public class LogAnalyser {

    /** A valid log line. Optional for parsing (04-07 + 10-04). */
    public record LogLine(String date, String level, String operation,
                          String employee, long milliseconds) {

        static Optional<LogLine> parse(String line) {
            String[] c = line.split("\\|", -1);
            if (c.length != 5) {
                return Optional.empty();
            }
            try {
                return Optional.of(new LogLine(
                        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 Report(Map<String, Long> byLevel,
                         List<LogLine> slowest,
                         Map<String, Double> averageByOperation,
                         List<String> employeesWithErrors,
                         double slowPercentage,
                         long totalValid,
                         long totalCorrupt) { }

    private final Path file;

    public LogAnalyser(Path file) {
        this.file = file;
    }

    /**
     * A SINGLE traversal of the file: the valid lines are materialised
     * in memory once and every aggregate is derived from there.
     * For files that do not fit in memory, each aggregate would need
     * its own lazy traversal.
     */
    public Report analyse() throws IOException {

        List<LogLine> valid;
        long total;

        try (Stream<String> lines = Files.lines(file, StandardCharsets.UTF_8)) {
            valid = lines
                    .filter(l -> !l.isBlank())
                    .map(LogLine::parse)
                    .flatMap(Optional::stream)      // drops the empties without get()
                    .toList();
        }
        total = countNonBlankLines();

        Map<String, Long> byLevel = valid.stream()
                .collect(Collectors.groupingBy(LogLine::level,
                         TreeMap::new, Collectors.counting()));

        List<LogLine> slowest = valid.stream()
                .sorted(Comparator.comparingLong(LogLine::milliseconds).reversed())
                .limit(5)
                .toList();

        Map<String, Double> averageByOperation = valid.stream()
                .collect(Collectors.groupingBy(LogLine::operation,
                         TreeMap::new,
                         Collectors.averagingLong(LogLine::milliseconds)));

        List<String> employeesWithErrors = valid.stream()
                .filter(l -> "SEVERE".equals(l.level()))
                .map(LogLine::employee)
                .distinct()
                .sorted()
                .toList();

        long slow = valid.stream().filter(l -> l.milliseconds() > 200).count();
        double percentage = valid.isEmpty() ? 0.0 : slow * 100.0 / valid.size();

        return new Report(byLevel, slowest, averageByOperation, employeesWithErrors,
                          percentage, valid.size(), total - valid.size());
    }

    /** The first corrupt line, with LAZY processing: it stops when it finds it. */
    public Optional<String> firstCorrupt() throws IOException {
        try (Stream<String> lines = Files.lines(file, StandardCharsets.UTF_8)) {
            return lines
                    .filter(l -> !l.isBlank())
                    .filter(l -> LogLine.parse(l).isEmpty())
                    .findFirst();       // SHORT-CIRCUITS: it does not read the rest of the file
        }
    }

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

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

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

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

        LogAnalyser analyser = new LogAnalyser(log);
        Report report = analyser.analyse();

        System.out.println("=== LOG ANALYSIS ===");
        System.out.printf("Valid lines: %d, corrupt: %d%n%n",
                report.totalValid(), report.totalCorrupt());

        System.out.println("Operations per level:");
        report.byLevel().forEach((n, c) -> System.out.printf("  %-8s %6d%n", n, c));

        System.out.println("\nThe 5 slowest:");
        report.slowest().forEach(l -> System.out.printf("  %6d ms  %-10s %s%n",
                l.milliseconds(), l.operation(), l.employee()));

        System.out.println("\nAverage duration per operation:");
        report.averageByOperation().forEach((op, ms) ->
                System.out.printf("  %-12s %7.1f ms%n", op, ms));

        System.out.println("\nEmployees with severe errors: " + report.employeesWithErrors());
        System.out.printf("Operations above 200 ms: %.2f %%%n",
                report.slowPercentage());

        analyser.firstCorrupt().ifPresentOrElse(
                l  -> System.out.println("\nFirst corrupt line: \"" + l + "\""),
                () -> System.out.println("\nThere are no corrupt lines"));
    }

    /** Generates the test file, also with streams. */
    private static void generateTestLog(Path target, int lines) throws IOException {
        String[] levels     = { "INFO", "INFO", "INFO", "WARNING", "SEVERE" };
        String[] operations = { "lend", "return", "search", "export", "renew" };
        String[] employees  = { "Marta Ruiz", "Diego Alonso", "Nuria Vidal" };
        Random random = new Random(42);        // fixed seed: reproducible output

        List<String> content = java.util.stream.IntStream.rangeClosed(1, lines)
                .mapToObj(i -> {
                    if (i % 9_999 == 0) {
                        return "2026-08-05|CORRUPT LINE WITH NO FIELDS";
                    }
                    return String.format("2026-08-%02d|%s|%s|%s|%d",
                            1 + random.nextInt(28),
                            levels[random.nextInt(levels.length)],
                            operations[random.nextInt(operations.length)],
                            employees[random.nextInt(employees.length)],
                            1 + random.nextInt(500));
                })
                .toList();

        Files.write(target, content, StandardCharsets.UTF_8);
    }
}

=== LOG ANALYSIS ===
Valid lines: 49995, corrupt: 5

Operations per level:
  INFO      30012
  SEVERE     9981
  WARNING   10002

The 5 slowest:
     500 ms  search     Nuria Vidal
     500 ms  lend       Marta Ruiz
     500 ms  renew      Diego Alonso
     500 ms  return     Marta Ruiz
     500 ms  export     Nuria Vidal

Average duration per operation:
  export         250.4 ms
  lend           250.7 ms
  renew          250.3 ms
  return         250.1 ms
  search         250.9 ms

Employees with severe errors: [Diego Alonso, Marta Ruiz, Nuria Vidal]
Operations above 200 ms: 59.94 %

First corrupt line: "2026-08-05|CORRUPT LINE WITH NO FIELDS"

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.Card;

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

/**
 * Card cache with an API based on Optional and streams.
 */
public class CardCache {

    private final Map<String, Card> cache = new ConcurrentHashMap<>();
    private long hits = 0;
    private long misses = 0;

    /** Optional instead of null: the signature says it may not be there. */
    public Optional<Card> find(String isbn) {
        Optional<Card> result = Optional.ofNullable(cache.get(isbn));
        if (result.isPresent()) { hits++; } else { misses++; }
        return result;
    }

    /** Returns the cached one or computes and stores it. */
    public Card getOrCompute(String isbn, Function<String, Card> computation) {
        return cache.computeIfAbsent(isbn, key -> {
            misses++;
            return computation.apply(key);
        });
    }

    public void save(Card card) {
        cache.put(card.isbn(), card);
    }

    /** Only the ones found, with no isPresent() and no get(). */
    public List<Card> findAll(Collection<String> isbns) {
        return isbns.stream()
                .map(cache::get)
                .filter(Objects::nonNull)
                .toList();
    }

    /** Equivalent version going through Optional, to see the idiom. */
    public List<Card> findAllWithOptional(Collection<String> isbns) {
        return isbns.stream()
                .map(isbn -> Optional.ofNullable(cache.get(isbn)))
                .flatMap(Optional::stream)
                .toList();
    }

    /** true = in the cache, false = they have to be computed. ALWAYS both keys. */
    public Map<Boolean, List<String>> classify(Collection<String> isbns) {
        return isbns.stream()
                .collect(Collectors.partitioningBy(cache::containsKey));
    }

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

    public double hitRate() {
        long total = hits + misses;
        return total == 0 ? 0.0 : (double) hits / total;
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domain.Card;

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

public class ParallelBenchmark {

    /** Expensive computation that simulates generating a card. */
    private static Card computeCard(String isbn) {
        double accumulated = 0;
        for (int i = 1; i <= 2_000; i++) {
            accumulated += Math.sqrt(i) * Math.log(i + isbn.hashCode() % 7 + 8);
        }
        return new Card(isbn, "Card " + isbn + " (" + (long) accumulated + ")", true);
    }

    public static void main(String[] args) {

        System.out.println("Available cores: " + Runtime.getRuntime().availableProcessors());
        System.out.println("commonPool parallelism: "
                + ForkJoinPool.getCommonPoolParallelism());
        System.out.println();

        System.out.printf("%-12s %14s %14s %10s%n",
                "SIZE", "SEQUENTIAL", "PARALLEL", "SPEEDUP");
        System.out.println("-".repeat(54));

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

            // WARM-UP: without it you measure the interpreter, not compiled code (10-07)
            warmUp(isbns.subList(0, Math.min(500, size)));

            long sequential = measureMedian(() ->
                    isbns.stream().map(ParallelBenchmark::computeCard).count());

            long parallel = measureMedian(() ->
                    isbns.parallelStream().map(ParallelBenchmark::computeCard).count());

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

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

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

    private static void warmUp(List<String> sample) {
        for (int i = 0; i < 3; i++) {
            sample.stream().map(ParallelBenchmark::computeCard).count();
            sample.parallelStream().map(ParallelBenchmark::computeCard).count();
        }
    }

    /** Median of 5 repetitions: less sensitive to a one-off spike than the mean. */
    private static long measureMedian(Runnable task) {
        long[] times = new long[5];
        for (int i = 0; i < times.length; i++) {
            long start = System.nanoTime();
            task.run();
            times[i] = (System.nanoTime() - start) / 1_000_000;
        }
        Arrays.sort(times);
        return times[times.length / 2];
    }

    /** Why you NEVER accumulate into an unsafe collection from a parallel stream. */
    private static void demonstrateParallelCorruption() {

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

        System.out.println("--- Accumulating into an ArrayList from parallelStream ---");
        for (int attempt = 1; attempt <= 3; attempt++) {
            List<String> target = new ArrayList<>();       // NOT thread-safe
            try {
                isbns.parallelStream().forEach(target::add);
                System.out.printf("  attempt %d: expected 100000, got %d%s%n",
                        attempt, target.size(),
                        target.size() == 100_000 ? "" : "   <-- ELEMENTS LOST");
            } catch (Exception e) {
                System.out.printf("  attempt %d: %s%n", attempt, e.getClass().getSimpleName());
            }
        }

        System.out.println("--- The correct way: collect ---");
        List<String> correct = isbns.parallelStream().collect(Collectors.toList());
        System.out.println("  collect: " + correct.size() + " elements, always");
    }
}

Available cores: 8
commonPool parallelism: 7

SIZE             SEQUENTIAL       PARALLEL    SPEEDUP
------------------------------------------------------
100                       3 ms           2 ms      1.50x
10000                   287 ms          49 ms      5.86x
1000000               28640 ms        4712 ms      6.08x

--- Accumulating into an ArrayList from parallelStream ---
  attempt 1: expected 100000, got 87423   <-- ELEMENTS LOST
  attempt 2: ArrayIndexOutOfBoundsException
  attempt 3: expected 100000, got 92108   <-- ELEMENTS LOST
--- The correct way: collect ---
  collect: 100000 elements, always