import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class MesurarBuffer {

    /** Sense memoria intermedia: una crida al sistema per caracter. */
    static long senseBuffer(String cami) throws IOException {
        long n = 0;
        try (FileReader lector = new FileReader(cami, StandardCharsets.UTF_8)) {
            while (lector.read() != -1) {
                n++;
            }
        }
        return n;
    }

    /** Amb memoria intermedia, mateix bucle: absorbeix les crides. */
    static long ambBuffer(String cami) throws IOException {
        long n = 0;
        try (BufferedReader lector = new BufferedReader(
                new FileReader(cami, StandardCharsets.UTF_8))) {
            while (lector.read() != -1) {
                n++;
            }
        }
        return n;
    }

    /** Amb memoria intermedia i per linies: la forma idiomatica. */
    static long perLinies(String cami) throws IOException {
        long n = 0;
        try (BufferedReader lector = new BufferedReader(
                new FileReader(cami, StandardCharsets.UTF_8))) {
            String linia;
            while ((linia = lector.readLine()) != null) {
                n += linia.length();
            }
        }
        return n;
    }

    public static void main(String[] args) throws IOException {
        String cami = "dades/cataleg-gran.txt";        // uns 5 MB

        mesurar("Sense buffer, caracter a caracter", () -> senseBuffer(cami));
        mesurar("Amb buffer, caracter a caracter",   () -> ambBuffer(cami));
        mesurar("Amb buffer, per linies",            () -> perLinies(cami));
    }

    interface Mesurable { long executar() throws IOException; }

    static void mesurar(String nom, Mesurable m) throws IOException {
        long inici = System.nanoTime();
        long resultat = m.executar();
        long ms = (System.nanoTime() - inici) / 1_000_000;
        System.out.printf("%-35s %6d ms  (%d caracters)%n", nom, ms, resultat);
    }
}

Sense buffer, caracter a caracter     4512 ms  (5242880 caracters)
Amb buffer, caracter a caracter         68 ms  (5242880 caracters)
Amb buffer, per linies                  41 ms  (5158400 caracters)

import java.io.*;
import java.nio.charset.StandardCharsets;

// Lectura, mida per defecte (8192 caracters)
BufferedReader lector = new BufferedReader(
        new FileReader("dades/cataleg.txt", StandardCharsets.UTF_8));

// Lectura, mida explicita
BufferedReader gran = new BufferedReader(
        new FileReader("dades/cataleg.txt", StandardCharsets.UTF_8), 65536);

// Escriptura
BufferedWriter escriptor = new BufferedWriter(
        new FileWriter("dades/informe.txt", StandardCharsets.UTF_8));

// Sobre un pont, quan la font no es un fitxer (07-03)
BufferedReader deConsola = new BufferedReader(
        new InputStreamReader(System.in, StandardCharsets.UTF_8));

public String readLine() throws IOException

try (BufferedReader lector = new BufferedReader(
        new FileReader(cami, StandardCharsets.UTF_8))) {

    String linia;
    while ((linia = lector.readLine()) != null) {
        processar(linia);
    }
}

// MALAMENT 1: s'atura a la primera linia buida
while (!(linia = lector.readLine()).isEmpty()) { }
// A mes: NullPointerException en arribar al final, perque readLine retorna null

// MALAMENT 2: llegeix cada linia DUES vegades i se'n salta una de cada dues
while (lector.readLine() != null) {
    processar(lector.readLine());    // aquesta es la SEGUENT linia
}

// MALAMENT 3: ready() no significa "queden dades". Apartat 7
while (lector.ready()) {
    processar(lector.readLine());
}

int numeroLinia = 0;
String linia;
while ((linia = lector.readLine()) != null) {
    numeroLinia++;

    String neta = linia.trim();
    if (neta.isEmpty() || neta.startsWith("#")) {
        continue;                        // buides i comentaris: 02-04
    }
    processar(neta, numeroLinia);        // el numero, per poder informar de l'error
}

public boolean ready() throws IOException

// MALAMENT: us incorrecte de ready()
try (BufferedReader lector = new BufferedReader(new FileReader(cami, UTF_8))) {
    while (lector.ready()) {              // <-- BUG
        System.out.println(lector.readLine());
    }
}

public void mark(int limitDeLectura) throws IOException
public void reset() throws IOException
public boolean markSupported()

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class DeteccioDeCapcalera {

    /**
     * Detecta si el fitxer te capcalera; si no en te, la primera
     * linia es una dada i NO s'ha de perdre.
     */
    public static void processar(String cami) throws IOException {
        try (BufferedReader lector = new BufferedReader(
                new FileReader(cami, StandardCharsets.UTF_8))) {

            lector.mark(8192);                     // marge ampli
            String primera = lector.readLine();

            boolean teCapcalera = primera != null
                    && (primera.startsWith("#") || primera.toLowerCase().contains("titol"));

            if (!teCapcalera) {
                lector.reset();                    // tornar la linia al flux
                System.out.println("Sense capcalera: la primera linia es una dada");
            } else {
                System.out.println("Capcalera detectada: " + primera);
            }

            String linia;
            while ((linia = lector.readLine()) != null) {
                System.out.println("  dada: " + linia);
            }
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class EscripturaAmbBuffer {

    public static void escriure(String cami) throws IOException {
        try (BufferedWriter escriptor = new BufferedWriter(
                new FileWriter(cami, StandardCharsets.UTF_8))) {

            escriptor.write("# Cataleg de BiblioTech");
            escriptor.newLine();                       // separador DEL SISTEMA

            escriptor.write("LLIBRE;978-0000000001;Java Eficac");
            escriptor.newLine();

            escriptor.write("LLIBRE;978-0000000002;Patrons de Disseny");
            escriptor.newLine();
        }
        // close() -> flush() -> les dades arriben al disc (07-02)
    }
}

try (PrintWriter sortida = new PrintWriter(         // 3. formatatge
        new BufferedWriter(                          // 2. memoria intermedia
            new FileWriter(cami,                     // 1. fitxer + charset
                    StandardCharsets.UTF_8)))) {

    sortida.printf("%-25s %8.2f%n", "Java Eficac", 3.75);
}

// Opcio A: PrintWriter. Comode, pero els errors cal preguntar-los.
try (PrintWriter sortida = new PrintWriter(
        new BufferedWriter(new FileWriter(cami, UTF_8)))) {
    sortida.printf("%-25s %8.2f%n", titol, multa);
    if (sortida.checkError()) {
        throw new IOException("Fallada en escriure " + cami);
    }
}

// Opcio B: BufferedWriter. Mes verbos, pero els errors es propaguen sols.
try (BufferedWriter sortida = new BufferedWriter(new FileWriter(cami, UTF_8))) {
    sortida.write(String.format("%-25s %8.2f", titol, multa));
    sortida.newLine();
}

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

// Lectura: equival a new BufferedReader(new InputStreamReader(
//          new FileInputStream(...), UTF_8))
try (BufferedReader lector = Files.newBufferedReader(
        Path.of("dades/cataleg.txt"), StandardCharsets.UTF_8)) {

    String linia;
    while ((linia = lector.readLine()) != null) {
        processar(linia);
    }
}

// Escriptura, amb opcions explicites
try (BufferedWriter escriptor = Files.newBufferedWriter(
        Path.of("dades/informe.txt"), StandardCharsets.UTF_8)) {
    escriptor.write("...");
    escriptor.newLine();
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class ProcessamentEnFlux {

    /**
     * Recorre un fitxer de QUALSEVOL mida amb memoria constant.
     *
     * En cada instant hi ha en memoria: la memoria intermedia (8 KB), la linia
     * actual i els acumuladors. Tant li fa que el fitxer tingui 1 MB o 50 GB.
     */
    public static Resum analitzar(String cami) throws IOException {
        long linies = 0;
        long caracters = 0;
        long liniesBuides = 0;
        int  maxLongitud = 0;
        String liniaMesLlarga = "";

        try (BufferedReader lector = new BufferedReader(
                new FileReader(cami, StandardCharsets.UTF_8))) {

            String linia;
            while ((linia = lector.readLine()) != null) {
                linies++;
                caracters += linia.length();

                if (linia.isBlank()) {
                    liniesBuides++;
                }
                if (linia.length() > maxLongitud) {
                    maxLongitud = linia.length();
                    liniaMesLlarga = linia;     // se'n desa UNA, no totes
                }
                // 'linia' queda disponible per al recollector a la volta seguent
            }
        }
        return new Resum(linies, caracters, liniesBuides, maxLongitud, liniaMesLlarga);
    }

    public record Resum(long linies, long caracters, long liniesBuides,
                        int maxLongitud, String liniaMesLlarga) { }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class ConsolaAmbBufferedReader {

    public static void main(String[] args) throws IOException {
        // System.in es un InputStream (bytes): cal el PONT (07-03)
        BufferedReader consola = new BufferedReader(
                new InputStreamReader(System.in, StandardCharsets.UTF_8));

        System.out.print("Referencia del material: ");
        String referencia = consola.readLine();

        System.out.print("Dies de prestec: ");
        String text = consola.readLine();

        // BufferedReader NO analitza: cal convertir a ma
        int dies;
        try {
            dies = Integer.parseInt(text.trim());
        } catch (NumberFormatException e) {
            System.out.println("'" + text + "' no es un numero valid");
            return;
        }

        System.out.printf("Prestec de %s per %d dies%n", referencia, dies);

        // ATENCIO: NO es tanca el BufferedReader. Tancar-lo tancaria System.in
        // per a tota l'aplicacio, i no hi hauria forma de reobrir-lo (06-06).
    }
}

package com.nexussoftware.bibliotech.servei;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.domini.Llibre;
import com.nexussoftware.bibliotech.domini.Material;
import com.nexussoftware.bibliotech.domini.ReferenciaDuplicadaException;
import com.nexussoftware.bibliotech.infraestructura.FormatFitxers;

/**
 * Importacio massiva del cataleg de BiblioTech des d'un fitxer de text.
 *
 * Format esperat (una linia per material):
 *   LLIBRE;isbn;titol;autor;any
 *
 * Politica (06-07):
 *   - Una linia dolenta NO avorta la importacio: es descarta i es compta.
 *   - El fitxer absent o illegible SI que avorta: no hi ha res per importar.
 *   - Els materials s'acumulen i es bolquen al cataleg AL FINAL, per no
 *     deixar-lo a mitges si el fitxer resulta estar corrupte del tot.
 *
 * Processa en FLUX: memoria constant sigui quina sigui la mida del fitxer.
 */
public class ImportadorCataleg {

    private static final Logger LOG = Logger.getLogger(ImportadorCataleg.class.getName());

    private static final int CAMPS_ESPERATS = 5;
    private static final int ANY_MINIM = 1450;
    private static final int ANY_MAXIM = 2100;

    /** Si mes d'aquesta fraccio de linies falla, el fitxer es sospitos. */
    private static final double LLINDAR_FITXER_CORRUPTE = 0.5;

    /** Errors detallats que es desen; la resta nomes es compten. */
    private static final int MAX_ERRORS_DETALLATS = 100;

    private final File fitxer;

    public ImportadorCataleg(String cami) {
        this.fitxer = new File(Objects.requireNonNull(cami, "El cami no pot ser nul"));
    }

    // ------------------------- L'INFORME -------------------------

    /** Motiu pel qual es descarta una línia. Enum (04-07): sense cadenes magiques. */
    public enum MotiuDescart {
        NUMERO_DE_CAMPS("Nombre de camps incorrecte"),
        TIPUS_DESCONEGUT("Tipus de material no reconegut"),
        CAMP_BUIT("Camp obligatori buit"),
        ANY_NO_NUMERIC("L'any no es un numero"),
        ANY_FORA_DE_RANG("Any fora del rang admes"),
        ISBN_INVALID("L'ISBN no te el format esperat"),
        DUPLICAT("Referencia o ISBN ja presents");

        private final String descripcio;
        MotiuDescart(String descripcio) { this.descripcio = descripcio; }
        public String getDescripcio() { return descripcio; }
    }

    /** Una linia descartada, amb tot el necessari per corregir-la. */
    public record LiniaDescartada(int numero, MotiuDescart motiu, String detall,
                                  String contingut) {
        @Override
        public String toString() {
            return String.format("Linia %d [%s]: %s | %s",
                    numero, motiu.name(), detall, retallar(contingut));
        }
        private static String retallar(String s) {
            return (s.length() <= 60) ? s : s.substring(0, 57) + "...";
        }
    }

    /** Resultat complet de la importacio. */
    public static class Informe {
        private final List<Material> importats = new ArrayList<>();
        private final List<LiniaDescartada> descartades = new ArrayList<>();
        private final Map<MotiuDescart, Integer> perMotiu = new LinkedHashMap<>();

        private int liniesLlegides = 0;
        private int liniesIgnorades = 0;       // buides i comentaris
        private int descartsTotals = 0;        // inclou els no detallats
        private long millisegons = 0;
        private boolean avortada = false;
        private String motiuAvortament = null;

        void comptarLinia()     { liniesLlegides++; }
        void comptarIgnorada()  { liniesIgnorades++; }
        void afegir(Material m) { importats.add(m); }

        void descartar(LiniaDescartada d) {
            descartsTotals++;
            perMotiu.merge(d.motiu(), 1, Integer::sum);         // 05-05
            if (descartades.size() < MAX_ERRORS_DETALLATS) {
                descartades.add(d);
            }
        }

        void avortar(String motiu) {
            avortada = true;
            motiuAvortament = motiu;
        }

        public List<Material> getImportats()             { return List.copyOf(importats); }
        public List<LiniaDescartada> getDescartades()    { return List.copyOf(descartades); }
        public Map<MotiuDescart, Integer> getPerMotiu()  { return Map.copyOf(perMotiu); }
        public int getLiniesLlegides()   { return liniesLlegides; }
        public int getLiniesIgnorades()  { return liniesIgnorades; }
        public int getImportatsTotal()   { return importats.size(); }
        public int getDescartsTotals()   { return descartsTotals; }
        public long getMillisegons()     { return millisegons; }
        public boolean estaAvortada()    { return avortada; }
        public String getMotiuAvortament() { return motiuAvortament; }

        public double taxaExit() {
            int processades = importats.size() + descartsTotals;
            return (processades == 0) ? 0.0 : (importats.size() * 100.0) / processades;
        }

        /** Informe llegible per a la capa de presentacio. */
        public String resum() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== INFORME D'IMPORTACIO ===\n");

            if (avortada) {
                sb.append("  IMPORTACIO AVORTADA: ").append(motiuAvortament).append('\n');
                return sb.toString();
            }

            sb.append(String.format("  Linies llegides  : %d%n", liniesLlegides));
            sb.append(String.format("  Ignorades        : %d (buides i comentaris)%n",
                    liniesIgnorades));
            sb.append(String.format("  Importades       : %d%n", importats.size()));
            sb.append(String.format("  Descartades      : %d%n", descartsTotals));
            sb.append(String.format("  Taxa d'exit      : %.1f%%%n", taxaExit()));
            sb.append(String.format("  Temps            : %d ms%n", millisegons));

            if (!perMotiu.isEmpty()) {
                sb.append("  --- Descarts per motiu ---\n");
                for (Map.Entry<MotiuDescart, Integer> e : perMotiu.entrySet()) {
                    sb.append(String.format("    %-22s %4d  (%s)%n",
                            e.getKey().name(), e.getValue(),
                            e.getKey().getDescripcio()));
                }
            }
            if (!descartades.isEmpty()) {
                sb.append("  --- Primeres linies descartades ---\n");
                int mostrades = Math.min(10, descartades.size());
                for (int i = 0; i < mostrades; i++) {
                    sb.append("    ").append(descartades.get(i)).append('\n');
                }
                if (descartsTotals > mostrades) {
                    sb.append(String.format("    ... i %d mes%n",
                            descartsTotals - mostrades));
                }
            }
            return sb.toString();
        }
    }

    // ------------------------- LA IMPORTACIO -------------------------

    /**
     * Importa el fitxer al cataleg donat.
     *
     * @return l'informe. Mai null, ni tan sols si avorta.
     */
    public Informe importar(Cataleg cataleg) {
        Objects.requireNonNull(cataleg, "El cataleg no pot ser nul");

        Informe informe = new Informe();
        long inici = System.nanoTime();

        LOG.info(() -> "Iniciant importacio des de " + fitxer.getAbsolutePath());

        // BufferedReader: memoria constant encara que el fitxer tingui milions
        // de linies. Charset explicit, el mateix que fa servir l'exportador.
        try (BufferedReader lector = new BufferedReader(
                new FileReader(fitxer, FormatFitxers.CHARSET))) {

            String linia;
            int numero = 0;

            while ((linia = lector.readLine()) != null) {   // el bucle canonic
                numero++;
                informe.comptarLinia();
                processarLinia(linia, numero, informe);
            }

        } catch (java.io.FileNotFoundException e) {
            informe.avortar("No existeix el fitxer " + fitxer.getAbsolutePath());
            LOG.log(Level.WARNING, "Importacio avortada: fitxer no trobat", e);
            return finalitzar(informe, inici);

        } catch (IOException e) {
            informe.avortar("Fallada d'E/S llegint " + fitxer.getAbsolutePath()
                    + ": " + e.getMessage());
            LOG.log(Level.SEVERE, "Importacio avortada per fallada d'E/S", e);
            return finalitzar(informe, inici);
        }

        // Comprovacio de seny: si falla mes de la meitat, alguna cosa va malament
        // amb el fitxer sencer (charset equivocat, format diferent, columnes
        // canviades). Millor rebutjar-lo que ficar brossa al cataleg.
        int processades = informe.getImportatsTotal() + informe.getDescartsTotals();
        if (processades > 10
                && informe.getDescartsTotals() > processades * LLINDAR_FITXER_CORRUPTE) {

            informe.avortar(String.format(
                    "Ha fallat el %.0f%% de les linies (%d de %d). El fitxer no sembla "
                            + "tenir el format esperat; no s'importa res.",
                    100 - informe.taxaExit(), informe.getDescartsTotals(), processades));

            LOG.severe(() -> "Importacio rebutjada: " + informe.getMotiuAvortament());
            return finalitzar(informe, inici);
        }

        // Bolcat al cataleg AL FINAL: fins aqui no s'ha tocat res
        bolcar(cataleg, informe);
        return finalitzar(informe, inici);
    }

    /** Valida i construeix el material d'una linia. No llanca mai cap amunt. */
    private void processarLinia(String linia, int numero, Informe informe) {
        String neta = linia.trim();

        if (neta.isEmpty() || neta.startsWith(FormatFitxers.COMENTARI)) {
            informe.comptarIgnorada();
            return;
        }

        // El -1 conserva els camps buits del final (07-01, solucio 3)
        String[] camps = neta.split(FormatFitxers.SEPARADOR_CAMPS, -1);

        if (camps.length != CAMPS_ESPERATS) {
            informe.descartar(new LiniaDescartada(numero, MotiuDescart.NUMERO_DE_CAMPS,
                    "n'hi ha " + camps.length + " i se n'esperaven " + CAMPS_ESPERATS,
                    neta));
            return;
        }

        String tipus = camps[0].trim().toUpperCase();
        String isbn  = camps[1].trim();
        String titol = camps[2].trim();
        String autor = camps[3].trim();
        String anyTx = camps[4].trim();

        if (!"LLIBRE".equals(tipus)) {
            informe.descartar(new LiniaDescartada(numero, MotiuDescart.TIPUS_DESCONEGUT,
                    "'" + tipus + "'", neta));
            return;
        }
        if (titol.isEmpty() || isbn.isEmpty()) {
            informe.descartar(new LiniaDescartada(numero, MotiuDescart.CAMP_BUIT,
                    titol.isEmpty() ? "titol" : "isbn", neta));
            return;
        }
        if (!isbn.matches("\\d{3}-\\d{10}")) {
            informe.descartar(new LiniaDescartada(numero, MotiuDescart.ISBN_INVALID,
                    "'" + isbn + "' no compleix NNN-NNNNNNNNNN", neta));
            return;
        }

        int any;
        try {
            any = Integer.parseInt(anyTx);
        } catch (NumberFormatException e) {
            informe.descartar(new LiniaDescartada(numero, MotiuDescart.ANY_NO_NUMERIC,
                    "'" + anyTx + "'", neta));
            return;
        }
        if (any < ANY_MINIM || any > ANY_MAXIM) {
            informe.descartar(new LiniaDescartada(numero, MotiuDescart.ANY_FORA_DE_RANG,
                    any + " fora de [" + ANY_MINIM + ", " + ANY_MAXIM + "]", neta));
            return;
        }

        informe.afegir(new Llibre(titol, autor.isEmpty() ? "Desconegut" : autor, isbn, any));
    }

    /**
     * Bolca al cataleg el que s'ha importat.
     *
     * Els duplicats es detecten AQUI, perque nomes el cataleg els coneix.
     * Un duplicat no invalida la importacio sencera: es descarta i es continua.
     */
    private void bolcar(Cataleg cataleg, Informe informe) {
        List<Material> pendents = informe.getImportats();
        List<Material> acceptats = new ArrayList<>(pendents.size());

        for (Material m : pendents) {
            try {
                cataleg.registrar(m);
                acceptats.add(m);
            } catch (ReferenciaDuplicadaException e) {
                informe.descartar(new LiniaDescartada(0, MotiuDescart.DUPLICAT,
                        e.getMessage(), m.getReferencia()));
            }
        }
        informe.importats.clear();
        informe.importats.addAll(acceptats);       // nomes el realment registrat
    }

    private Informe finalitzar(Informe informe, long inici) {
        informe.millisegons = (System.nanoTime() - inici) / 1_000_000;

        if (informe.estaAvortada()) {
            LOG.warning(() -> "Importacio avortada: " + informe.getMotiuAvortament());
        } else {
            LOG.info(() -> String.format(
                    "Importacio acabada: %d importats, %d descartats, %d ms",
                    informe.getImportatsTotal(), informe.getDescartsTotals(),
                    informe.getMillisegons()));
        }
        return informe;
    }
}

package com.nexussoftware.bibliotech.presentacio;

import com.nexussoftware.bibliotech.servei.Cataleg;
import com.nexussoftware.bibliotech.servei.ImportadorCataleg;

public class DemoImportacio {

    public static void main(String[] args) {
        Cataleg cataleg = new Cataleg();

        ImportadorCataleg importador =
                new ImportadorCataleg("dades/cataleg-complet.txt");

        ImportadorCataleg.Informe informe = importador.importar(cataleg);

        System.out.println(informe.resum());
        System.out.println("Materials al cataleg: " + cataleg.mida());
    }
}

=== INFORME D'IMPORTACIO ===
  Linies llegides  : 5003
  Ignorades        : 3 (buides i comentaris)
  Importades       : 4962
  Descartades      : 38
  Taxa d'exit      : 99.2%
  Temps            : 87 ms
  --- Descarts per motiu ---
    ANY_NO_NUMERIC           14  (L'any no es un numero)
    ISBN_INVALID             11  (L'ISBN no te el format esperat)
    NUMERO_DE_CAMPS           7  (Nombre de camps incorrecte)
    DUPLICAT                  4  (Referencia o ISBN ja presents)
    CAMP_BUIT                 2  (Camp obligatori buit)
  --- Primeres linies descartades ---
    Linia 47 [ANY_NO_NUMERIC]: 'mil nou-cents' | LLIBRE;978-0000000047;Un llibre;Autor;mil...
    Linia 112 [NUMERO_DE_CAMPS]: n'hi ha 4 i se n'esperaven 5 | LLIBRE;978-0000000112;Altre;A
    Linia 340 [ISBN_INVALID]: '97800000340' no compleix NNN-NNNNNNNNNN | LLIBRE;97800000340;
    ... i 35 mes

package com.nexussoftware.bibliotech.util;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Estadistiques d'un fitxer de text en UN SOL RECORREGUT i amb memoria
 * constant respecte a la mida del fitxer.
 *
 * L'unic que creix es el mapa de frequencies, que depen del nombre de
 * paraules DIFERENTS, no de la mida del fitxer. Un fitxer de 10 GB en
 * catala te de l'ordre de cent mil paraules diferents: perfectament
 * manejable.
 */
public class EstadistiquesFitxer {

    private static final int PARAULES_TOP = 3;
    private static final int LONGITUD_MOSTRA = 60;

    public record Estadistiques(
            long linies, long paraules, long caracters,
            long liniesBuides, long liniesComentari,
            double longitudMitjana, int longitudMinima, int longitudMaxima,
            int numeroLiniaMesLlarga, String mostraLiniaMesLlarga,
            List<Map.Entry<String, Integer>> paraulesFrequents) {

        public String informe() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== ESTADISTIQUES DEL FITXER ===\n");
            sb.append(String.format("  Linies            : %d%n", linies));
            sb.append(String.format("    buides          : %d%n", liniesBuides));
            sb.append(String.format("    comentaris      : %d%n", liniesComentari));
            sb.append(String.format("  Paraules          : %d%n", paraules));
            sb.append(String.format("  Caracters         : %d%n", caracters));
            sb.append(String.format("  Longitud mitjana  : %.1f%n", longitudMitjana));
            sb.append(String.format("  Longitud minima   : %d%n", longitudMinima));
            sb.append(String.format("  Longitud maxima   : %d (linia %d)%n",
                    longitudMaxima, numeroLiniaMesLlarga));
            sb.append(String.format("    mostra          : %s%n", mostraLiniaMesLlarga));
            sb.append("  Paraules mes frequents:\n");
            for (Map.Entry<String, Integer> e : paraulesFrequents) {
                sb.append(String.format("    %-20s %6d%n", e.getKey(), e.getValue()));
            }
            return sb.toString();
        }
    }

    public static Estadistiques analitzar(String cami) throws IOException {
        long linies = 0, paraules = 0, caracters = 0;
        long buides = 0, comentaris = 0;
        int  minima = Integer.MAX_VALUE, maxima = 0;
        int  numeroMesLlarga = 0;
        String mostraMesLlarga = "";

        // Nomes aixo creix, i amb el nombre de paraules DIFERENTS
        Map<String, Integer> frequencies = new HashMap<>();

        try (BufferedReader lector = new BufferedReader(
                new FileReader(cami, StandardCharsets.UTF_8))) {

            String linia;
            while ((linia = lector.readLine()) != null) {     // bucle canonic
                linies++;
                caracters += linia.length();

                int longitud = linia.length();
                if (longitud < minima) { minima = longitud; }
                if (longitud > maxima) {
                    maxima = longitud;
                    numeroMesLlarga = (int) linies;
                    mostraMesLlarga = longitud <= LONGITUD_MOSTRA
                            ? linia
                            : linia.substring(0, LONGITUD_MOSTRA) + "...";
                }

                String neta = linia.trim();
                if (neta.isEmpty()) {
                    buides++;
                    continue;
                }
                if (neta.startsWith("#")) {
                    comentaris++;
                    continue;
                }

                // Separa per qualsevol cosa que no sigui lletra o digit
                for (String paraula : neta.toLowerCase().split("[^\\p{L}\\p{N}]+")) {
                    if (paraula.length() > 2) {           // ignora articles curts
                        paraules++;
                        frequencies.merge(paraula, 1, Integer::sum);   // 05-05
                    }
                }
                // 'linia' es descarta aqui: memoria constant
            }
        }

        if (minima == Integer.MAX_VALUE) {
            minima = 0;                                   // fitxer buit
        }

        return new Estadistiques(
                linies, paraules, caracters, buides, comentaris,
                linies == 0 ? 0.0 : (double) caracters / linies,
                minima, maxima, numeroMesLlarga, mostraMesLlarga,
                mesFrequents(frequencies, PARAULES_TOP));
    }

    /**
     * Les n entrades amb valor mes gran.
     *
     * Sense l'API de Streams (10-04): llista + Comparator + sort, que es
     * exactament el de 05-09.
     */
    private static List<Map.Entry<String, Integer>> mesFrequents(
            Map<String, Integer> frequencies, int n) {

        List<Map.Entry<String, Integer>> entrades = new ArrayList<>(frequencies.entrySet());

        // Descendent per valor; a igualtat, alfabetic per clau
        entrades.sort(Comparator
                .comparing(Map.Entry<String, Integer>::getValue).reversed()
                .thenComparing(Map.Entry::getKey));

        return List.copyOf(entrades.subList(0, Math.min(n, entrades.size())));
    }

    public static void main(String[] args) throws IOException {
        String cami = (args.length > 0) ? args[0] : "dades/cataleg.txt";
        System.out.println(analitzar(cami).informe());
    }
}

=== ESTADISTIQUES DEL FITXER ===
  Linies            : 5003
  Linies buides     : 1
  Comentaris        : 2
  Paraules          : 19842
  Caracters         : 248915
  Longitud mitjana  : 49.8
  Longitud minima   : 0
  Longitud maxima   : 87 (linia 1204)
    mostra          : LLIBRE;978-0000001204;Introduccio als sistemes distribuits...
  Paraules mes frequents:
    llibre                 5000
    programacio             412
    sistemes                287

package com.nexussoftware.bibliotech.servei;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.logging.Logger;

/**
 * Filtra un fitxer de cataleg escrivint-ne un altre amb les linies que
 * compleixin un criteri, SENSE carregar cap dels dos en memoria.
 *
 * Llegeix i escriu en flux simultaniament: en cada instant hi ha en memoria
 * una linia i dues memories intermedies de 8 KB.
 */
public class FiltreCataleg {

    private static final Logger LOG = Logger.getLogger(FiltreCataleg.class.getName());

    private static final String COMENTARI = "#";

    /**
     * Criteri de filtratge. Interficie funcional propia (04-06): rep la
     * linia i el seu numero, per si el criteri depen de la posicio.
     */
    @FunctionalInterface
    public interface Predicat {
        boolean compleix(String linia, int numero);
    }

    public record ResultatFiltre(int llegides, int escrites, int descartades,
                                 int comentarisConservats, long millisegons) {

        public String resum() {
            return String.format(
                    "Filtrat: %d llegides, %d escrites, %d descartades, "
                            + "%d comentaris conservats (%d ms)",
                    llegides, escrites, descartades, comentarisConservats, millisegons);
        }
    }

    /**
     * Filtra origen cap a desti de forma ATOMICA (07-02).
     *
     * Si alguna cosa falla a mitges, el desti anterior queda intacte.
     */
    public ResultatFiltre filtrar(String origen, String desti, Predicat criteri)
            throws IOException {

        long inici = System.nanoTime();

        File fitxerDesti = new File(desti);
        File temporal = new File(fitxerDesti.getAbsolutePath() + ".tmp");

        int llegides = 0, escrites = 0, descartades = 0, comentaris = 0;
        boolean completat = false;

        try {
            // Lectura i escriptura simultanies, totes dues amb memoria intermedia.
            // Es declaren els dos recursos al mateix try-with-resources:
            // es tanquen en ordre invers, l'escriptor primer (06-06).
            try (BufferedReader lector = new BufferedReader(
                         new FileReader(origen, StandardCharsets.UTF_8));
                 BufferedWriter escriptor = new BufferedWriter(
                         new FileWriter(temporal, StandardCharsets.UTF_8))) {

                String linia;
                int numero = 0;

                while ((linia = lector.readLine()) != null) {
                    numero++;
                    llegides++;

                    String neta = linia.trim();

                    // Comentaris i capcaleres: es conserven sempre
                    if (neta.isEmpty() || neta.startsWith(COMENTARI)) {
                        escriptor.write(linia);
                        escriptor.newLine();
                        comentaris++;
                        continue;
                    }

                    if (criteri.compleix(linia, numero)) {
                        escriptor.write(linia);
                        escriptor.newLine();         // readLine NO retorna el salt
                        escrites++;
                    } else {
                        descartades++;
                    }
                }
                // BufferedWriter llanca IOException de veritat: sense checkError
            }

            // Substitucio atomica
            if (fitxerDesti.exists() && !fitxerDesti.delete()) {
                throw new IOException("No s'ha pogut substituir " + desti);
            }
            if (!temporal.renameTo(fitxerDesti)) {
                throw new IOException("No s'ha pogut reanomenar " + temporal.getName());
            }
            completat = true;

        } finally {
            if (!completat && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sense esborrar: " + temporal.getAbsolutePath());
            }
        }

        ResultatFiltre resultat = new ResultatFiltre(llegides, escrites, descartades,
                comentaris, (System.nanoTime() - inici) / 1_000_000);

        LOG.info(resultat::resum);
        return resultat;
    }

    // ------------------------- CRITERIS -------------------------

    /** Any de publicacio posterior al donat. Camp 5 del format. */
    public static Predicat publicatDespresDe(int any) {
        return (linia, numero) -> {
            String[] camps = linia.split(";", -1);
            if (camps.length < 5) {
                return false;
            }
            try {
                return Integer.parseInt(camps[4].trim()) > any;
            } catch (NumberFormatException e) {
                return false;               // any illegible: no compleix
            }
        };
    }

    /** L'autor conte el text donat, sense distingir majuscules. */
    public static Predicat autorConte(String text) {
        String buscat = text.toLowerCase();
        return (linia, numero) -> {
            String[] camps = linia.split(";", -1);
            return camps.length >= 4 && camps[3].toLowerCase().contains(buscat);
        };
    }

    /** Combinacio de dos criteris (composicio de lambdes, 04-05). */
    public static Predicat i(Predicat a, Predicat b) {
        return (linia, numero) -> a.compleix(linia, numero) && b.compleix(linia, numero);
    }

    public static void main(String[] args) throws IOException {
        FiltreCataleg filtre = new FiltreCataleg();

        System.out.println(filtre.filtrar(
                "dades/cataleg.txt",
                "dades/cataleg-recents.txt",
                publicatDespresDe(2000)).resum());

        System.out.println(filtre.filtrar(
                "dades/cataleg.txt",
                "dades/cataleg-bloch.txt",
                autorConte("bloch")).resum());

        System.out.println(filtre.filtrar(
                "dades/cataleg.txt",
                "dades/cataleg-recents-fowler.txt",
                i(publicatDespresDe(1995), autorConte("fowler"))).resum());
    }
}

Filtrat: 5003 llegides, 3418 escrites, 1582 descartades, 3 comentaris conservats (61 ms)
Filtrat: 5003 llegides, 12 escrites, 4988 descartades, 3 comentaris conservats (48 ms)
Filtrat: 5003 llegides, 7 escrites, 4993 descartades, 3 comentaris conservats (52 ms)

package com.nexussoftware.bibliotech.servei;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Compara dos fitxers de cataleg i informa d'altes, baixes i canvis.
 *
 * PER QUE AQUEST ALGORISME SI QUE NECESSITA MEMORIA:
 * Per saber si un material del fitxer B existeix a A, cal poder
 * consultar-lo. Com que els fluxos son SEQUENCIALS i no permeten tornar
 * enrere (07-03), l'unica forma de consultar A mentre es recorre B es tenir
 * A indexat en memoria.
 *
 * QUIN CONVE CARREGAR: el mes petit. Es recorre en flux el gran.
 *
 * SI CAP NO HI CAP: hi ha dues sortides classiques. Ordenar tots dos fitxers
 * per clau i fer-ne una "fusio" recorrent-los en parallel, que necessita
 * memoria constant; o carregar nomes les CLAUS (els ISBN) amb un hash de
 * cada linia, que ocupa una fraccio minima. La segona es l'habitual.
 */
public class ComparadorCatalegs {

    private static final String SEPARADOR = ";";
    private static final String COMENTARI = "#";

    /** Dades d'un material tal com apareixen al fitxer. */
    private record Registre(String isbn, String titol, String autor, int any) {

        /** Quins camps difereixen respecte a un altre registre amb el mateix ISBN. */
        List<String> diferenciesAmb(Registre altre) {
            List<String> canvis = new ArrayList<>();
            if (!titol.equals(altre.titol)) {
                canvis.add("titol: '" + titol + "' -> '" + altre.titol + "'");
            }
            if (!autor.equals(altre.autor)) {
                canvis.add("autor: '" + autor + "' -> '" + altre.autor + "'");
            }
            if (any != altre.any) {
                canvis.add("any: " + any + " -> " + altre.any);
            }
            return canvis;
        }
    }

    public record Diferencies(List<String> baixes, List<String> altes,
                              List<String> modificacions, int identics) {

        public String informe() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== COMPARACIO DE CATALEGS ===\n");
            sb.append(String.format("  Identics       : %d%n", identics));
            sb.append(String.format("  Altes          : %d%n", altes.size()));
            sb.append(String.format("  Baixes         : %d%n", baixes.size()));
            sb.append(String.format("  Modificacions  : %d%n", modificacions.size()));

            imprimirBloc(sb, "ALTES (nomes al nou)", altes);
            imprimirBloc(sb, "BAIXES (nomes a l'antic)", baixes);
            imprimirBloc(sb, "MODIFICACIONS", modificacions);
            return sb.toString();
        }

        private void imprimirBloc(StringBuilder sb, String titol, List<String> linies) {
            if (linies.isEmpty()) {
                return;
            }
            sb.append("  --- ").append(titol).append(" ---\n");
            int mostrades = Math.min(10, linies.size());
            for (int i = 0; i < mostrades; i++) {
                sb.append("    ").append(linies.get(i)).append('\n');
            }
            if (linies.size() > mostrades) {
                sb.append(String.format("    ... i %d mes%n", linies.size() - mostrades));
            }
        }
    }

    /**
     * Compara dos catalegs.
     *
     * @param camiAntic el que es carrega EN MEMORIA (conve el mes petit)
     * @param camiNou   el que es recorre EN FLUX
     */
    public Diferencies comparar(String camiAntic, String camiNou) throws IOException {

        // FASE 1: indexar l'antic. Un sol recorregut.
        Map<String, Registre> antics = indexar(camiAntic);

        List<String> altes = new ArrayList<>();
        List<String> modificacions = new ArrayList<>();
        int identics = 0;

        // FASE 2: recorrer el nou EN FLUX, consultant l'index
        try (BufferedReader lector = new BufferedReader(
                new FileReader(camiNou, StandardCharsets.UTF_8))) {

            String linia;
            while ((linia = lector.readLine()) != null) {
                Registre nou = parsejar(linia);
                if (nou == null) {
                    continue;                        // comentari o linia dolenta
                }

                // remove() en lloc de get(): el que quedi al final son les BAIXES.
                // Estalvia un segon recorregut i una estructura addicional.
                Registre antic = antics.remove(nou.isbn());

                if (antic == null) {
                    altes.add(nou.isbn() + " - " + nou.titol());
                    continue;
                }

                List<String> canvis = antic.diferenciesAmb(nou);
                if (canvis.isEmpty()) {
                    identics++;
                } else {
                    modificacions.add(nou.isbn() + " - " + String.join("; ", canvis));
                }
            }
        }

        // FASE 3: el que sobra de l'index son les baixes
        List<String> baixes = new ArrayList<>();
        for (Registre r : antics.values()) {
            baixes.add(r.isbn() + " - " + r.titol());
        }

        baixes.sort(null);                           // ordre natural (05-09)
        altes.sort(null);
        modificacions.sort(null);

        return new Diferencies(baixes, altes, modificacions, identics);
    }

    /** Carrega un cataleg indexat per ISBN. Un sol recorregut, amb memoria intermedia. */
    private Map<String, Registre> indexar(String cami) throws IOException {
        Map<String, Registre> index = new HashMap<>();

        try (BufferedReader lector = new BufferedReader(
                new FileReader(cami, StandardCharsets.UTF_8))) {

            String linia;
            while ((linia = lector.readLine()) != null) {
                Registre r = parsejar(linia);
                if (r != null) {
                    index.put(r.isbn(), r);
                }
            }
        }
        return index;
    }

    /** Retorna null si la linia no es un registre valid. */
    private Registre parsejar(String linia) {
        String neta = linia.trim();
        if (neta.isEmpty() || neta.startsWith(COMENTARI)) {
            return null;
        }
        String[] c = neta.split(SEPARADOR, -1);
        if (c.length != 5) {
            return null;
        }
        try {
            return new Registre(c[1].trim(), c[2].trim(), c[3].trim(),
                    Integer.parseInt(c[4].trim()));
        } catch (NumberFormatException e) {
            return null;
        }
    }

    public static void main(String[] args) throws IOException {
        Diferencies d = new ComparadorCatalegs()
                .comparar("dades/cataleg-2025.txt", "dades/cataleg-2026.txt");
        System.out.println(d.informe());
    }
}

=== COMPARACIO DE CATALEGS ===
  Identics       : 4871
  Altes          : 92
  Baixes         : 37
  Modificacions  : 14
  --- ALTES (nomes al nou) ---
    978-0000005001 - Arquitectura hexagonal
    978-0000005002 - Java modern
    ... i 90 mes
  --- BAIXES (nomes a l'antic) ---
    978-0000000341 - Manual de COBOL
    ... i 36 mes
  --- MODIFICACIONS ---
    978-0000000002 - titol: 'Patrons de Disseny' -> 'Patrons de Disseny i Refactoritzacio'
    978-0000000047 - any: 2018 -> 2019
    ... i 12 mes