/**
 * Cuenta bytes de CUALQUIER flujo de entrada.
 *
 * No sabe ni le importa si viene de un fichero, de la red, de la memoria
 * o de un array. Eso es exactamente lo que aporta la abstraccion.
 */
public static long contarBytes(InputStream entrada) throws IOException {
    long total = 0;
    int leidos;
    byte[] bloque = new byte[8192];
    while ((leidos = entrada.read(bloque)) != -1) {
        total += leidos;
    }
    return total;
}

// InputStream
public abstract int read() throws IOException;            // 0..255, o -1 al final
public int read(byte[] b) throws IOException;             // cuantos leyo, o -1
public int read(byte[] b, int off, int len);
public void close() throws IOException;
public long transferTo(OutputStream destino);             // Java 9

// OutputStream
public abstract void write(int b) throws IOException;     // el byte menos significativo
public void write(byte[] b);
public void write(byte[] b, int off, int len);
public void flush() throws IOException;
public void close() throws IOException;

// Reader
public int read() throws IOException;                     // 0..65535, o -1
public int read(char[] c);
public void close() throws IOException;

// Writer
public void write(int c);
public void write(String s);
public void write(char[] c);
public void flush();
public void close();

// NODO: recibe un recurso (una ruta, un File, un array)
new FileInputStream("catalogo.txt")
new ByteArrayInputStream(datos)

// FILTRO: recibe OTRO FLUJO
new BufferedInputStream(otroFlujo)
new DataInputStream(otroFlujo)
new PrintWriter(otroWriter)

new DataInputStream(          // filtro: anade readInt, readDouble...
    new BufferedInputStream(  // filtro: anade buffer
        new FileInputStream(  // NODO: conecta con el fichero
            "datos/prestamos.bin")))

// CORRECTO: el buffer esta entre el fichero y los tipos
new DataInputStream(new BufferedInputStream(new FileInputStream(f)))

// INUTIL: el buffer esta fuera. DataInputStream lee directo del fichero,
// 4 bytes cada vez, con una llamada al sistema por cada uno.
new BufferedInputStream(new DataInputStream(new FileInputStream(f)))

// Basta con esto: el close() de PrintWriter cierra BufferedWriter,
// que cierra FileWriter, que cierra el fichero.
try (PrintWriter salida = new PrintWriter(
        new BufferedWriter(
            new FileWriter("informe.txt", StandardCharsets.UTF_8)))) {
    salida.println("...");
}

try (FileWriter fw = new FileWriter("informe.txt", StandardCharsets.UTF_8);
     BufferedWriter bw = new BufferedWriter(fw);
     PrintWriter salida = new PrintWriter(bw)) {
    salida.println("...");
}
// Cada recurso declarado por separado: todos se cierran, en orden inverso (06-06)

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

public class UsoDelPuente {

    /** Lectura de texto con la cadena completa, explicita. */
    public static void leer(String ruta) throws IOException {
        try (BufferedReader lector = new BufferedReader(       // 3. buffer y readLine
                new InputStreamReader(                          // 2. PUENTE: aqui el charset
                        new FileInputStream(ruta),              // 1. NODO: bytes del fichero
                        StandardCharsets.UTF_8))) {

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

    /** Escritura simetrica. */
    public static void escribir(String ruta, String texto) throws IOException {
        try (BufferedWriter escritor = new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream(ruta),
                        StandardCharsets.UTF_8))) {
            escritor.write(texto);
        }
    }
}

// Estas dos lineas son practicamente lo mismo:
new FileReader(ruta, StandardCharsets.UTF_8)
new InputStreamReader(new FileInputStream(ruta), StandardCharsets.UTF_8)

// Y estas dos tambien:
new FileWriter(ruta, StandardCharsets.UTF_8)
new OutputStreamWriter(new FileOutputStream(ruta), StandardCharsets.UTF_8)

// Leer texto de la ENTRADA ESTANDAR: no hay un "FileReader de System.in"
new InputStreamReader(System.in, StandardCharsets.UTF_8)

// Leer texto de una conexion de red (modulo 9)
new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)

// Leer texto de un recurso dentro del .jar
new InputStreamReader(getClass().getResourceAsStream("/config.txt"),
                      StandardCharsets.UTF_8)

PrintWriter consola = new PrintWriter(
        new OutputStreamWriter(System.out, StandardCharsets.UTF_8), true);
consola.println("Patrones de Diseño");   // charset controlado

import java.io.FileInputStream;
import java.io.IOException;

public class LecturaBinariaSimple {

    /** Muestra los primeros bytes de un fichero en hexadecimal. */
    public static void volcarCabecera(String ruta, int cuantos) throws IOException {
        try (FileInputStream entrada = new FileInputStream(ruta)) {

            for (int i = 0; i < cuantos; i++) {
                int b = entrada.read();          // 0..255, o -1 al final
                if (b == -1) {
                    System.out.println("\n(fin del fichero)");
                    break;
                }
                System.out.printf("%02X ", b);
                if ((i + 1) % 16 == 0) {
                    System.out.println();
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) throws IOException {
        volcarCabecera("portadas/java-efectivo.jpg", 32);
    }
}

FF D8 FF E0 00 10 4A 46 49 46 00 01 01 00 00 48
00 48 00 00 FF DB 00 43 00 08 06 06 07 06 05 08

byte b = -56;                    // asi lo guarda un byte[]
int sinSigno = b & 0xFF;         // 200: el valor real
System.out.printf("%02X%n", sinSigno);   // C8

try (FileOutputStream salida = new FileOutputStream("prueba.bin")) {
    salida.write(255);     // escribe el byte 0xFF
    salida.write(65);      // escribe el byte 0x41, que es la 'A' en ASCII
    salida.write(300);     // escribe 0x2C: se queda con los 8 bits BAJOS, sin avisar
}

new FileOutputStream("datos.bin");         // SOBRESCRIBE, trunca a cero
new FileOutputStream("datos.bin", true);   // ANADE al final

public int read(byte[] buffer) throws IOException

import java.io.FileInputStream;
import java.io.IOException;

public class LecturaPorBloques {

    private static final int TAMANO_BLOQUE = 8192;

    public static long contarBytes(String ruta) throws IOException {
        long total = 0;

        try (FileInputStream entrada = new FileInputStream(ruta)) {
            byte[] bloque = new byte[TAMANO_BLOQUE];
            int leidos;

            // 'leidos' es CUANTOS bytes hay de verdad en el array.
            // Solo los primeros 'leidos' son datos nuevos; el resto es
            // basura de la iteracion anterior.
            while ((leidos = entrada.read(bloque)) != -1) {
                total += leidos;
                procesar(bloque, leidos);          // SIEMPRE con el limite
            }
        }
        return total;
    }

    private static void procesar(byte[] bloque, int cuantos) {
        for (int i = 0; i < cuantos; i++) {        // hasta 'cuantos', no hasta length
            // ...
        }
    }
}

// MAL: copia SIEMPRE el array entero
while ((leidos = entrada.read(bloque)) != -1) {
    salida.write(bloque);                     // <-- deberia ser write(bloque, 0, leidos)
}

// Java 9+: lee EXACTAMENTE n bytes o lanza EOFException
byte[] cabecera = entrada.readNBytes(16);

// Java 9+: lee TODO lo que queda. Cuidado con ficheros grandes (07-01)
byte[] todo = entrada.readAllBytes();

package com.nexussoftware.bibliotech.servicio;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.logging.Logger;

/**
 * Gestion de las imagenes de portada del catalogo de BiblioTech.
 *
 * Las portadas son JPEG o PNG: datos BINARIOS. Usar Reader/Writer sobre
 * ellas las destruiria, porque el decodificador de caracteres sustituye
 * los bytes que no forman secuencias validas.
 */
public class GestorPortadas {

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

    private static final int TAMANO_BLOQUE = 8192;
    private static final long TAMANO_MAXIMO = 5 * 1024 * 1024;   // 5 MB

    private final File directorio;

    public GestorPortadas(String directorioPortadas) {
        this.directorio = new File(directorioPortadas);
        if (!directorio.exists() && !directorio.mkdirs()) {
            LOG.warning("No se pudo crear " + directorio.getAbsolutePath());
        }
    }

    /**
     * Copia la portada de un libro al almacen, nombrandola por su ISBN.
     *
     * @return bytes copiados
     * @throws IOException si falla la copia
     */
    public long importarPortada(String isbn, File origen) throws IOException {
        if (!origen.isFile()) {
            throw new IOException("No es un fichero legible: " + origen.getAbsolutePath());
        }
        if (origen.length() > TAMANO_MAXIMO) {
            throw new IOException("La portada supera el maximo de "
                    + (TAMANO_MAXIMO / 1024) + " KB: " + origen.length() + " bytes");
        }

        File destino = new File(directorio, isbn + extension(origen.getName()));
        long copiados = copiar(origen, destino);

        LOG.info(() -> String.format("Portada de %s importada: %d bytes en %s",
                isbn, copiados, destino.getName()));
        return copiados;
    }

    /**
     * Copia binaria byte a byte, con buffer en ambos extremos.
     *
     * La cadena de decoradores:
     *   FileInputStream  -> NODO: lee del fichero
     *   BufferedInputStream -> FILTRO: agrupa las lecturas
     *   (y lo mismo en el lado de escritura)
     */
    public long copiar(File origen, File destino) throws IOException {
        long total = 0;

        try (BufferedInputStream entrada =
                     new BufferedInputStream(new FileInputStream(origen), TAMANO_BLOQUE);
             BufferedOutputStream salida =
                     new BufferedOutputStream(new FileOutputStream(destino), TAMANO_BLOQUE)) {

            byte[] bloque = new byte[TAMANO_BLOQUE];
            int leidos;

            while ((leidos = entrada.read(bloque)) != -1) {
                // CLAVE: (bloque, 0, leidos), NUNCA (bloque) a secas.
                // Con (bloque) se copiaria basura al final y la imagen no abriria.
                salida.write(bloque, 0, leidos);
                total += leidos;
            }
            // El close() del try-with-resources hace flush: sin el, los ultimos
            // bytes del buffer no llegarian al fichero (07-02).
        }
        return total;
    }

    /** Detecta el formato leyendo la FIRMA del fichero, no su extension. */
    public String detectarFormato(File fichero) throws IOException {
        try (FileInputStream entrada = new FileInputStream(fichero)) {
            byte[] firma = entrada.readNBytes(8);      // Java 9+

            if (firma.length >= 3
                    && (firma[0] & 0xFF) == 0xFF
                    && (firma[1] & 0xFF) == 0xD8
                    && (firma[2] & 0xFF) == 0xFF) {
                return "JPEG";
            }
            if (firma.length >= 8
                    && (firma[0] & 0xFF) == 0x89
                    && firma[1] == 'P' && firma[2] == 'N' && firma[3] == 'G') {
                return "PNG";
            }
            if (firma.length >= 4 && firma[0] == 'G' && firma[1] == 'I' && firma[2] == 'F') {
                return "GIF";
            }
            return "DESCONOCIDO";
        }
    }

    private String extension(String nombre) {
        int punto = nombre.lastIndexOf('.');
        return (punto > 0) ? nombre.substring(punto).toLowerCase() : ".bin";
    }
}

import java.io.*;

public class DatosBinarios {

    public static void escribir(String ruta) throws IOException {
        try (DataOutputStream salida = new DataOutputStream(
                new BufferedOutputStream(new FileOutputStream(ruta)))) {

            salida.writeUTF("PR-0001");        // cadena: 2 bytes de longitud + UTF-8 modificado
            salida.writeInt(15);               // 4 bytes
            salida.writeDouble(0.25);          // 8 bytes
            salida.writeBoolean(true);         // 1 byte
            salida.writeLong(1_700_000_000L);  // 8 bytes
        }
    }

    public static void leer(String ruta) throws IOException {
        try (DataInputStream entrada = new DataInputStream(
                new BufferedInputStream(new FileInputStream(ruta)))) {

            // El ORDEN de lectura debe ser EXACTAMENTE el de escritura.
            // El fichero no lleva ninguna descripcion de su contenido.
            String referencia = entrada.readUTF();
            int    dias       = entrada.readInt();
            double tarifa     = entrada.readDouble();
            boolean devuelto  = entrada.readBoolean();
            long   marca      = entrada.readLong();

            System.out.printf("%s: %d dias, %.2f EUR/dia, devuelto=%b, marca=%d%n",
                    referencia, dias, tarifa, devuelto, marca);
        }
    }
}

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

public class FlujosEnMemoria {

    /** ByteArrayOutputStream: acumula en memoria lo que se le escribe. */
    public static byte[] generarEnMemoria() throws IOException {
        ByteArrayOutputStream memoria = new ByteArrayOutputStream();

        try (DataOutputStream salida = new DataOutputStream(memoria)) {
            salida.writeUTF("PR-0001");
            salida.writeInt(15);
            salida.writeDouble(0.25);
        }
        // toByteArray() devuelve una COPIA de lo acumulado
        return memoria.toByteArray();
    }

    /** ByteArrayInputStream: lee de un array como si fuera un fichero. */
    public static void leerDeMemoria(byte[] datos) throws IOException {
        try (DataInputStream entrada = new DataInputStream(
                new ByteArrayInputStream(datos))) {

            System.out.println(entrada.readUTF());
            System.out.println(entrada.readInt());
            System.out.println(entrada.readDouble());
        }
    }

    public static void main(String[] args) throws IOException {
        byte[] datos = generarEnMemoria();
        System.out.println("Generados " + datos.length + " bytes sin tocar el disco");
        leerDeMemoria(datos);
    }
}

/**
 * Metodo de produccion: recibe un InputStream, no una ruta.
 * Esa decision de diseno es lo que lo hace probable sin ficheros.
 */
public int contarLineas(InputStream entrada) throws IOException {
    int lineas = 0;
    try (BufferedReader lector = new BufferedReader(
            new InputStreamReader(entrada, StandardCharsets.UTF_8))) {
        while (lector.readLine() != null) {
            lineas++;
        }
    }
    return lineas;
}

// PRUEBA: sin fichero, sin disco, sin limpieza, sin dependencias del entorno
public void pruebaContarLineas() {
    String contenido = "LIBRO;978-0000000001;Java Efectivo\n"
                     + "LIBRO;978-0000000002;Patrones de Diseno\n";

    InputStream simulado =
            new ByteArrayInputStream(contenido.getBytes(StandardCharsets.UTF_8));

    int resultado = contarLineas(simulado);
    // se esperan 2
}

StringWriter memoria = new StringWriter();
try (PrintWriter salida = new PrintWriter(memoria)) {
    salida.printf("%-25s %8.2f%n", "Java Efectivo", 3.75);
}
String resultado = memoria.toString();

public long transferTo(OutputStream destino) throws IOException

import java.io.*;

public class CopiaModerna {

    /** Copia completa. Java 9+. */
    public static long copiar(File origen, File destino) throws IOException {
        try (InputStream entrada = new BufferedInputStream(new FileInputStream(origen));
             OutputStream salida = new BufferedOutputStream(new FileOutputStream(destino))) {

            return entrada.transferTo(salida);      // todo el bucle, en una linea
        }
    }
}

/** Copia informando del progreso: aqui el bucle sigue siendo necesario. */
public long copiarConProgreso(File origen, File destino) throws IOException {
    long tamano = origen.length();
    long copiados = 0;
    int ultimoPorcentaje = -1;

    try (InputStream entrada = new BufferedInputStream(new FileInputStream(origen));
         OutputStream salida = new BufferedOutputStream(new FileOutputStream(destino))) {

        byte[] bloque = new byte[8192];
        int leidos;
        while ((leidos = entrada.read(bloque)) != -1) {
            salida.write(bloque, 0, leidos);
            copiados += leidos;

            int porcentaje = (int) (copiados * 100 / Math.max(1, tamano));
            if (porcentaje != ultimoPorcentaje && porcentaje % 10 == 0) {
                System.out.printf("  %d%% (%d de %d bytes)%n", porcentaje, copiados, tamano);
                ultimoPorcentaje = porcentaje;
            }
        }
    }
    return copiados;
}

Files.copy(origen, destino, StandardCopyOption.REPLACE_EXISTING);

00000000  FF D8 FF E0 00 10 4A 46  49 46 00 01 01 00 00 48  |......JFIF.....H|
00000010  00 48 00 00 FF DB 00 43  00 08 06 06 07 06 05 08  |.H.....C........|

package com.nexussoftware.bibliotech.util;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Visor hexadecimal de ficheros, en el formato clasico de tres columnas.
 *
 * Trabaja con FLUJOS DE BYTES porque el contenido puede ser cualquier cosa:
 * usar un Reader corromperia los datos antes de poder mostrarlos.
 */
public class VisorHexadecimal {

    private static final int BYTES_POR_LINEA = 16;
    private static final int PRIMER_IMPRIMIBLE = 32;
    private static final int ULTIMO_IMPRIMIBLE = 126;

    public static void volcar(String ruta, int maxBytes) throws IOException {
        try (InputStream entrada = new BufferedInputStream(new FileInputStream(ruta))) {

            byte[] linea = new byte[BYTES_POR_LINEA];
            int offset = 0;
            int leidos;

            // readNBytes (Java 9+) insiste hasta llenar el array o llegar al
            // final. Con read() a secas podriamos recibir menos de 16 bytes
            // en medio del fichero y el volcado quedaria desalineado.
            while (offset < maxBytes
                    && (leidos = entrada.readNBytes(linea, 0, BYTES_POR_LINEA)) > 0) {

                imprimirLinea(offset, linea, leidos);
                offset += leidos;
            }
        }
    }

    private static void imprimirLinea(int offset, byte[] datos, int cuantos) {
        StringBuilder hex   = new StringBuilder();
        StringBuilder ascii = new StringBuilder();

        for (int i = 0; i < BYTES_POR_LINEA; i++) {
            if (i == 8) {
                hex.append(' ');                    // separacion de los dos grupos
            }
            if (i < cuantos) {
                // & 0xFF: sin esto, un byte negativo se imprimiria como FFFFFFxx
                int b = datos[i] & 0xFF;
                hex.append(String.format("%02X ", b));
                ascii.append(esImprimible(b) ? (char) b : '.');
            } else {
                hex.append("   ");                  // relleno de la ultima linea
                ascii.append(' ');
            }
        }

        System.out.printf("%08X  %s |%s|%n", offset, hex, ascii);
    }

    private static boolean esImprimible(int b) {
        return b >= PRIMER_IMPRIMIBLE && b <= ULTIMO_IMPRIMIBLE;
    }

    /** Detecta el formato por su FIRMA. La extension no es fiable. */
    public static String detectarFormato(String ruta) throws IOException {
        try (InputStream entrada = new BufferedInputStream(new FileInputStream(ruta))) {
            byte[] f = entrada.readNBytes(8);

            if (empieza(f, 0xFF, 0xD8, 0xFF))                 { return "JPEG"; }
            if (empieza(f, 0x89, 0x50, 0x4E, 0x47))           { return "PNG"; }
            if (empieza(f, 0x47, 0x49, 0x46, 0x38))           { return "GIF"; }
            if (empieza(f, 0x25, 0x50, 0x44, 0x46))           { return "PDF"; }
            if (empieza(f, 0x50, 0x4B, 0x03, 0x04))           { return "ZIP (o JAR, DOCX...)"; }
            if (empieza(f, 0xCA, 0xFE, 0xBA, 0xBE))           { return "CLASE DE JAVA"; }
            if (empieza(f, 0xAC, 0xED))                       { return "OBJETO SERIALIZADO (07-05)"; }
            return "DESCONOCIDO (posiblemente texto)";
        }
    }

    /** Compara los primeros bytes con la firma dada. */
    private static boolean empieza(byte[] datos, int... firma) {
        if (datos.length < firma.length) {
            return false;
        }
        for (int i = 0; i < firma.length; i++) {
            if ((datos[i] & 0xFF) != firma[i]) {      // el & 0xFF, otra vez imprescindible
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws IOException {
        String ruta = (args.length > 0) ? args[0] : "portadas/java-efectivo.jpg";

        System.out.println("Fichero : " + ruta);
        System.out.println("Formato : " + detectarFormato(ruta));
        System.out.println();
        volcar(ruta, 64);
    }
}

Fichero : portadas/java-efectivo.jpg
Formato : JPEG

00000000  FF D8 FF E0 00 10 4A 46  49 46 00 01 01 00 00 48  |......JFIF.....H|
00000010  00 48 00 00 FF DB 00 43  00 08 06 06 07 06 05 08  |.H.....C........|
00000020  07 07 07 09 09 08 0A 0C  14 0D 0C 0B 0B 0C 19 12  |................|
00000030  13 0F 14 1D 1A 1F 1E 1D  1A 1C 1C 20 24 2E 27 20  |........... $.' |

package com.nexussoftware.bibliotech.util;

import java.io.*;
import java.util.Random;

/**
 * Comparativa de cinco tecnicas de copia binaria.
 *
 * AVISO: esto NO es un banco de pruebas riguroso. La cache de pagina del
 * sistema operativo, el compilador JIT y el recolector de basura distorsionan
 * las medidas; la primera ejecucion siempre sale peor. Sirve para ver los
 * ORDENES DE MAGNITUD, que es lo que importa aqui. Para medir en serio se
 * usa JMH, que se menciona en 10-07.
 */
public class ComparadorRendimiento {

    private static final String ORIGEN  = "prueba-rendimiento.bin";
    private static final String DESTINO = "copia-rendimiento.bin";
    private static final int TAMANO_MB  = 5;

    // ---------- Las cinco tecnicas ----------

    /** 1. Byte a byte SIN buffer: una llamada al sistema por byte. */
    static long byteABytesinBuffer(File o, File d) throws IOException {
        try (InputStream in = new FileInputStream(o);
             OutputStream out = new FileOutputStream(d)) {
            int b;
            long n = 0;
            while ((b = in.read()) != -1) {
                out.write(b);
                n++;
            }
            return n;
        }
    }

    /** 2. Byte a byte CON buffer: el buffer absorbe las llamadas al sistema. */
    static long byteAByteConBuffer(File o, File d) throws IOException {
        try (InputStream in = new BufferedInputStream(new FileInputStream(o));
             OutputStream out = new BufferedOutputStream(new FileOutputStream(d))) {
            int b;
            long n = 0;
            while ((b = in.read()) != -1) {
                out.write(b);
                n++;
            }
            return n;
        }
    }

    /** 3 y 4. Por bloques del tamano indicado. */
    static long porBloques(File o, File d, int tamano) throws IOException {
        try (InputStream in = new FileInputStream(o);
             OutputStream out = new FileOutputStream(d)) {
            byte[] bloque = new byte[tamano];
            int leidos;
            long n = 0;
            while ((leidos = in.read(bloque)) != -1) {
                out.write(bloque, 0, leidos);     // el limite, SIEMPRE
                n += leidos;
            }
            return n;
        }
    }

    /** 5. transferTo (Java 9+). */
    static long conTransferTo(File o, File d) throws IOException {
        try (InputStream in = new BufferedInputStream(new FileInputStream(o));
             OutputStream out = new BufferedOutputStream(new FileOutputStream(d))) {
            return in.transferTo(out);
        }
    }

    // ---------- Infraestructura de medida ----------

    interface Tecnica {
        long copiar(File origen, File destino) throws IOException;
    }

    static void generarFicheroPrueba(File f, int megas) throws IOException {
        if (f.exists() && f.length() == megas * 1024L * 1024L) {
            return;                                // ya esta generado
        }
        Random aleatorio = new Random(42);          // semilla fija: reproducible
        byte[] bloque = new byte[1024 * 1024];

        try (OutputStream out = new BufferedOutputStream(new FileOutputStream(f))) {
            for (int i = 0; i < megas; i++) {
                aleatorio.nextBytes(bloque);
                out.write(bloque);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        File origen  = new File(ORIGEN);
        File destino = new File(DESTINO);

        System.out.println("Generando fichero de prueba de " + TAMANO_MB + " MB...");
        generarFicheroPrueba(origen, TAMANO_MB);
        System.out.println("Tamano: " + origen.length() + " bytes");
        System.out.println();

        String[] nombres = {
                "1. Byte a byte SIN buffer",
                "2. Byte a byte CON buffer",
                "3. Bloques de 512 B",
                "4. Bloques de 8 KB",
                "5. transferTo"
        };
        Tecnica[] tecnicas = {
                ComparadorRendimiento::byteABytesinBuffer,      // referencias a metodo (04-06)
                ComparadorRendimiento::byteAByteConBuffer,
                (o, d) -> porBloques(o, d, 512),
                (o, d) -> porBloques(o, d, 8192),
                ComparadorRendimiento::conTransferTo
        };

        long referencia = 0;

        System.out.printf("%-28s %10s %10s %12s%n", "TECNICA", "TIEMPO", "MB/s", "MEJORA");
        System.out.println("-".repeat(64));

        for (int i = 0; i < tecnicas.length; i++) {
            long inicio = System.nanoTime();
            long copiados = tecnicas[i].copiar(origen, destino);
            long ms = (System.nanoTime() - inicio) / 1_000_000;

            // VERIFICACION: una copia rapida pero incorrecta no vale nada
            if (copiados != origen.length() || destino.length() != origen.length()) {
                System.out.printf("%-28s  COPIA INCORRECTA: %d bytes%n",
                        nombres[i], destino.length());
                continue;
            }

            if (i == 0) {
                referencia = ms;
            }
            double mbs = (origen.length() / 1024.0 / 1024.0) / (ms / 1000.0);

            System.out.printf("%-28s %8d ms %10.1f %11.1fx%n",
                    nombres[i], ms, mbs, (double) referencia / Math.max(1, ms));
        }

        System.out.println();
        System.out.println("El salto grande esta entre 1 y 2, y la causa es una sola:");
        System.out.println("sin buffer hay UNA LLAMADA AL SISTEMA POR BYTE (5 millones);");
        System.out.println("con buffer, una cada 8192 bytes (unas 640). El resto de");
        System.out.println("mejoras son marginales en comparacion.");

        destino.delete();
    }
}

Generando fichero de prueba de 5 MB...
Tamano: 5242880 bytes

TECNICA                          TIEMPO       MB/s       MEJORA
----------------------------------------------------------------
1. Byte a byte SIN buffer          4680 ms        1.1         1.0x
2. Byte a byte CON buffer            78 ms       64.2        60.0x
3. Bloques de 512 B                  26 ms      192.5       180.0x
4. Bloques de 8 KB                    9 ms      555.6       520.0x
5. transferTo                         7 ms      714.3       668.7x

El salto grande esta entre 1 y 2, y la causa es una sola:
sin buffer hay UNA LLAMADA AL SISTEMA POR BYTE (5 millones);
con buffer, una cada 8192 bytes (unas 640). El resto de
mejoras son marginales en comparacion.

package com.nexussoftware.bibliotech.servicio;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.logging.Logger;

/**
 * Almacen binario de prestamos de BiblioTech.
 *
 * Formato propio (BLIB v1):
 *   [4 bytes] numero magico 0x424C4942 = "BLIB"
 *   [4 bytes] version del formato
 *   [4 bytes] numero de registros
 *   por registro:
 *     UTF  referencia del prestamo
 *     UTF  referencia del material
 *     UTF  identificador del empleado
 *     INT  dia de inicio
 *     INT  dia de devolucion (-1 si no devuelto)
 *     DOUBLE multa acumulada
 *
 * Este formato es COMPACTO y RAPIDO, pero NO es legible ni versionable en
 * control de codigo. Para el catalogo, BiblioTech usara CSV (07-07); esto
 * queda como cache binaria interna.
 */
public class AlmacenPrestamos {

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

    /** "BLIB" en ASCII. Identifica el fichero como nuestro. */
    private static final int NUMERO_MAGICO = 0x424C4942;
    private static final int VERSION_ACTUAL = 1;

    /** Registro plano de un prestamo, tal como se guarda. */
    public record RegistroPrestamo(String referencia, String referenciaMaterial,
                                   String idEmpleado, int diaInicio,
                                   int diaDevolucion, double multa) {

        public RegistroPrestamo {
            Objects.requireNonNull(referencia, "La referencia no puede ser nula");
            Objects.requireNonNull(referenciaMaterial, "El material no puede ser nulo");
            Objects.requireNonNull(idEmpleado, "El empleado no puede ser nulo");
            if (multa < 0) {
                throw new IllegalArgumentException("La multa no puede ser negativa: " + multa);
            }
        }

        public boolean estaDevuelto() { return diaDevolucion >= 0; }
    }

    private final File fichero;

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

    // ---------------------------- ESCRITURA ----------------------------

    /**
     * Guarda todos los prestamos. Escritura ATOMICA (07-02): se escribe en
     * un temporal y solo se renombra al final.
     */
    public void guardar(List<RegistroPrestamo> prestamos) throws IOException {
        Objects.requireNonNull(prestamos, "La lista no puede ser nula");

        File temporal = new File(fichero.getAbsolutePath() + ".tmp");
        boolean completado = false;

        try {
            try (DataOutputStream salida = new DataOutputStream(
                    new BufferedOutputStream(new FileOutputStream(temporal)))) {

                // Cabecera
                salida.writeInt(NUMERO_MAGICO);
                salida.writeInt(VERSION_ACTUAL);
                salida.writeInt(prestamos.size());

                // Registros, en el MISMO orden en que se leeran
                for (RegistroPrestamo p : prestamos) {
                    salida.writeUTF(p.referencia());
                    salida.writeUTF(p.referenciaMaterial());
                    salida.writeUTF(p.idEmpleado());
                    salida.writeInt(p.diaInicio());
                    salida.writeInt(p.diaDevolucion());
                    salida.writeDouble(p.multa());
                }
            }   // close() -> flush garantizado

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

            LOG.info(() -> String.format("Guardados %d prestamos en %s (%d bytes)",
                    prestamos.size(), fichero.getName(), fichero.length()));

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

    // ---------------------------- LECTURA ----------------------------

    /**
     * Carga los prestamos guardados.
     *
     * @throws IOException si el fichero no es nuestro, la version no se
     *                     soporta o esta truncado
     */
    public List<RegistroPrestamo> cargar() throws IOException {
        if (!fichero.exists()) {
            LOG.warning(() -> "No hay almacen en " + fichero.getAbsolutePath()
                    + "; se devuelve lista vacia");
            return new ArrayList<>();               // degradacion elegante (07-01)
        }

        try (DataInputStream entrada = new DataInputStream(
                new BufferedInputStream(new FileInputStream(fichero)))) {

            // 1. VALIDAR EL NUMERO MAGICO.
            //    Sin esto, un fichero ajeno se interpretaria como nuestro y
            //    produciria datos absurdos SIN NINGUN ERROR. Es la diferencia
            //    entre fallar y corromper.
            int magico = entrada.readInt();
            if (magico != NUMERO_MAGICO) {
                throw new IOException(String.format(
                        "%s no es un almacen de BiblioTech "
                                + "(numero magico 0x%08X, se esperaba 0x%08X)",
                        fichero.getName(), magico, NUMERO_MAGICO));
            }

            // 2. VALIDAR LA VERSION
            int version = entrada.readInt();
            if (version > VERSION_ACTUAL) {
                throw new IOException(String.format(
                        "El almacen usa la version %d del formato y esta version "
                                + "de BiblioTech solo entiende hasta la %d. "
                                + "Actualiza la aplicacion.",
                        version, VERSION_ACTUAL));
            }

            // 3. Numero de registros, con cordura minima
            int cuantos = entrada.readInt();
            if (cuantos < 0) {
                throw new IOException("Numero de registros invalido: " + cuantos);
            }

            List<RegistroPrestamo> prestamos = new ArrayList<>(cuantos);

            for (int i = 0; i < cuantos; i++) {
                try {
                    prestamos.add(new RegistroPrestamo(
                            entrada.readUTF(),      // el ORDEN debe coincidir
                            entrada.readUTF(),      // exactamente con guardar()
                            entrada.readUTF(),
                            entrada.readInt(),
                            entrada.readInt(),
                            entrada.readDouble()));

                } catch (EOFException e) {
                    // Fichero TRUNCADO: se corto una escritura anterior.
                    // Se encadena la causa (06-03) y se dice cuantos habia.
                    throw new IOException(String.format(
                            "Almacen truncado: se esperaban %d registros y solo "
                                    + "hay %d completos", cuantos, i), e);
                }
            }

            LOG.info(() -> String.format("Cargados %d prestamos de %s (formato v%d)",
                    prestamos.size(), fichero.getName(), version));
            return prestamos;
        }
    }

    // ---------------------------- DEMOSTRACION ----------------------------

    public static void main(String[] args) throws IOException {
        AlmacenPrestamos almacen = new AlmacenPrestamos("datos/prestamos.blib");

        List<RegistroPrestamo> originales = List.of(
                new RegistroPrestamo("PR-0001", "978-0000000001", "E-001", 10, 22,  1.75),
                new RegistroPrestamo("PR-0002", "978-0000000002", "E-002", 12, -1,  0.00),
                new RegistroPrestamo("PR-0003", "978-0000000003", "E-003",  5, 45, 20.00));

        almacen.guardar(originales);

        System.out.println("=== RECUPERADOS ===");
        for (RegistroPrestamo p : almacen.cargar()) {
            System.out.printf("  %s  material=%s  empleado=%s  dias %d..%s  multa %.2f%n",
                    p.referencia(), p.referenciaMaterial(), p.idEmpleado(),
                    p.diaInicio(),
                    p.estaDevuelto() ? String.valueOf(p.diaDevolucion()) : "pendiente",
                    p.multa());
        }

        // --- Comprobacion del rechazo de un fichero ajeno ---
        File impostor = new File("datos/impostor.blib");
        try (DataOutputStream d = new DataOutputStream(new FileOutputStream(impostor))) {
            d.writeInt(0xDEADBEEF);      // numero magico incorrecto
            d.writeInt(1);
            d.writeInt(0);
        }

        System.out.println();
        System.out.println("=== FICHERO AJENO ===");
        try {
            new AlmacenPrestamos(impostor.getPath()).cargar();
            System.out.println("  ERROR: deberia haber sido rechazado");
        } catch (IOException e) {
            System.out.println("  Rechazado correctamente:");
            System.out.println("  " + e.getMessage());
        }
        impostor.delete();
    }
}

=== RECUPERADOS ===
  PR-0001  material=978-0000000001  empleado=E-001  dias 10..22  multa 1.75
  PR-0002  material=978-0000000002  empleado=E-002  dias 12..pendiente  multa 0.00
  PR-0003  material=978-0000000003  empleado=E-003  dias 5..45  multa 20.00

=== FICHERO AJENO ===
  Rechazado correctamente:
  impostor.blib no es un almacen de BiblioTech (numero magico 0xDEADBEEF, se esperaba 0x424C4942)