/**
 * Compta bytes de QUALSEVOL flux d'entrada.
 *
 * No sap ni li importa si ve d'un fitxer, de la xarxa, de la memoria
 * o d'un array. Aixo es exactament el que aporta l'abstraccio.
 */
public static long comptarBytes(InputStream entrada) throws IOException {
    long total = 0;
    int llegits;
    byte[] bloc = new byte[8192];
    while ((llegits = entrada.read(bloc)) != -1) {
        total += llegits;
    }
    return total;
}

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

// OutputStream
public abstract void write(int b) throws IOException;     // el byte menys significatiu
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();

// NODE: rep un recurs (un cami, un File, un array)
new FileInputStream("cataleg.txt")
new ByteArrayInputStream(dades)

// FILTRE: rep UN ALTRE FLUX
new BufferedInputStream(altreFlux)
new DataInputStream(altreFlux)
new PrintWriter(altreWriter)

new DataInputStream(          // filtre: afegeix readInt, readDouble...
    new BufferedInputStream(  // filtre: afegeix memoria intermedia
        new FileInputStream(  // NODE: connecta amb el fitxer
            "dades/prestecs.bin")))

// CORRECTE: la memoria intermedia esta entre el fitxer i els tipus
new DataInputStream(new BufferedInputStream(new FileInputStream(f)))

// INUTIL: la memoria intermedia esta fora. DataInputStream llegeix directe del
// fitxer, 4 bytes cada vegada, amb una crida al sistema per cadascun.
new BufferedInputStream(new DataInputStream(new FileInputStream(f)))

// N'hi ha prou amb aixo: el close() de PrintWriter tanca BufferedWriter,
// que tanca FileWriter, que tanca el fitxer.
try (PrintWriter sortida = new PrintWriter(
        new BufferedWriter(
            new FileWriter("informe.txt", StandardCharsets.UTF_8)))) {
    sortida.println("...");
}

try (FileWriter fw = new FileWriter("informe.txt", StandardCharsets.UTF_8);
     BufferedWriter bw = new BufferedWriter(fw);
     PrintWriter sortida = new PrintWriter(bw)) {
    sortida.println("...");
}
// Cada recurs declarat per separat: tots es tanquen, en ordre invers (06-06)

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

public class UsDelPont {

    /** Lectura de text amb la cadena completa, explicita. */
    public static void llegir(String cami) throws IOException {
        try (BufferedReader lector = new BufferedReader(       // 3. memoria i readLine
                new InputStreamReader(                          // 2. PONT: aqui el charset
                        new FileInputStream(cami),              // 1. NODE: bytes del fitxer
                        StandardCharsets.UTF_8))) {

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

    /** Escriptura simetrica. */
    public static void escriure(String cami, String text) throws IOException {
        try (BufferedWriter escriptor = new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream(cami),
                        StandardCharsets.UTF_8))) {
            escriptor.write(text);
        }
    }
}

// Aquestes dues linies son practicament el mateix:
new FileReader(cami, StandardCharsets.UTF_8)
new InputStreamReader(new FileInputStream(cami), StandardCharsets.UTF_8)

// I aquestes dues tambe:
new FileWriter(cami, StandardCharsets.UTF_8)
new OutputStreamWriter(new FileOutputStream(cami), StandardCharsets.UTF_8)

// Llegir text de l'ENTRADA ESTANDARD: no hi ha cap "FileReader de System.in"
new InputStreamReader(System.in, StandardCharsets.UTF_8)

// Llegir text d'una connexio de xarxa (modul 9)
new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)

// Llegir text d'un recurs dins 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("Prestec vençut");       // charset controlat

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

public class LecturaBinariaSimple {

    /** Mostra els primers bytes d'un fitxer en hexadecimal. */
    public static void bolcarCapcalera(String cami, int quants) throws IOException {
        try (FileInputStream entrada = new FileInputStream(cami)) {

            for (int i = 0; i < quants; i++) {
                int b = entrada.read();          // 0..255, o -1 al final
                if (b == -1) {
                    System.out.println("\n(final del fitxer)");
                    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 {
        bolcarCapcalera("portades/java-eficac.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;                    // aixi ho guarda un byte[]
int senseSigne = b & 0xFF;       // 200: el valor real
System.out.printf("%02X%n", senseSigne);   // C8

try (FileOutputStream sortida = new FileOutputStream("prova.bin")) {
    sortida.write(255);    // escriu el byte 0xFF
    sortida.write(65);     // escriu el byte 0x41, que es la 'A' en ASCII
    sortida.write(300);    // escriu 0x2C: es queda amb els 8 bits BAIXOS, sense avisar
}

new FileOutputStream("dades.bin");         // SOBREESCRIU, trunca a zero
new FileOutputStream("dades.bin", true);   // AFEGEIX al final

public int read(byte[] buffer) throws IOException

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

public class LecturaPerBlocs {

    private static final int MIDA_BLOC = 8192;

    public static long comptarBytes(String cami) throws IOException {
        long total = 0;

        try (FileInputStream entrada = new FileInputStream(cami)) {
            byte[] bloc = new byte[MIDA_BLOC];
            int llegits;

            // 'llegits' es QUANTS bytes hi ha de veritat a l'array.
            // Nomes els primers 'llegits' son dades noves; la resta es
            // brossa de la iteracio anterior.
            while ((llegits = entrada.read(bloc)) != -1) {
                total += llegits;
                processar(bloc, llegits);          // SEMPRE amb el limit
            }
        }
        return total;
    }

    private static void processar(byte[] bloc, int quants) {
        for (int i = 0; i < quants; i++) {         // fins a 'quants', no fins a length
            // ...
        }
    }
}

// MALAMENT: copia SEMPRE l'array sencer
while ((llegits = entrada.read(bloc)) != -1) {
    sortida.write(bloc);                      // <-- hauria de ser write(bloc, 0, llegits)
}

// Java 9+: llegeix EXACTAMENT n bytes o llanca EOFException
byte[] capcalera = entrada.readNBytes(16);

// Java 9+: llegeix TOT el que queda. Compte amb fitxers grans (07-01)
byte[] tot = entrada.readAllBytes();

package com.nexussoftware.bibliotech.servei;

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;

/**
 * Gestio de les imatges de portada del cataleg de BiblioTech.
 *
 * Les portades son JPEG o PNG: dades BINARIES. Fer servir Reader/Writer sobre
 * elles les destruiria, perque el descodificador de caracters substitueix
 * els bytes que no formen sequencies valides.
 */
public class GestorPortades {

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

    private static final int MIDA_BLOC = 8192;
    private static final long MIDA_MAXIMA = 5 * 1024 * 1024;     // 5 MB

    private final File directori;

    public GestorPortades(String directoriPortades) {
        this.directori = new File(directoriPortades);
        if (!directori.exists() && !directori.mkdirs()) {
            LOG.warning("No s'ha pogut crear " + directori.getAbsolutePath());
        }
    }

    /**
     * Copia la portada d'un llibre al magatzem, anomenant-la pel seu ISBN.
     *
     * @return bytes copiats
     * @throws IOException si falla la copia
     */
    public long importarPortada(String isbn, File origen) throws IOException {
        if (!origen.isFile()) {
            throw new IOException("No es un fitxer llegible: " + origen.getAbsolutePath());
        }
        if (origen.length() > MIDA_MAXIMA) {
            throw new IOException("La portada supera el maxim de "
                    + (MIDA_MAXIMA / 1024) + " KB: " + origen.length() + " bytes");
        }

        File desti = new File(directori, isbn + extensio(origen.getName()));
        long copiats = copiar(origen, desti);

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

    /**
     * Copia binaria byte a byte, amb memoria intermedia als dos extrems.
     *
     * La cadena de decoradors:
     *   FileInputStream  -> NODE: llegeix del fitxer
     *   BufferedInputStream -> FILTRE: agrupa les lectures
     *   (i el mateix al costat d'escriptura)
     */
    public long copiar(File origen, File desti) throws IOException {
        long total = 0;

        try (BufferedInputStream entrada =
                     new BufferedInputStream(new FileInputStream(origen), MIDA_BLOC);
             BufferedOutputStream sortida =
                     new BufferedOutputStream(new FileOutputStream(desti), MIDA_BLOC)) {

            byte[] bloc = new byte[MIDA_BLOC];
            int llegits;

            while ((llegits = entrada.read(bloc)) != -1) {
                // CLAU: (bloc, 0, llegits), MAI (bloc) a seques.
                // Amb (bloc) es copiaria brossa al final i la imatge no obriria.
                sortida.write(bloc, 0, llegits);
                total += llegits;
            }
            // El close() del try-with-resources fa flush: sense ell, els ultims
            // bytes de la memoria intermedia no arribarien al fitxer (07-02).
        }
        return total;
    }

    /** Detecta el format llegint la SIGNATURA del fitxer, no la seva extensio. */
    public String detectarFormat(File fitxer) throws IOException {
        try (FileInputStream entrada = new FileInputStream(fitxer)) {
            byte[] sign = entrada.readNBytes(8);       // Java 9+

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

    private String extensio(String nom) {
        int punt = nom.lastIndexOf('.');
        return (punt > 0) ? nom.substring(punt).toLowerCase() : ".bin";
    }
}

import java.io.*;

public class DadesBinaries {

    public static void escriure(String cami) throws IOException {
        try (DataOutputStream sortida = new DataOutputStream(
                new BufferedOutputStream(new FileOutputStream(cami)))) {

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

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

            // L'ORDRE de lectura ha de ser EXACTAMENT el d'escriptura.
            // El fitxer no porta cap descripcio del seu contingut.
            String referencia = entrada.readUTF();
            int    dies       = entrada.readInt();
            double tarifa     = entrada.readDouble();
            boolean retornat  = entrada.readBoolean();
            long   marca      = entrada.readLong();

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

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

public class FluxosEnMemoria {

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

        try (DataOutputStream sortida = new DataOutputStream(memoria)) {
            sortida.writeUTF("PR-0001");
            sortida.writeInt(15);
            sortida.writeDouble(0.25);
        }
        // toByteArray() retorna una COPIA del que s'ha acumulat
        return memoria.toByteArray();
    }

    /** ByteArrayInputStream: llegeix d'un array com si fos un fitxer. */
    public static void llegirDeMemoria(byte[] dades) throws IOException {
        try (DataInputStream entrada = new DataInputStream(
                new ByteArrayInputStream(dades))) {

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

    public static void main(String[] args) throws IOException {
        byte[] dades = generarEnMemoria();
        System.out.println("Generats " + dades.length + " bytes sense tocar el disc");
        llegirDeMemoria(dades);
    }
}

/**
 * Metode de produccio: rep un InputStream, no un cami.
 * Aquesta decisio de disseny es el que el fa provable sense fitxers.
 */
public int comptarLinies(InputStream entrada) throws IOException {
    int linies = 0;
    try (BufferedReader lector = new BufferedReader(
            new InputStreamReader(entrada, StandardCharsets.UTF_8))) {
        while (lector.readLine() != null) {
            linies++;
        }
    }
    return linies;
}

// PROVA: sense fitxer, sense disc, sense neteja, sense dependencies de l'entorn
public void provaComptarLinies() {
    String contingut = "LLIBRE;978-0000000001;Java Eficac\n"
                     + "LLIBRE;978-0000000002;Patrons de Disseny\n";

    InputStream simulat =
            new ByteArrayInputStream(contingut.getBytes(StandardCharsets.UTF_8));

    int resultat = comptarLinies(simulat);
    // se n'esperen 2
}

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

public long transferTo(OutputStream desti) throws IOException

import java.io.*;

public class CopiaModerna {

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

            return entrada.transferTo(sortida);     // tot el bucle, en una linia
        }
    }
}

/** Copia informant del progres: aqui el bucle continua sent necessari. */
public long copiarAmbProgres(File origen, File desti) throws IOException {
    long mida = origen.length();
    long copiats = 0;
    int ultimPercentatge = -1;

    try (InputStream entrada = new BufferedInputStream(new FileInputStream(origen));
         OutputStream sortida = new BufferedOutputStream(new FileOutputStream(desti))) {

        byte[] bloc = new byte[8192];
        int llegits;
        while ((llegits = entrada.read(bloc)) != -1) {
            sortida.write(bloc, 0, llegits);
            copiats += llegits;

            int percentatge = (int) (copiats * 100 / Math.max(1, mida));
            if (percentatge != ultimPercentatge && percentatge % 10 == 0) {
                System.out.printf("  %d%% (%d de %d bytes)%n", percentatge, copiats, mida);
                ultimPercentatge = percentatge;
            }
        }
    }
    return copiats;
}

Files.copy(origen, desti, 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 fitxers, en el format classic de tres columnes.
 *
 * Treballa amb FLUXOS DE BYTES perque el contingut pot ser qualsevol cosa:
 * fer servir un Reader corrompria les dades abans de poder mostrar-les.
 */
public class VisorHexadecimal {

    private static final int BYTES_PER_LINIA = 16;
    private static final int PRIMER_IMPRIMIBLE = 32;
    private static final int ULTIM_IMPRIMIBLE = 126;

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

            byte[] linia = new byte[BYTES_PER_LINIA];
            int desplacament = 0;
            int llegits;

            // readNBytes (Java 9+) insisteix fins a omplir l'array o arribar al
            // final. Amb read() a seques podriem rebre menys de 16 bytes
            // enmig del fitxer i el bolcat quedaria desalineat.
            while (desplacament < maxBytes
                    && (llegits = entrada.readNBytes(linia, 0, BYTES_PER_LINIA)) > 0) {

                imprimirLinia(desplacament, linia, llegits);
                desplacament += llegits;
            }
        }
    }

    private static void imprimirLinia(int desplacament, byte[] dades, int quants) {
        StringBuilder hex   = new StringBuilder();
        StringBuilder ascii = new StringBuilder();

        for (int i = 0; i < BYTES_PER_LINIA; i++) {
            if (i == 8) {
                hex.append(' ');                    // separacio dels dos grups
            }
            if (i < quants) {
                // & 0xFF: sense aixo, un byte negatiu s'imprimiria com FFFFFFxx
                int b = dades[i] & 0xFF;
                hex.append(String.format("%02X ", b));
                ascii.append(esImprimible(b) ? (char) b : '.');
            } else {
                hex.append("   ");                  // farciment de l'ultima linia
                ascii.append(' ');
            }
        }

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

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

    /** Detecta el format per la seva SIGNATURA. L'extensio no es fiable. */
    public static String detectarFormat(String cami) throws IOException {
        try (InputStream entrada = new BufferedInputStream(new FileInputStream(cami))) {
            byte[] f = entrada.readNBytes(8);

            if (comenca(f, 0xFF, 0xD8, 0xFF))                 { return "JPEG"; }
            if (comenca(f, 0x89, 0x50, 0x4E, 0x47))           { return "PNG"; }
            if (comenca(f, 0x47, 0x49, 0x46, 0x38))           { return "GIF"; }
            if (comenca(f, 0x25, 0x50, 0x44, 0x46))           { return "PDF"; }
            if (comenca(f, 0x50, 0x4B, 0x03, 0x04))           { return "ZIP (o JAR, DOCX...)"; }
            if (comenca(f, 0xCA, 0xFE, 0xBA, 0xBE))           { return "CLASSE DE JAVA"; }
            if (comenca(f, 0xAC, 0xED))                       { return "OBJECTE SERIALITZAT (07-05)"; }
            return "DESCONEGUT (possiblement text)";
        }
    }

    /** Compara els primers bytes amb la signatura donada. */
    private static boolean comenca(byte[] dades, int... signatura) {
        if (dades.length < signatura.length) {
            return false;
        }
        for (int i = 0; i < signatura.length; i++) {
            if ((dades[i] & 0xFF) != signatura[i]) {  // el & 0xFF, un altre cop imprescindible
                return false;
            }
        }
        return true;
    }

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

        System.out.println("Fitxer : " + cami);
        System.out.println("Format : " + detectarFormat(cami));
        System.out.println();
        bolcar(cami, 64);
    }
}

Fitxer : portades/java-eficac.jpg
Format : 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 cinc tecniques de copia binaria.
 *
 * AVIS: aixo NO es un banc de proves rigoros. La memoria cau de pagina del
 * sistema operatiu, el compilador JIT i el recollector de brossa distorsionen
 * les mesures; la primera execucio sempre surt pitjor. Serveix per veure els
 * ORDRES DE MAGNITUD, que es el que importa aqui. Per mesurar de debo es
 * fa servir JMH, que s'esmenta a 10-07.
 */
public class ComparadorRendiment {

    private static final String ORIGEN = "prova-rendiment.bin";
    private static final String DESTI  = "copia-rendiment.bin";
    private static final int MIDA_MB   = 5;

    // ---------- Les cinc tecniques ----------

    /** 1. Byte a byte SENSE memoria intermedia: una crida al sistema per byte. */
    static long byteAByteSenseBuffer(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 AMB memoria intermedia: absorbeix les crides al sistema. */
    static long byteAByteAmbBuffer(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 i 4. Per blocs de la mida indicada. */
    static long perBlocs(File o, File d, int mida) throws IOException {
        try (InputStream in = new FileInputStream(o);
             OutputStream out = new FileOutputStream(d)) {
            byte[] bloc = new byte[mida];
            int llegits;
            long n = 0;
            while ((llegits = in.read(bloc)) != -1) {
                out.write(bloc, 0, llegits);     // el limit, SEMPRE
                n += llegits;
            }
            return n;
        }
    }

    /** 5. transferTo (Java 9+). */
    static long ambTransferTo(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 mesura ----------

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

    static void generarFitxerProva(File f, int megues) throws IOException {
        if (f.exists() && f.length() == megues * 1024L * 1024L) {
            return;                                // ja esta generat
        }
        Random aleatori = new Random(42);           // llavor fixa: reproduible
        byte[] bloc = new byte[1024 * 1024];

        try (OutputStream out = new BufferedOutputStream(new FileOutputStream(f))) {
            for (int i = 0; i < megues; i++) {
                aleatori.nextBytes(bloc);
                out.write(bloc);
            }
        }
    }

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

        System.out.println("Generant fitxer de prova de " + MIDA_MB + " MB...");
        generarFitxerProva(origen, MIDA_MB);
        System.out.println("Mida: " + origen.length() + " bytes");
        System.out.println();

        String[] noms = {
                "1. Byte a byte SENSE buffer",
                "2. Byte a byte AMB buffer",
                "3. Blocs de 512 B",
                "4. Blocs de 8 KB",
                "5. transferTo"
        };
        Tecnica[] tecniques = {
                ComparadorRendiment::byteAByteSenseBuffer,      // referencies a metode (04-06)
                ComparadorRendiment::byteAByteAmbBuffer,
                (o, d) -> perBlocs(o, d, 512),
                (o, d) -> perBlocs(o, d, 8192),
                ComparadorRendiment::ambTransferTo
        };

        long referencia = 0;

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

        for (int i = 0; i < tecniques.length; i++) {
            long inici = System.nanoTime();
            long copiats = tecniques[i].copiar(origen, desti);
            long ms = (System.nanoTime() - inici) / 1_000_000;

            // VERIFICACIO: una copia rapida pero incorrecta no val res
            if (copiats != origen.length() || desti.length() != origen.length()) {
                System.out.printf("%-28s  COPIA INCORRECTA: %d bytes%n",
                        noms[i], desti.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",
                    noms[i], ms, mbs, (double) referencia / Math.max(1, ms));
        }

        System.out.println();
        System.out.println("El salt gran esta entre 1 i 2, i la causa es una de sola:");
        System.out.println("sense memoria intermedia hi ha UNA CRIDA AL SISTEMA PER BYTE");
        System.out.println("(5 milions); amb memoria intermedia, una cada 8192 bytes (unes");
        System.out.println("640). La resta de millores son marginals en comparacio.");

        desti.delete();
    }
}

Generant fitxer de prova de 5 MB...
Mida: 5242880 bytes

TECNICA                           TEMPS       MB/s      MILLORA
----------------------------------------------------------------
1. Byte a byte SENSE buffer      4680 ms        1.1         1.0x
2. Byte a byte AMB buffer          78 ms       64.2        60.0x
3. Blocs de 512 B                  26 ms      192.5       180.0x
4. Blocs de 8 KB                    9 ms      555.6       520.0x
5. transferTo                       7 ms      714.3       668.7x

El salt gran esta entre 1 i 2, i la causa es una de sola:
sense memoria intermedia hi ha UNA CRIDA AL SISTEMA PER BYTE
(5 milions); amb memoria intermedia, una cada 8192 bytes (unes
640). La resta de millores son marginals en comparacio.

package com.nexussoftware.bibliotech.servei;

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

/**
 * Magatzem binari de prestecs de BiblioTech.
 *
 * Format propi (BLIB v1):
 *   [4 bytes] nombre magic 0x424C4942 = "BLIB"
 *   [4 bytes] versio del format
 *   [4 bytes] nombre de registres
 *   per registre:
 *     UTF  referencia del prestec
 *     UTF  referencia del material
 *     UTF  identificador de l'empleat
 *     INT  dia d'inici
 *     INT  dia de devolucio (-1 si no s'ha retornat)
 *     DOUBLE multa acumulada
 *
 * Aquest format es COMPACTE i RAPID, pero NO es llegible ni versionable en
 * control de codi. Per al cataleg, BiblioTech fara servir CSV (07-07); aixo
 * queda com a memoria cau binaria interna.
 */
public class MagatzemPrestecs {

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

    /** "BLIB" en ASCII. Identifica el fitxer com a nostre. */
    private static final int NUMERO_MAGIC = 0x424C4942;
    private static final int VERSIO_ACTUAL = 1;

    /** Registre pla d'un prestec, tal com es desa. */
    public record RegistrePrestec(String referencia, String referenciaMaterial,
                                  String idEmpleat, int diaInici,
                                  int diaDevolucio, double multa) {

        public RegistrePrestec {
            Objects.requireNonNull(referencia, "La referencia no pot ser nulla");
            Objects.requireNonNull(referenciaMaterial, "El material no pot ser nul");
            Objects.requireNonNull(idEmpleat, "L'empleat no pot ser nul");
            if (multa < 0) {
                throw new IllegalArgumentException("La multa no pot ser negativa: " + multa);
            }
        }

        public boolean estaRetornat() { return diaDevolucio >= 0; }
    }

    private final File fitxer;

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

    // ---------------------------- ESCRIPTURA ----------------------------

    /**
     * Desa tots els prestecs. Escriptura ATOMICA (07-02): s'escriu en
     * un temporal i nomes es reanomena al final.
     */
    public void desar(List<RegistrePrestec> prestecs) throws IOException {
        Objects.requireNonNull(prestecs, "La llista no pot ser nulla");

        File temporal = new File(fitxer.getAbsolutePath() + ".tmp");
        boolean completat = false;

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

                // Capcalera
                sortida.writeInt(NUMERO_MAGIC);
                sortida.writeInt(VERSIO_ACTUAL);
                sortida.writeInt(prestecs.size());

                // Registres, en el MATEIX ordre en que es llegiran
                for (RegistrePrestec p : prestecs) {
                    sortida.writeUTF(p.referencia());
                    sortida.writeUTF(p.referenciaMaterial());
                    sortida.writeUTF(p.idEmpleat());
                    sortida.writeInt(p.diaInici());
                    sortida.writeInt(p.diaDevolucio());
                    sortida.writeDouble(p.multa());
                }
            }   // close() -> flush garantit

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

            LOG.info(() -> String.format("Desats %d prestecs a %s (%d bytes)",
                    prestecs.size(), fitxer.getName(), fitxer.length()));

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

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

    /**
     * Carrega els prestecs desats.
     *
     * @throws IOException si el fitxer no es nostre, la versio no se
     *                     suporta o esta truncat
     */
    public List<RegistrePrestec> carregar() throws IOException {
        if (!fitxer.exists()) {
            LOG.warning(() -> "No hi ha magatzem a " + fitxer.getAbsolutePath()
                    + "; es retorna una llista buida");
            return new ArrayList<>();               // degradacio elegant (07-01)
        }

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

            // 1. VALIDAR EL NOMBRE MAGIC.
            //    Sense aixo, un fitxer alie s'interpretaria com a nostre i
            //    produiria dades absurdes SENSE CAP ERROR. Es la diferencia
            //    entre fallar i corrompre.
            int magic = entrada.readInt();
            if (magic != NUMERO_MAGIC) {
                throw new IOException(String.format(
                        "%s no es un magatzem de BiblioTech "
                                + "(nombre magic 0x%08X, s'esperava 0x%08X)",
                        fitxer.getName(), magic, NUMERO_MAGIC));
            }

            // 2. VALIDAR LA VERSIO
            int versio = entrada.readInt();
            if (versio > VERSIO_ACTUAL) {
                throw new IOException(String.format(
                        "El magatzem fa servir la versio %d del format i aquesta versio "
                                + "de BiblioTech nomes enten fins a la %d. "
                                + "Actualitza l'aplicacio.",
                        versio, VERSIO_ACTUAL));
            }

            // 3. Nombre de registres, amb un minim de seny
            int quants = entrada.readInt();
            if (quants < 0) {
                throw new IOException("Nombre de registres invalid: " + quants);
            }

            List<RegistrePrestec> prestecs = new ArrayList<>(quants);

            for (int i = 0; i < quants; i++) {
                try {
                    prestecs.add(new RegistrePrestec(
                            entrada.readUTF(),      // l'ORDRE ha de coincidir
                            entrada.readUTF(),      // exactament amb desar()
                            entrada.readUTF(),
                            entrada.readInt(),
                            entrada.readInt(),
                            entrada.readDouble()));

                } catch (EOFException e) {
                    // Fitxer TRUNCAT: es va tallar una escriptura anterior.
                    // S'encadena la causa (06-03) i es diu quants n'hi havia.
                    throw new IOException(String.format(
                            "Magatzem truncat: s'esperaven %d registres i nomes "
                                    + "n'hi ha %d de complets", quants, i), e);
                }
            }

            LOG.info(() -> String.format("Carregats %d prestecs de %s (format v%d)",
                    prestecs.size(), fitxer.getName(), versio));
            return prestecs;
        }
    }

    // ---------------------------- DEMOSTRACIO ----------------------------

    public static void main(String[] args) throws IOException {
        MagatzemPrestecs magatzem = new MagatzemPrestecs("dades/prestecs.blib");

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

        magatzem.desar(originals);

        System.out.println("=== RECUPERATS ===");
        for (RegistrePrestec p : magatzem.carregar()) {
            System.out.printf("  %s  material=%s  empleat=%s  dies %d..%s  multa %.2f%n",
                    p.referencia(), p.referenciaMaterial(), p.idEmpleat(),
                    p.diaInici(),
                    p.estaRetornat() ? String.valueOf(p.diaDevolucio()) : "pendent",
                    p.multa());
        }

        // --- Comprovacio del rebuig d'un fitxer alie ---
        File impostor = new File("dades/impostor.blib");
        try (DataOutputStream d = new DataOutputStream(new FileOutputStream(impostor))) {
            d.writeInt(0xDEADBEEF);      // nombre magic incorrecte
            d.writeInt(1);
            d.writeInt(0);
        }

        System.out.println();
        System.out.println("=== FITXER ALIE ===");
        try {
            new MagatzemPrestecs(impostor.getPath()).carregar();
            System.out.println("  ERROR: hauria d'haver estat rebutjat");
        } catch (IOException e) {
            System.out.println("  Rebutjat correctament:");
            System.out.println("  " + e.getMessage());
        }
        impostor.delete();
    }
}

=== RECUPERATS ===
  PR-0001  material=978-0000000001  empleat=E-001  dies 10..22  multa 1.75
  PR-0002  material=978-0000000002  empleat=E-002  dies 12..pendent  multa 0.00
  PR-0003  material=978-0000000003  empleat=E-003  dies 5..45  multa 20.00

=== FITXER ALIE ===
  Rebutjat correctament:
  impostor.blib no es un magatzem de BiblioTech (nombre magic 0xDEADBEEF, s'esperava 0x424C4942)