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

public class MedirBuffer {

    /** Sin buffer: una llamada al sistema por caracter. */
    static long sinBuffer(String ruta) throws IOException {
        long n = 0;
        try (FileReader lector = new FileReader(ruta, StandardCharsets.UTF_8)) {
            while (lector.read() != -1) {
                n++;
            }
        }
        return n;
    }

    /** Con buffer, mismo bucle: el buffer absorbe las llamadas. */
    static long conBuffer(String ruta) throws IOException {
        long n = 0;
        try (BufferedReader lector = new BufferedReader(
                new FileReader(ruta, StandardCharsets.UTF_8))) {
            while (lector.read() != -1) {
                n++;
            }
        }
        return n;
    }

    /** Con buffer y por lineas: la forma idiomatica. */
    static long porLineas(String ruta) throws IOException {
        long n = 0;
        try (BufferedReader lector = new BufferedReader(
                new FileReader(ruta, StandardCharsets.UTF_8))) {
            String linea;
            while ((linea = lector.readLine()) != null) {
                n += linea.length();
            }
        }
        return n;
    }

    public static void main(String[] args) throws IOException {
        String ruta = "datos/catalogo-grande.txt";     // unos 5 MB

        medir("Sin buffer, caracter a caracter", () -> sinBuffer(ruta));
        medir("Con buffer, caracter a caracter", () -> conBuffer(ruta));
        medir("Con buffer, por lineas",          () -> porLineas(ruta));
    }

    interface Medible { long ejecutar() throws IOException; }

    static void medir(String nombre, Medible m) throws IOException {
        long inicio = System.nanoTime();
        long resultado = m.ejecutar();
        long ms = (System.nanoTime() - inicio) / 1_000_000;
        System.out.printf("%-35s %6d ms  (%d caracteres)%n", nombre, ms, resultado);
    }
}

Sin buffer, caracter a caracter       4512 ms  (5242880 caracteres)
Con buffer, caracter a caracter         68 ms  (5242880 caracteres)
Con buffer, por lineas                  41 ms  (5158400 caracteres)

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

// Lectura, tamano por defecto (8192 caracteres)
BufferedReader lector = new BufferedReader(
        new FileReader("datos/catalogo.txt", StandardCharsets.UTF_8));

// Lectura, tamano explicito
BufferedReader grande = new BufferedReader(
        new FileReader("datos/catalogo.txt", StandardCharsets.UTF_8), 65536);

// Escritura
BufferedWriter escritor = new BufferedWriter(
        new FileWriter("datos/informe.txt", StandardCharsets.UTF_8));

// Sobre un puente, cuando la fuente no es un fichero (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(ruta, StandardCharsets.UTF_8))) {

    String linea;
    while ((linea = lector.readLine()) != null) {
        procesar(linea);
    }
}

// MAL 1: se para en la primera linea vacia
while (!(linea = lector.readLine()).isEmpty()) { }
// Ademas: NullPointerException al llegar al final, porque readLine devuelve null

// MAL 2: lee cada linea DOS veces y se salta una de cada dos
while (lector.readLine() != null) {
    procesar(lector.readLine());     // esta es la SIGUIENTE linea
}

// MAL 3: ready() no significa "quedan datos". Apartado 7
while (lector.ready()) {
    procesar(lector.readLine());
}

int numeroLinea = 0;
String linea;
while ((linea = lector.readLine()) != null) {
    numeroLinea++;

    String limpia = linea.trim();
    if (limpia.isEmpty() || limpia.startsWith("#")) {
        continue;                        // vacias y comentarios: 02-04
    }
    procesar(limpia, numeroLinea);       // el numero, para poder informar del error
}

public boolean ready() throws IOException

// MAL: uso incorrecto de ready()
try (BufferedReader lector = new BufferedReader(new FileReader(ruta, UTF_8))) {
    while (lector.ready()) {              // <-- BUG
        System.out.println(lector.readLine());
    }
}

public void mark(int limiteDeLectura) 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 DeteccionDeCabecera {

    /**
     * Detecta si el fichero tiene cabecera; si no la tiene, la primera
     * linea es un dato y NO debe perderse.
     */
    public static void procesar(String ruta) throws IOException {
        try (BufferedReader lector = new BufferedReader(
                new FileReader(ruta, StandardCharsets.UTF_8))) {

            lector.mark(8192);                     // margen amplio
            String primera = lector.readLine();

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

            if (!tieneCabecera) {
                lector.reset();                    // devolver la linea al flujo
                System.out.println("Sin cabecera: la primera linea es un dato");
            } else {
                System.out.println("Cabecera detectada: " + primera);
            }

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

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

public class EscrituraConBuffer {

    public static void escribir(String ruta) throws IOException {
        try (BufferedWriter escritor = new BufferedWriter(
                new FileWriter(ruta, StandardCharsets.UTF_8))) {

            escritor.write("# Catalogo de BiblioTech");
            escritor.newLine();                        // separador DEL SISTEMA

            escritor.write("LIBRO;978-0000000001;Java Efectivo");
            escritor.newLine();

            escritor.write("LIBRO;978-0000000002;Patrones de Diseno");
            escritor.newLine();
        }
        // close() -> flush() -> los datos llegan al disco (07-02)
    }
}

try (PrintWriter salida = new PrintWriter(          // 3. formateo
        new BufferedWriter(                          // 2. buffer
            new FileWriter(ruta,                     // 1. fichero + charset
                    StandardCharsets.UTF_8)))) {

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

// Opcion A: PrintWriter. Comodo, pero los errores hay que preguntarlos.
try (PrintWriter salida = new PrintWriter(
        new BufferedWriter(new FileWriter(ruta, UTF_8)))) {
    salida.printf("%-25s %8.2f%n", titulo, multa);
    if (salida.checkError()) {
        throw new IOException("Fallo al escribir " + ruta);
    }
}

// Opcion B: BufferedWriter. Mas verboso, pero los errores se propagan solos.
try (BufferedWriter salida = new BufferedWriter(new FileWriter(ruta, UTF_8))) {
    salida.write(String.format("%-25s %8.2f", titulo, multa));
    salida.newLine();
}

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

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

    String linea;
    while ((linea = lector.readLine()) != null) {
        procesar(linea);
    }
}

// Escritura, con opciones explicitas
try (BufferedWriter escritor = Files.newBufferedWriter(
        Path.of("datos/informe.txt"), StandardCharsets.UTF_8)) {
    escritor.write("...");
    escritor.newLine();
}

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

public class ProcesamientoEnFlujo {

    /**
     * Recorre un fichero de CUALQUIER tamano con memoria constante.
     *
     * En cada instante hay en memoria: el buffer (8 KB), la linea actual
     * y los acumuladores. Da igual que el fichero tenga 1 MB o 50 GB.
     */
    public static Resumen analizar(String ruta) throws IOException {
        long lineas = 0;
        long caracteres = 0;
        long lineasVacias = 0;
        int  maxLongitud = 0;
        String lineaMasLarga = "";

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

            String linea;
            while ((linea = lector.readLine()) != null) {
                lineas++;
                caracteres += linea.length();

                if (linea.isBlank()) {
                    lineasVacias++;
                }
                if (linea.length() > maxLongitud) {
                    maxLongitud = linea.length();
                    lineaMasLarga = linea;      // se guarda UNA, no todas
                }
                // 'linea' queda disponible para el recolector en la vuelta siguiente
            }
        }
        return new Resumen(lineas, caracteres, lineasVacias, maxLongitud, lineaMasLarga);
    }

    public record Resumen(long lineas, long caracteres, long lineasVacias,
                          int maxLongitud, String lineaMasLarga) { }
}

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

public class ConsolaConBufferedReader {

    public static void main(String[] args) throws IOException {
        // System.in es un InputStream (bytes): hace falta el PUENTE (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("Dias de prestamo: ");
        String texto = consola.readLine();

        // BufferedReader NO parsea: hay que convertir a mano
        int dias;
        try {
            dias = Integer.parseInt(texto.trim());
        } catch (NumberFormatException e) {
            System.out.println("'" + texto + "' no es un numero valido");
            return;
        }

        System.out.printf("Prestamo de %s por %d dias%n", referencia, dias);

        // OJO: NO se cierra el BufferedReader. Cerrarlo cerraria System.in
        // para toda la aplicacion, y no habria forma de reabrirlo (06-06).
    }
}

package com.nexussoftware.bibliotech.servicio;

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.dominio.Libro;
import com.nexussoftware.bibliotech.dominio.Material;
import com.nexussoftware.bibliotech.dominio.ReferenciaDuplicadaException;
import com.nexussoftware.bibliotech.infraestructura.FormatoFicheros;

/**
 * Importacion masiva del catalogo de BiblioTech desde un fichero de texto.
 *
 * Formato esperado (una linea por material):
 *   LIBRO;isbn;titulo;autor;anio
 *
 * Politica (06-07):
 *   - Una linea mala NO aborta la importacion: se descarta y se cuenta.
 *   - El fichero ausente o ilegible SI aborta: no hay nada que importar.
 *   - Los materiales se acumulan y se vuelcan al catalogo AL FINAL, para no
 *     dejarlo a medias si el fichero resulta estar corrupto por completo.
 *
 * Procesa en FLUJO: memoria constante sea cual sea el tamano del fichero.
 */
public class ImportadorCatalogo {

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

    private static final int CAMPOS_ESPERADOS = 5;
    private static final int ANIO_MINIMO = 1450;
    private static final int ANIO_MAXIMO = 2100;

    /** Si mas de esta fraccion de lineas falla, el fichero es sospechoso. */
    private static final double UMBRAL_FICHERO_CORRUPTO = 0.5;

    /** Errores detallados que se guardan; el resto solo se cuentan. */
    private static final int MAX_ERRORES_DETALLADOS = 100;

    private final File fichero;

    public ImportadorCatalogo(String ruta) {
        this.fichero = new File(Objects.requireNonNull(ruta, "La ruta no puede ser nula"));
    }

    // ------------------------- EL INFORME -------------------------

    /** Motivo por el que se descarta una línea. Enum (04-07): sin cadenas magicas. */
    public enum MotivoDescarte {
        NUMERO_DE_CAMPOS("Numero de campos incorrecto"),
        TIPO_DESCONOCIDO("Tipo de material no reconocido"),
        CAMPO_VACIO("Campo obligatorio vacio"),
        ANIO_NO_NUMERICO("El anio no es un numero"),
        ANIO_FUERA_DE_RANGO("Anio fuera del rango admitido"),
        ISBN_INVALIDO("El ISBN no tiene el formato esperado"),
        DUPLICADO("Referencia o ISBN ya presentes");

        private final String descripcion;
        MotivoDescarte(String descripcion) { this.descripcion = descripcion; }
        public String getDescripcion() { return descripcion; }
    }

    /** Una linea descartada, con todo lo necesario para corregirla. */
    public record LineaDescartada(int numero, MotivoDescarte motivo, String detalle,
                                  String contenido) {
        @Override
        public String toString() {
            return String.format("Linea %d [%s]: %s | %s",
                    numero, motivo.name(), detalle, recortar(contenido));
        }
        private static String recortar(String s) {
            return (s.length() <= 60) ? s : s.substring(0, 57) + "...";
        }
    }

    /** Resultado completo de la importacion. */
    public static class Informe {
        private final List<Material> importados = new ArrayList<>();
        private final List<LineaDescartada> descartadas = new ArrayList<>();
        private final Map<MotivoDescarte, Integer> porMotivo = new LinkedHashMap<>();

        private int lineasLeidas = 0;
        private int lineasIgnoradas = 0;       // vacias y comentarios
        private int descartesTotales = 0;      // incluye los no detallados
        private long milisegundos = 0;
        private boolean abortada = false;
        private String motivoAborto = null;

        void contarLinea()      { lineasLeidas++; }
        void contarIgnorada()   { lineasIgnoradas++; }
        void anadir(Material m) { importados.add(m); }

        void descartar(LineaDescartada d) {
            descartesTotales++;
            porMotivo.merge(d.motivo(), 1, Integer::sum);      // 05-05
            if (descartadas.size() < MAX_ERRORES_DETALLADOS) {
                descartadas.add(d);
            }
        }

        void abortar(String motivo) {
            abortada = true;
            motivoAborto = motivo;
        }

        public List<Material> getImportados()            { return List.copyOf(importados); }
        public List<LineaDescartada> getDescartadas()    { return List.copyOf(descartadas); }
        public Map<MotivoDescarte, Integer> getPorMotivo() { return Map.copyOf(porMotivo); }
        public int getLineasLeidas()     { return lineasLeidas; }
        public int getLineasIgnoradas()  { return lineasIgnoradas; }
        public int getImportadosTotal()  { return importados.size(); }
        public int getDescartesTotales() { return descartesTotales; }
        public long getMilisegundos()    { return milisegundos; }
        public boolean estaAbortada()    { return abortada; }
        public String getMotivoAborto()  { return motivoAborto; }

        public double tasaExito() {
            int procesadas = importados.size() + descartesTotales;
            return (procesadas == 0) ? 0.0 : (importados.size() * 100.0) / procesadas;
        }

        /** Informe legible para la capa de presentacion. */
        public String resumen() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== INFORME DE IMPORTACION ===\n");

            if (abortada) {
                sb.append("  IMPORTACION ABORTADA: ").append(motivoAborto).append('\n');
                return sb.toString();
            }

            sb.append(String.format("  Lineas leidas    : %d%n", lineasLeidas));
            sb.append(String.format("  Ignoradas        : %d (vacias y comentarios)%n",
                    lineasIgnoradas));
            sb.append(String.format("  Importadas       : %d%n", importados.size()));
            sb.append(String.format("  Descartadas      : %d%n", descartesTotales));
            sb.append(String.format("  Tasa de exito    : %.1f%%%n", tasaExito()));
            sb.append(String.format("  Tiempo           : %d ms%n", milisegundos));

            if (!porMotivo.isEmpty()) {
                sb.append("  --- Descartes por motivo ---\n");
                for (Map.Entry<MotivoDescarte, Integer> e : porMotivo.entrySet()) {
                    sb.append(String.format("    %-22s %4d  (%s)%n",
                            e.getKey().name(), e.getValue(),
                            e.getKey().getDescripcion()));
                }
            }
            if (!descartadas.isEmpty()) {
                sb.append("  --- Primeras lineas descartadas ---\n");
                int mostradas = Math.min(10, descartadas.size());
                for (int i = 0; i < mostradas; i++) {
                    sb.append("    ").append(descartadas.get(i)).append('\n');
                }
                if (descartesTotales > mostradas) {
                    sb.append(String.format("    ... y %d mas%n",
                            descartesTotales - mostradas));
                }
            }
            return sb.toString();
        }
    }

    // ------------------------- LA IMPORTACION -------------------------

    /**
     * Importa el fichero al catalogo dado.
     *
     * @return el informe. Nunca null, ni siquiera si aborta.
     */
    public Informe importar(Catalogo catalogo) {
        Objects.requireNonNull(catalogo, "El catalogo no puede ser nulo");

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

        LOG.info(() -> "Iniciando importacion desde " + fichero.getAbsolutePath());

        // BufferedReader: memoria constante aunque el fichero tenga millones
        // de lineas. Charset explicito, el mismo que usa el exportador.
        try (BufferedReader lector = new BufferedReader(
                new FileReader(fichero, FormatoFicheros.CHARSET))) {

            String linea;
            int numero = 0;

            while ((linea = lector.readLine()) != null) {   // el bucle canonico
                numero++;
                informe.contarLinea();
                procesarLinea(linea, numero, informe);
            }

        } catch (java.io.FileNotFoundException e) {
            informe.abortar("No existe el fichero " + fichero.getAbsolutePath());
            LOG.log(Level.WARNING, "Importacion abortada: fichero no encontrado", e);
            return finalizar(informe, inicio);

        } catch (IOException e) {
            informe.abortar("Fallo de E/S leyendo " + fichero.getAbsolutePath()
                    + ": " + e.getMessage());
            LOG.log(Level.SEVERE, "Importacion abortada por fallo de E/S", e);
            return finalizar(informe, inicio);
        }

        // Comprobacion de cordura: si falla mas de la mitad, algo va mal con
        // el fichero entero (charset equivocado, formato distinto, columnas
        // cambiadas). Mejor rechazarlo que meter basura en el catalogo.
        int procesadas = informe.getImportadosTotal() + informe.getDescartesTotales();
        if (procesadas > 10
                && informe.getDescartesTotales() > procesadas * UMBRAL_FICHERO_CORRUPTO) {

            informe.abortar(String.format(
                    "Ha fallado el %.0f%% de las lineas (%d de %d). El fichero no parece "
                            + "tener el formato esperado; no se importa nada.",
                    100 - informe.tasaExito(), informe.getDescartesTotales(), procesadas));

            LOG.severe(() -> "Importacion rechazada: " + informe.getMotivoAborto());
            return finalizar(informe, inicio);
        }

        // Volcado al catalogo AL FINAL: hasta aqui no se ha tocado nada
        volcar(catalogo, informe);
        return finalizar(informe, inicio);
    }

    /** Valida y construye el material de una linea. Nunca lanza hacia arriba. */
    private void procesarLinea(String linea, int numero, Informe informe) {
        String limpia = linea.trim();

        if (limpia.isEmpty() || limpia.startsWith(FormatoFicheros.COMENTARIO)) {
            informe.contarIgnorada();
            return;
        }

        // El -1 conserva los campos vacios del final (07-01, solucion 3)
        String[] campos = limpia.split(FormatoFicheros.SEPARADOR_CAMPOS, -1);

        if (campos.length != CAMPOS_ESPERADOS) {
            informe.descartar(new LineaDescartada(numero, MotivoDescarte.NUMERO_DE_CAMPOS,
                    "hay " + campos.length + " y se esperaban " + CAMPOS_ESPERADOS,
                    limpia));
            return;
        }

        String tipo   = campos[0].trim().toUpperCase();
        String isbn   = campos[1].trim();
        String titulo = campos[2].trim();
        String autor  = campos[3].trim();
        String anioTx = campos[4].trim();

        if (!"LIBRO".equals(tipo)) {
            informe.descartar(new LineaDescartada(numero, MotivoDescarte.TIPO_DESCONOCIDO,
                    "'" + tipo + "'", limpia));
            return;
        }
        if (titulo.isEmpty() || isbn.isEmpty()) {
            informe.descartar(new LineaDescartada(numero, MotivoDescarte.CAMPO_VACIO,
                    titulo.isEmpty() ? "titulo" : "isbn", limpia));
            return;
        }
        if (!isbn.matches("\\d{3}-\\d{10}")) {
            informe.descartar(new LineaDescartada(numero, MotivoDescarte.ISBN_INVALIDO,
                    "'" + isbn + "' no cumple NNN-NNNNNNNNNN", limpia));
            return;
        }

        int anio;
        try {
            anio = Integer.parseInt(anioTx);
        } catch (NumberFormatException e) {
            informe.descartar(new LineaDescartada(numero, MotivoDescarte.ANIO_NO_NUMERICO,
                    "'" + anioTx + "'", limpia));
            return;
        }
        if (anio < ANIO_MINIMO || anio > ANIO_MAXIMO) {
            informe.descartar(new LineaDescartada(numero, MotivoDescarte.ANIO_FUERA_DE_RANGO,
                    anio + " fuera de [" + ANIO_MINIMO + ", " + ANIO_MAXIMO + "]", limpia));
            return;
        }

        informe.anadir(new Libro(titulo, autor.isEmpty() ? "Desconocido" : autor, isbn, anio));
    }

    /**
     * Vuelca al catalogo lo importado.
     *
     * Los duplicados se detectan AQUI, porque solo el catalogo los conoce.
     * Un duplicado no invalida la importacion entera: se descarta y se sigue.
     */
    private void volcar(Catalogo catalogo, Informe informe) {
        List<Material> pendientes = informe.getImportados();
        List<Material> aceptados = new ArrayList<>(pendientes.size());

        for (Material m : pendientes) {
            try {
                catalogo.registrar(m);
                aceptados.add(m);
            } catch (ReferenciaDuplicadaException e) {
                informe.descartar(new LineaDescartada(0, MotivoDescarte.DUPLICADO,
                        e.getMessage(), m.getReferencia()));
            }
        }
        informe.importados.clear();
        informe.importados.addAll(aceptados);      // solo lo realmente registrado
    }

    private Informe finalizar(Informe informe, long inicio) {
        informe.milisegundos = (System.nanoTime() - inicio) / 1_000_000;

        if (informe.estaAbortada()) {
            LOG.warning(() -> "Importacion abortada: " + informe.getMotivoAborto());
        } else {
            LOG.info(() -> String.format(
                    "Importacion terminada: %d importados, %d descartados, %d ms",
                    informe.getImportadosTotal(), informe.getDescartesTotales(),
                    informe.getMilisegundos()));
        }
        return informe;
    }
}

package com.nexussoftware.bibliotech.presentacion;

import com.nexussoftware.bibliotech.servicio.Catalogo;
import com.nexussoftware.bibliotech.servicio.ImportadorCatalogo;

public class DemoImportacion {

    public static void main(String[] args) {
        Catalogo catalogo = new Catalogo();

        ImportadorCatalogo importador =
                new ImportadorCatalogo("datos/catalogo-completo.txt");

        ImportadorCatalogo.Informe informe = importador.importar(catalogo);

        System.out.println(informe.resumen());
        System.out.println("Materiales en el catalogo: " + catalogo.tamano());
    }
}

=== INFORME DE IMPORTACION ===
  Lineas leidas    : 5003
  Ignoradas        : 3 (vacias y comentarios)
  Importadas       : 4962
  Descartadas      : 38
  Tasa de exito    : 99.2%
  Tiempo           : 87 ms
  --- Descartes por motivo ---
    ANIO_NO_NUMERICO         14  (El anio no es un numero)
    ISBN_INVALIDO            11  (El ISBN no tiene el formato esperado)
    NUMERO_DE_CAMPOS          7  (Numero de campos incorrecto)
    DUPLICADO                 4  (Referencia o ISBN ya presentes)
    CAMPO_VACIO               2  (Campo obligatorio vacio)
  --- Primeras lineas descartadas ---
    Linea 47 [ANIO_NO_NUMERICO]: 'mil novecientos' | LIBRO;978-0000000047;Un libro;Autor;mil...
    Linea 112 [NUMERO_DE_CAMPOS]: hay 4 y se esperaban 5 | LIBRO;978-0000000112;Otro;Autor
    Linea 340 [ISBN_INVALIDO]: '97800000340' no cumple NNN-NNNNNNNNNN | LIBRO;97800000340;...
    ... y 35 mas

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;

/**
 * Estadisticas de un fichero de texto en UN SOLO RECORRIDO y con memoria
 * constante respecto al tamano del fichero.
 *
 * Lo unico que crece es el mapa de frecuencias, que depende del numero de
 * palabras DISTINTAS, no del tamano del fichero. Un fichero de 10 GB en
 * espanol tiene del orden de cien mil palabras distintas: perfectamente
 * manejable.
 */
public class EstadisticasFichero {

    private static final int PALABRAS_TOP = 3;
    private static final int LONGITUD_MUESTRA = 60;

    public record Estadisticas(
            long lineas, long palabras, long caracteres,
            long lineasVacias, long lineasComentario,
            double longitudMedia, int longitudMinima, int longitudMaxima,
            int numeroLineaMasLarga, String muestraLineaMasLarga,
            List<Map.Entry<String, Integer>> palabrasFrecuentes) {

        public String informe() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== ESTADISTICAS DEL FICHERO ===\n");
            sb.append(String.format("  Lineas            : %d%n", lineas));
            sb.append(String.format("    vacias          : %d%n", lineasVacias));
            sb.append(String.format("    comentarios     : %d%n", lineasComentario));
            sb.append(String.format("  Palabras          : %d%n", palabras));
            sb.append(String.format("  Caracteres        : %d%n", caracteres));
            sb.append(String.format("  Longitud media    : %.1f%n", longitudMedia));
            sb.append(String.format("  Longitud minima   : %d%n", longitudMinima));
            sb.append(String.format("  Longitud maxima   : %d (linea %d)%n",
                    longitudMaxima, numeroLineaMasLarga));
            sb.append(String.format("    muestra         : %s%n", muestraLineaMasLarga));
            sb.append("  Palabras mas frecuentes:\n");
            for (Map.Entry<String, Integer> e : palabrasFrecuentes) {
                sb.append(String.format("    %-20s %6d%n", e.getKey(), e.getValue()));
            }
            return sb.toString();
        }
    }

    public static Estadisticas analizar(String ruta) throws IOException {
        long lineas = 0, palabras = 0, caracteres = 0;
        long vacias = 0, comentarios = 0;
        int  minima = Integer.MAX_VALUE, maxima = 0;
        int  numeroMasLarga = 0;
        String muestraMasLarga = "";

        // Solo esto crece, y con el numero de palabras DISTINTAS
        Map<String, Integer> frecuencias = new HashMap<>();

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

            String linea;
            while ((linea = lector.readLine()) != null) {     // bucle canonico
                lineas++;
                caracteres += linea.length();

                int longitud = linea.length();
                if (longitud < minima) { minima = longitud; }
                if (longitud > maxima) {
                    maxima = longitud;
                    numeroMasLarga = (int) lineas;
                    muestraMasLarga = longitud <= LONGITUD_MUESTRA
                            ? linea
                            : linea.substring(0, LONGITUD_MUESTRA) + "...";
                }

                String limpia = linea.trim();
                if (limpia.isEmpty()) {
                    vacias++;
                    continue;
                }
                if (limpia.startsWith("#")) {
                    comentarios++;
                    continue;
                }

                // Separa por cualquier cosa que no sea letra o digito
                for (String palabra : limpia.toLowerCase().split("[^\\p{L}\\p{N}]+")) {
                    if (palabra.length() > 2) {           // ignora articulos cortos
                        palabras++;
                        frecuencias.merge(palabra, 1, Integer::sum);   // 05-05
                    }
                }
                // 'linea' se descarta aqui: memoria constante
            }
        }

        if (minima == Integer.MAX_VALUE) {
            minima = 0;                                   // fichero vacio
        }

        return new Estadisticas(
                lineas, palabras, caracteres, vacias, comentarios,
                lineas == 0 ? 0.0 : (double) caracteres / lineas,
                minima, maxima, numeroMasLarga, muestraMasLarga,
                masFrecuentes(frecuencias, PALABRAS_TOP));
    }

    /**
     * Las n entradas con mayor valor.
     *
     * Sin la API de Streams (10-04): lista + Comparator + sort, que es
     * exactamente lo de 05-09.
     */
    private static List<Map.Entry<String, Integer>> masFrecuentes(
            Map<String, Integer> frecuencias, int n) {

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

        // Descendente por valor; a igualdad, alfabetico por clave
        entradas.sort(Comparator
                .comparing(Map.Entry<String, Integer>::getValue).reversed()
                .thenComparing(Map.Entry::getKey));

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

    public static void main(String[] args) throws IOException {
        String ruta = (args.length > 0) ? args[0] : "datos/catalogo.txt";
        System.out.println(analizar(ruta).informe());
    }
}

=== ESTADISTICAS DEL FICHERO ===
  Lineas            : 5003
  Lineas vacias     : 1
  Comentarios       : 2
  Palabras          : 19842
  Caracteres        : 248915
  Longitud media    : 49.8
  Longitud minima   : 0
  Longitud maxima   : 87 (linea 1204)
    muestra         : LIBRO;978-0000001204;Introduccion a los sistemas distribuidos...
  Palabras mas frecuentes:
    libro                  5000
    programacion            412
    sistemas                287

package com.nexussoftware.bibliotech.servicio;

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 fichero de catalogo escribiendo otro con las lineas que cumplan
 * un criterio, SIN cargar ninguno de los dos en memoria.
 *
 * Lee y escribe en flujo simultaneamente: en cada instante hay en memoria
 * una linea y dos buffers de 8 KB.
 */
public class FiltroCatalogo {

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

    private static final String COMENTARIO = "#";

    /**
     * Criterio de filtrado. Interfaz funcional propia (04-06): recibe la
     * linea y su numero, por si el criterio depende de la posicion.
     */
    @FunctionalInterface
    public interface Predicado {
        boolean cumple(String linea, int numero);
    }

    public record ResultadoFiltro(int leidas, int escritas, int descartadas,
                                  int comentariosConservados, long milisegundos) {

        public String resumen() {
            return String.format(
                    "Filtrado: %d leidas, %d escritas, %d descartadas, "
                            + "%d comentarios conservados (%d ms)",
                    leidas, escritas, descartadas, comentariosConservados, milisegundos);
        }
    }

    /**
     * Filtra origen hacia destino de forma ATOMICA (07-02).
     *
     * Si algo falla a mitad, el destino anterior queda intacto.
     */
    public ResultadoFiltro filtrar(String origen, String destino, Predicado criterio)
            throws IOException {

        long inicio = System.nanoTime();

        File ficheroDestino = new File(destino);
        File temporal = new File(ficheroDestino.getAbsolutePath() + ".tmp");

        int leidas = 0, escritas = 0, descartadas = 0, comentarios = 0;
        boolean completado = false;

        try {
            // Lectura y escritura simultaneas, ambas con buffer.
            // Se declaran los dos recursos en el mismo try-with-resources:
            // se cierran en orden inverso, el escritor primero (06-06).
            try (BufferedReader lector = new BufferedReader(
                         new FileReader(origen, StandardCharsets.UTF_8));
                 BufferedWriter escritor = new BufferedWriter(
                         new FileWriter(temporal, StandardCharsets.UTF_8))) {

                String linea;
                int numero = 0;

                while ((linea = lector.readLine()) != null) {
                    numero++;
                    leidas++;

                    String limpia = linea.trim();

                    // Comentarios y cabeceras: se conservan siempre
                    if (limpia.isEmpty() || limpia.startsWith(COMENTARIO)) {
                        escritor.write(linea);
                        escritor.newLine();
                        comentarios++;
                        continue;
                    }

                    if (criterio.cumple(linea, numero)) {
                        escritor.write(linea);
                        escritor.newLine();          // readLine NO devuelve el salto
                        escritas++;
                    } else {
                        descartadas++;
                    }
                }
                // BufferedWriter lanza IOException de verdad: sin checkError
            }

            // Sustitucion atomica
            if (ficheroDestino.exists() && !ficheroDestino.delete()) {
                throw new IOException("No se pudo sustituir " + destino);
            }
            if (!temporal.renameTo(ficheroDestino)) {
                throw new IOException("No se pudo renombrar " + temporal.getName());
            }
            completado = true;

        } finally {
            if (!completado && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sin borrar: " + temporal.getAbsolutePath());
            }
        }

        ResultadoFiltro resultado = new ResultadoFiltro(leidas, escritas, descartadas,
                comentarios, (System.nanoTime() - inicio) / 1_000_000);

        LOG.info(resultado::resumen);
        return resultado;
    }

    // ------------------------- CRITERIOS -------------------------

    /** Anio de publicacion posterior al dado. Campo 5 del formato. */
    public static Predicado publicadoDespuesDe(int anio) {
        return (linea, numero) -> {
            String[] campos = linea.split(";", -1);
            if (campos.length < 5) {
                return false;
            }
            try {
                return Integer.parseInt(campos[4].trim()) > anio;
            } catch (NumberFormatException e) {
                return false;               // anio ilegible: no cumple
            }
        };
    }

    /** El autor contiene el texto dado, sin distinguir mayusculas. */
    public static Predicado autorContiene(String texto) {
        String buscado = texto.toLowerCase();
        return (linea, numero) -> {
            String[] campos = linea.split(";", -1);
            return campos.length >= 4 && campos[3].toLowerCase().contains(buscado);
        };
    }

    /** Combinacion de dos criterios (composicion de lambdas, 04-05). */
    public static Predicado y(Predicado a, Predicado b) {
        return (linea, numero) -> a.cumple(linea, numero) && b.cumple(linea, numero);
    }

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

        System.out.println(filtro.filtrar(
                "datos/catalogo.txt",
                "datos/catalogo-recientes.txt",
                publicadoDespuesDe(2000)).resumen());

        System.out.println(filtro.filtrar(
                "datos/catalogo.txt",
                "datos/catalogo-bloch.txt",
                autorContiene("bloch")).resumen());

        System.out.println(filtro.filtrar(
                "datos/catalogo.txt",
                "datos/catalogo-recientes-fowler.txt",
                y(publicadoDespuesDe(1995), autorContiene("fowler"))).resumen());
    }
}

Filtrado: 5003 leidas, 3418 escritas, 1582 descartadas, 3 comentarios conservados (61 ms)
Filtrado: 5003 leidas, 12 escritas, 4988 descartadas, 3 comentarios conservados (48 ms)
Filtrado: 5003 leidas, 7 escritas, 4993 descartadas, 3 comentarios conservados (52 ms)

package com.nexussoftware.bibliotech.servicio;

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 ficheros de catalogo e informa de altas, bajas y cambios.
 *
 * POR QUE ESTE ALGORITMO SI NECESITA MEMORIA:
 * Para saber si un material del fichero B existe en A, hay que poder
 * consultarlo. Como los flujos son SECUENCIALES y no permiten volver atras
 * (07-03), la unica forma de consultar A mientras se recorre B es tener A
 * indexado en memoria.
 *
 * CUAL CONVIENE CARGAR: el mas pequeno. Se recorre en flujo el grande.
 *
 * SI NINGUNO CABE: hay dos salidas clasicas. Ordenar ambos ficheros por
 * clave y hacer una "fusion" recorriendolos en paralelo, que necesita
 * memoria constante; o cargar solo las CLAVES (los ISBN) con un hash de
 * cada linea, que ocupa una fraccion minima. La segunda es la habitual.
 */
public class ComparadorCatalogos {

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

    /** Datos de un material tal como aparecen en el fichero. */
    private record Registro(String isbn, String titulo, String autor, int anio) {

        /** Que campos difieren respecto a otro registro con el mismo ISBN. */
        List<String> diferenciasCon(Registro otro) {
            List<String> cambios = new ArrayList<>();
            if (!titulo.equals(otro.titulo)) {
                cambios.add("titulo: '" + titulo + "' -> '" + otro.titulo + "'");
            }
            if (!autor.equals(otro.autor)) {
                cambios.add("autor: '" + autor + "' -> '" + otro.autor + "'");
            }
            if (anio != otro.anio) {
                cambios.add("anio: " + anio + " -> " + otro.anio);
            }
            return cambios;
        }
    }

    public record Diferencias(List<String> bajas, List<String> altas,
                              List<String> modificaciones, int identicos) {

        public String informe() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== COMPARACION DE CATALOGOS ===\n");
            sb.append(String.format("  Identicos      : %d%n", identicos));
            sb.append(String.format("  Altas          : %d%n", altas.size()));
            sb.append(String.format("  Bajas          : %d%n", bajas.size()));
            sb.append(String.format("  Modificaciones : %d%n", modificaciones.size()));

            imprimirBloque(sb, "ALTAS (solo en el nuevo)", altas);
            imprimirBloque(sb, "BAJAS (solo en el antiguo)", bajas);
            imprimirBloque(sb, "MODIFICACIONES", modificaciones);
            return sb.toString();
        }

        private void imprimirBloque(StringBuilder sb, String titulo, List<String> lineas) {
            if (lineas.isEmpty()) {
                return;
            }
            sb.append("  --- ").append(titulo).append(" ---\n");
            int mostradas = Math.min(10, lineas.size());
            for (int i = 0; i < mostradas; i++) {
                sb.append("    ").append(lineas.get(i)).append('\n');
            }
            if (lineas.size() > mostradas) {
                sb.append(String.format("    ... y %d mas%n", lineas.size() - mostradas));
            }
        }
    }

    /**
     * Compara dos catalogos.
     *
     * @param rutaAntiguo el que se carga EN MEMORIA (conviene el mas pequeno)
     * @param rutaNuevo   el que se recorre EN FLUJO
     */
    public Diferencias comparar(String rutaAntiguo, String rutaNuevo) throws IOException {

        // FASE 1: indexar el antiguo. Un solo recorrido.
        Map<String, Registro> antiguos = indexar(rutaAntiguo);

        List<String> altas = new ArrayList<>();
        List<String> modificaciones = new ArrayList<>();
        int identicos = 0;

        // FASE 2: recorrer el nuevo EN FLUJO, consultando el indice
        try (BufferedReader lector = new BufferedReader(
                new FileReader(rutaNuevo, StandardCharsets.UTF_8))) {

            String linea;
            while ((linea = lector.readLine()) != null) {
                Registro nuevo = parsear(linea);
                if (nuevo == null) {
                    continue;                        // comentario o linea mala
                }

                // remove() en vez de get(): lo que quede al final son las BAJAS.
                // Ahorra un segundo recorrido y una estructura adicional.
                Registro antiguo = antiguos.remove(nuevo.isbn());

                if (antiguo == null) {
                    altas.add(nuevo.isbn() + " - " + nuevo.titulo());
                    continue;
                }

                List<String> cambios = antiguo.diferenciasCon(nuevo);
                if (cambios.isEmpty()) {
                    identicos++;
                } else {
                    modificaciones.add(nuevo.isbn() + " - " + String.join("; ", cambios));
                }
            }
        }

        // FASE 3: lo que sobra del indice son las bajas
        List<String> bajas = new ArrayList<>();
        for (Registro r : antiguos.values()) {
            bajas.add(r.isbn() + " - " + r.titulo());
        }

        bajas.sort(null);                            // orden natural (05-09)
        altas.sort(null);
        modificaciones.sort(null);

        return new Diferencias(bajas, altas, modificaciones, identicos);
    }

    /** Carga un catalogo indexado por ISBN. Un solo recorrido, con buffer. */
    private Map<String, Registro> indexar(String ruta) throws IOException {
        Map<String, Registro> indice = new HashMap<>();

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

            String linea;
            while ((linea = lector.readLine()) != null) {
                Registro r = parsear(linea);
                if (r != null) {
                    indice.put(r.isbn(), r);
                }
            }
        }
        return indice;
    }

    /** Devuelve null si la linea no es un registro valido. */
    private Registro parsear(String linea) {
        String limpia = linea.trim();
        if (limpia.isEmpty() || limpia.startsWith(COMENTARIO)) {
            return null;
        }
        String[] c = limpia.split(SEPARADOR, -1);
        if (c.length != 5) {
            return null;
        }
        try {
            return new Registro(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 {
        Diferencias d = new ComparadorCatalogos()
                .comparar("datos/catalogo-2025.txt", "datos/catalogo-2026.txt");
        System.out.println(d.informe());
    }
}

=== COMPARACION DE CATALOGOS ===
  Identicos      : 4871
  Altas          : 92
  Bajas          : 37
  Modificaciones : 14
  --- ALTAS (solo en el nuevo) ---
    978-0000005001 - Arquitectura hexagonal
    978-0000005002 - Java moderno
    ... y 90 mas
  --- BAJAS (solo en el antiguo) ---
    978-0000000341 - Manual de COBOL
    ... y 36 mas
  --- MODIFICACIONES ---
    978-0000000002 - titulo: 'Patrones de Diseno' -> 'Patrones de Diseño'
    978-0000000047 - anio: 2018 -> 2019
    ... y 12 mas