/**
 * Counts the bytes of ANY input stream.
 *
 * It neither knows nor cares whether it comes from a file, the network,
 * memory or an array. That is exactly what the abstraction contributes.
 */
public static long countBytes(InputStream input) throws IOException {
    long total = 0;
    int read;
    byte[] block = new byte[8192];
    while ((read = input.read(block)) != -1) {
        total += read;
    }
    return total;
}

// InputStream
public abstract int read() throws IOException;            // 0..255, or -1 at the end
public int read(byte[] b) throws IOException;             // how many it read, or -1
public int read(byte[] b, int off, int len);
public void close() throws IOException;
public long transferTo(OutputStream target);              // Java 9

// OutputStream
public abstract void write(int b) throws IOException;     // the least significant byte
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, or -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: it receives a resource (a path, a File, an array)
new FileInputStream("catalog.txt")
new ByteArrayInputStream(data)

// FILTER: it receives ANOTHER STREAM
new BufferedInputStream(anotherStream)
new DataInputStream(anotherStream)
new PrintWriter(anotherWriter)

new DataInputStream(          // filter: adds readInt, readDouble...
    new BufferedInputStream(  // filter: adds a buffer
        new FileInputStream(  // NODE: connects to the file
            "data/loans.bin")))

// CORRECT: the buffer sits between the file and the types
new DataInputStream(new BufferedInputStream(new FileInputStream(f)))

// USELESS: the buffer is on the outside. DataInputStream reads straight from
// the file, 4 bytes at a time, with one system call for each.
new BufferedInputStream(new DataInputStream(new FileInputStream(f)))

// This is enough: PrintWriter's close() closes BufferedWriter,
// which closes FileWriter, which closes the file.
try (PrintWriter output = new PrintWriter(
        new BufferedWriter(
            new FileWriter("report.txt", StandardCharsets.UTF_8)))) {
    output.println("...");
}

try (FileWriter fw = new FileWriter("report.txt", StandardCharsets.UTF_8);
     BufferedWriter bw = new BufferedWriter(fw);
     PrintWriter output = new PrintWriter(bw)) {
    output.println("...");
}
// Each resource declared separately: all are closed, in reverse order (06-06)

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

public class BridgeUsage {

    /** Reading text with the complete, explicit chain. */
    public static void read(String path) throws IOException {
        try (BufferedReader reader = new BufferedReader(       // 3. buffer and readLine
                new InputStreamReader(                          // 2. BRIDGE: the charset goes here
                        new FileInputStream(path),              // 1. NODE: bytes from the file
                        StandardCharsets.UTF_8))) {

            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }

    /** Symmetrical writing. */
    public static void write(String path, String text) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream(path),
                        StandardCharsets.UTF_8))) {
            writer.write(text);
        }
    }
}

// These two lines are practically the same thing:
new FileReader(path, StandardCharsets.UTF_8)
new InputStreamReader(new FileInputStream(path), StandardCharsets.UTF_8)

// And so are these two:
new FileWriter(path, StandardCharsets.UTF_8)
new OutputStreamWriter(new FileOutputStream(path), StandardCharsets.UTF_8)

// Reading text from STANDARD INPUT: there is no "FileReader for System.in"
new InputStreamReader(System.in, StandardCharsets.UTF_8)

// Reading text from a network connection (module 9)
new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)

// Reading text from a resource inside the .jar
new InputStreamReader(getClass().getResourceAsStream("/config.txt"),
                      StandardCharsets.UTF_8)

PrintWriter console = new PrintWriter(
        new OutputStreamWriter(System.out, StandardCharsets.UTF_8), true);
console.println("Café Society");         // controlled charset

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

public class SimpleBinaryReading {

    /** Shows the first bytes of a file in hexadecimal. */
    public static void dumpHeader(String path, int howMany) throws IOException {
        try (FileInputStream input = new FileInputStream(path)) {

            for (int i = 0; i < howMany; i++) {
                int b = input.read();            // 0..255, or -1 at the end
                if (b == -1) {
                    System.out.println("\n(end of file)");
                    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 {
        dumpHeader("covers/effective-java.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;                    // this is how a byte[] stores it
int unsigned = b & 0xFF;         // 200: the real value
System.out.printf("%02X%n", unsigned);   // C8

try (FileOutputStream output = new FileOutputStream("test.bin")) {
    output.write(255);     // writes the byte 0xFF
    output.write(65);      // writes the byte 0x41, which is 'A' in ASCII
    output.write(300);     // writes 0x2C: it keeps the LOW 8 bits, without warning
}

new FileOutputStream("data.bin");         // OVERWRITES, truncates to zero
new FileOutputStream("data.bin", true);   // APPENDS at the end

public int read(byte[] buffer) throws IOException

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

public class BlockReading {

    private static final int BLOCK_SIZE = 8192;

    public static long countBytes(String path) throws IOException {
        long total = 0;

        try (FileInputStream input = new FileInputStream(path)) {
            byte[] block = new byte[BLOCK_SIZE];
            int read;

            // 'read' is HOW MANY bytes there really are in the array.
            // Only the first 'read' are new data; the rest is rubbish
            // from the previous iteration.
            while ((read = input.read(block)) != -1) {
                total += read;
                process(block, read);              // ALWAYS with the limit
            }
        }
        return total;
    }

    private static void process(byte[] block, int howMany) {
        for (int i = 0; i < howMany; i++) {        // up to 'howMany', not up to length
            // ...
        }
    }
}

// WRONG: it ALWAYS copies the whole array
while ((read = input.read(block)) != -1) {
    output.write(block);                      // <-- should be write(block, 0, read)
}

// Java 9+: reads EXACTLY n bytes or throws EOFException
byte[] header = input.readNBytes(16);

// Java 9+: reads EVERYTHING that is left. Careful with large files (07-01)
byte[] everything = input.readAllBytes();

package com.nexussoftware.bibliotech.service;

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;

/**
 * Management of the cover images of the BiblioTech catalogue.
 *
 * Covers are JPEG or PNG: BINARY data. Using Reader/Writer on them would
 * destroy them, because the character decoder replaces the bytes that do
 * not form valid sequences.
 */
public class CoverManager {

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

    private static final int BLOCK_SIZE = 8192;
    private static final long MAX_SIZE = 5 * 1024 * 1024;        // 5 MB

    private final File directory;

    public CoverManager(String coverDirectory) {
        this.directory = new File(coverDirectory);
        if (!directory.exists() && !directory.mkdirs()) {
            LOG.warning("Could not create " + directory.getAbsolutePath());
        }
    }

    /**
     * Copies a book cover into the store, naming it after its ISBN.
     *
     * @return bytes copied
     * @throws IOException if the copy fails
     */
    public long importCover(String isbn, File source) throws IOException {
        if (!source.isFile()) {
            throw new IOException("Not a readable file: " + source.getAbsolutePath());
        }
        if (source.length() > MAX_SIZE) {
            throw new IOException("The cover exceeds the maximum of "
                    + (MAX_SIZE / 1024) + " KB: " + source.length() + " bytes");
        }

        File target = new File(directory, isbn + extension(source.getName()));
        long copied = copy(source, target);

        LOG.info(() -> String.format("Cover of %s imported: %d bytes into %s",
                isbn, copied, target.getName()));
        return copied;
    }

    /**
     * Binary copy byte by byte, with a buffer at both ends.
     *
     * The decorator chain:
     *   FileInputStream  -> NODE: reads from the file
     *   BufferedInputStream -> FILTER: groups the reads
     *   (and the same on the writing side)
     */
    public long copy(File source, File target) throws IOException {
        long total = 0;

        try (BufferedInputStream input =
                     new BufferedInputStream(new FileInputStream(source), BLOCK_SIZE);
             BufferedOutputStream output =
                     new BufferedOutputStream(new FileOutputStream(target), BLOCK_SIZE)) {

            byte[] block = new byte[BLOCK_SIZE];
            int read;

            while ((read = input.read(block)) != -1) {
                // KEY: (block, 0, read), NEVER plain (block).
                // With (block) rubbish would be copied at the end and the image would not open.
                output.write(block, 0, read);
                total += read;
            }
            // try-with-resources' close() flushes: without it, the last bytes
            // of the buffer would never reach the file (07-02).
        }
        return total;
    }

    /** Detects the format by reading the file SIGNATURE, not its extension. */
    public String detectFormat(File file) throws IOException {
        try (FileInputStream input = new FileInputStream(file)) {
            byte[] signature = input.readNBytes(8);    // Java 9+

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

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

import java.io.*;

public class BinaryData {

    public static void write(String path) throws IOException {
        try (DataOutputStream output = new DataOutputStream(
                new BufferedOutputStream(new FileOutputStream(path)))) {

            output.writeUTF("LN-0001");        // string: 2 length bytes + modified UTF-8
            output.writeInt(15);               // 4 bytes
            output.writeDouble(0.25);          // 8 bytes
            output.writeBoolean(true);         // 1 byte
            output.writeLong(1_700_000_000L);  // 8 bytes
        }
    }

    public static void read(String path) throws IOException {
        try (DataInputStream input = new DataInputStream(
                new BufferedInputStream(new FileInputStream(path)))) {

            // The reading ORDER must be EXACTLY the writing one.
            // The file carries no description whatsoever of its content.
            String reference = input.readUTF();
            int    days      = input.readInt();
            double rate      = input.readDouble();
            boolean returned = input.readBoolean();
            long   timestamp = input.readLong();

            System.out.printf("%s: %d days, %.2f EUR/day, returned=%b, timestamp=%d%n",
                    reference, days, rate, returned, timestamp);
        }
    }
}

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

public class InMemoryStreams {

    /** ByteArrayOutputStream: accumulates in memory whatever is written to it. */
    public static byte[] generateInMemory() throws IOException {
        ByteArrayOutputStream memory = new ByteArrayOutputStream();

        try (DataOutputStream output = new DataOutputStream(memory)) {
            output.writeUTF("LN-0001");
            output.writeInt(15);
            output.writeDouble(0.25);
        }
        // toByteArray() returns a COPY of what has been accumulated
        return memory.toByteArray();
    }

    /** ByteArrayInputStream: reads from an array as if it were a file. */
    public static void readFromMemory(byte[] data) throws IOException {
        try (DataInputStream input = new DataInputStream(
                new ByteArrayInputStream(data))) {

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

    public static void main(String[] args) throws IOException {
        byte[] data = generateInMemory();
        System.out.println("Generated " + data.length + " bytes without touching the disk");
        readFromMemory(data);
    }
}

/**
 * Production method: it receives an InputStream, not a path.
 * That design decision is what makes it testable without files.
 */
public int countLines(InputStream input) throws IOException {
    int lines = 0;
    try (BufferedReader reader = new BufferedReader(
            new InputStreamReader(input, StandardCharsets.UTF_8))) {
        while (reader.readLine() != null) {
            lines++;
        }
    }
    return lines;
}

// TEST: no file, no disk, no cleanup, no dependency on the environment
public void testCountLines() {
    String content = "BOOK;978-0000000001;Effective Java\n"
                   + "BOOK;978-0000000002;Design Patterns\n";

    InputStream simulated =
            new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));

    int result = countLines(simulated);
    // 2 is expected
}

StringWriter memory = new StringWriter();
try (PrintWriter output = new PrintWriter(memory)) {
    output.printf("%-25s %8.2f%n", "Effective Java", 3.75);
}
String result = memory.toString();

public long transferTo(OutputStream target) throws IOException

import java.io.*;

public class ModernCopy {

    /** Complete copy. Java 9+. */
    public static long copy(File source, File target) throws IOException {
        try (InputStream input = new BufferedInputStream(new FileInputStream(source));
             OutputStream output = new BufferedOutputStream(new FileOutputStream(target))) {

            return input.transferTo(output);        // the whole loop, in one line
        }
    }
}

/** Copy reporting progress: here the loop is still necessary. */
public long copyWithProgress(File source, File target) throws IOException {
    long size = source.length();
    long copied = 0;
    int lastPercentage = -1;

    try (InputStream input = new BufferedInputStream(new FileInputStream(source));
         OutputStream output = new BufferedOutputStream(new FileOutputStream(target))) {

        byte[] block = new byte[8192];
        int read;
        while ((read = input.read(block)) != -1) {
            output.write(block, 0, read);
            copied += read;

            int percentage = (int) (copied * 100 / Math.max(1, size));
            if (percentage != lastPercentage && percentage % 10 == 0) {
                System.out.printf("  %d%% (%d of %d bytes)%n", percentage, copied, size);
                lastPercentage = percentage;
            }
        }
    }
    return copied;
}

Files.copy(source, target, 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;

/**
 * Hexadecimal file viewer, in the classic three-column format.
 *
 * It works with BYTE STREAMS because the content could be anything:
 * using a Reader would corrupt the data before it could be shown.
 */
public class HexViewer {

    private static final int BYTES_PER_LINE = 16;
    private static final int FIRST_PRINTABLE = 32;
    private static final int LAST_PRINTABLE = 126;

    public static void dump(String path, int maxBytes) throws IOException {
        try (InputStream input = new BufferedInputStream(new FileInputStream(path))) {

            byte[] line = new byte[BYTES_PER_LINE];
            int offset = 0;
            int read;

            // readNBytes (Java 9+) insists until it fills the array or reaches
            // the end. With plain read() we could get fewer than 16 bytes in
            // the middle of the file and the dump would be misaligned.
            while (offset < maxBytes
                    && (read = input.readNBytes(line, 0, BYTES_PER_LINE)) > 0) {

                printLine(offset, line, read);
                offset += read;
            }
        }
    }

    private static void printLine(int offset, byte[] data, int howMany) {
        StringBuilder hex   = new StringBuilder();
        StringBuilder ascii = new StringBuilder();

        for (int i = 0; i < BYTES_PER_LINE; i++) {
            if (i == 8) {
                hex.append(' ');                    // separation of the two groups
            }
            if (i < howMany) {
                // & 0xFF: without this, a negative byte would print as FFFFFFxx
                int b = data[i] & 0xFF;
                hex.append(String.format("%02X ", b));
                ascii.append(isPrintable(b) ? (char) b : '.');
            } else {
                hex.append("   ");                  // padding of the last line
                ascii.append(' ');
            }
        }

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

    private static boolean isPrintable(int b) {
        return b >= FIRST_PRINTABLE && b <= LAST_PRINTABLE;
    }

    /** Detects the format by its SIGNATURE. The extension is not reliable. */
    public static String detectFormat(String path) throws IOException {
        try (InputStream input = new BufferedInputStream(new FileInputStream(path))) {
            byte[] f = input.readNBytes(8);

            if (startsWith(f, 0xFF, 0xD8, 0xFF))              { return "JPEG"; }
            if (startsWith(f, 0x89, 0x50, 0x4E, 0x47))        { return "PNG"; }
            if (startsWith(f, 0x47, 0x49, 0x46, 0x38))        { return "GIF"; }
            if (startsWith(f, 0x25, 0x50, 0x44, 0x46))        { return "PDF"; }
            if (startsWith(f, 0x50, 0x4B, 0x03, 0x04))        { return "ZIP (or JAR, DOCX...)"; }
            if (startsWith(f, 0xCA, 0xFE, 0xBA, 0xBE))        { return "JAVA CLASS"; }
            if (startsWith(f, 0xAC, 0xED))                    { return "SERIALISED OBJECT (07-05)"; }
            return "UNKNOWN (possibly text)";
        }
    }

    /** Compares the first bytes with the given signature. */
    private static boolean startsWith(byte[] data, int... signature) {
        if (data.length < signature.length) {
            return false;
        }
        for (int i = 0; i < signature.length; i++) {
            if ((data[i] & 0xFF) != signature[i]) {   // the & 0xFF, essential again
                return false;
            }
        }
        return true;
    }

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

        System.out.println("File   : " + path);
        System.out.println("Format : " + detectFormat(path));
        System.out.println();
        dump(path, 64);
    }
}

File   : covers/effective-java.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;

/**
 * Comparison of five binary copy techniques.
 *
 * WARNING: this is NOT a rigorous benchmark. The operating system page cache,
 * the JIT compiler and the garbage collector distort the measurements; the
 * first run always comes out worse. It serves to see the ORDERS OF MAGNITUDE,
 * which is what matters here. To measure seriously you use JMH, which is
 * mentioned in 10-07.
 */
public class PerformanceComparison {

    private static final String SOURCE = "performance-test.bin";
    private static final String TARGET = "performance-copy.bin";
    private static final int SIZE_MB   = 5;

    // ---------- The five techniques ----------

    /** 1. Byte by byte WITHOUT a buffer: one system call per byte. */
    static long byteByByteNoBuffer(File s, File t) throws IOException {
        try (InputStream in = new FileInputStream(s);
             OutputStream out = new FileOutputStream(t)) {
            int b;
            long n = 0;
            while ((b = in.read()) != -1) {
                out.write(b);
                n++;
            }
            return n;
        }
    }

    /** 2. Byte by byte WITH a buffer: the buffer absorbs the system calls. */
    static long byteByByteBuffered(File s, File t) throws IOException {
        try (InputStream in = new BufferedInputStream(new FileInputStream(s));
             OutputStream out = new BufferedOutputStream(new FileOutputStream(t))) {
            int b;
            long n = 0;
            while ((b = in.read()) != -1) {
                out.write(b);
                n++;
            }
            return n;
        }
    }

    /** 3 and 4. In blocks of the given size. */
    static long inBlocks(File s, File t, int size) throws IOException {
        try (InputStream in = new FileInputStream(s);
             OutputStream out = new FileOutputStream(t)) {
            byte[] block = new byte[size];
            int read;
            long n = 0;
            while ((read = in.read(block)) != -1) {
                out.write(block, 0, read);        // the limit, ALWAYS
                n += read;
            }
            return n;
        }
    }

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

    // ---------- Measurement infrastructure ----------

    interface Technique {
        long copy(File source, File target) throws IOException;
    }

    static void generateTestFile(File f, int megabytes) throws IOException {
        if (f.exists() && f.length() == megabytes * 1024L * 1024L) {
            return;                                // already generated
        }
        Random random = new Random(42);             // fixed seed: reproducible
        byte[] block = new byte[1024 * 1024];

        try (OutputStream out = new BufferedOutputStream(new FileOutputStream(f))) {
            for (int i = 0; i < megabytes; i++) {
                random.nextBytes(block);
                out.write(block);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        File source = new File(SOURCE);
        File target = new File(TARGET);

        System.out.println("Generating a test file of " + SIZE_MB + " MB...");
        generateTestFile(source, SIZE_MB);
        System.out.println("Size: " + source.length() + " bytes");
        System.out.println();

        String[] names = {
                "1. Byte by byte, NO buffer",
                "2. Byte by byte, buffered",
                "3. Blocks of 512 B",
                "4. Blocks of 8 KB",
                "5. transferTo"
        };
        Technique[] techniques = {
                PerformanceComparison::byteByByteNoBuffer,      // method references (04-06)
                PerformanceComparison::byteByByteBuffered,
                (s, t) -> inBlocks(s, t, 512),
                (s, t) -> inBlocks(s, t, 8192),
                PerformanceComparison::withTransferTo
        };

        long reference = 0;

        System.out.printf("%-28s %10s %10s %12s%n", "TECHNIQUE", "TIME", "MB/s", "SPEEDUP");
        System.out.println("-".repeat(64));

        for (int i = 0; i < techniques.length; i++) {
            long start = System.nanoTime();
            long copied = techniques[i].copy(source, target);
            long ms = (System.nanoTime() - start) / 1_000_000;

            // VERIFICATION: a fast but incorrect copy is worth nothing
            if (copied != source.length() || target.length() != source.length()) {
                System.out.printf("%-28s  INCORRECT COPY: %d bytes%n",
                        names[i], target.length());
                continue;
            }

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

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

        System.out.println();
        System.out.println("The big jump is between 1 and 2, and the cause is a single one:");
        System.out.println("without a buffer there is ONE SYSTEM CALL PER BYTE (5 million);");
        System.out.println("with a buffer, one every 8192 bytes (about 640). The rest of");
        System.out.println("the improvements are marginal in comparison.");

        target.delete();
    }
}

Generating a test file of 5 MB...
Size: 5242880 bytes

TECHNIQUE                          TIME       MB/s      SPEEDUP
----------------------------------------------------------------
1. Byte by byte, NO buffer       4680 ms        1.1         1.0x
2. Byte by byte, buffered          78 ms       64.2        60.0x
3. Blocks of 512 B                 26 ms      192.5       180.0x
4. Blocks of 8 KB                   9 ms      555.6       520.0x
5. transferTo                       7 ms      714.3       668.7x

The big jump is between 1 and 2, and the cause is a single one:
without a buffer there is ONE SYSTEM CALL PER BYTE (5 million);
with a buffer, one every 8192 bytes (about 640). The rest of
the improvements are marginal in comparison.

package com.nexussoftware.bibliotech.service;

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

/**
 * Binary loan store for BiblioTech.
 *
 * Proprietary format (BLIB v1):
 *   [4 bytes] magic number 0x424C4942 = "BLIB"
 *   [4 bytes] format version
 *   [4 bytes] number of records
 *   per record:
 *     UTF  loan reference
 *     UTF  material reference
 *     UTF  employee identifier
 *     INT  start day
 *     INT  return day (-1 if not returned)
 *     DOUBLE accumulated fine
 *
 * This format is COMPACT and FAST, but it is NOT readable or versionable in
 * source control. For the catalogue, BiblioTech will use CSV (07-07); this
 * stands as an internal binary cache.
 */
public class LoanStore {

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

    /** "BLIB" in ASCII. It identifies the file as ours. */
    private static final int MAGIC_NUMBER = 0x424C4942;
    private static final int CURRENT_VERSION = 1;

    /** Flat record of a loan, exactly as it is stored. */
    public record LoanRecord(String reference, String materialReference,
                             String employeeId, int startDay,
                             int returnDay, double fine) {

        public LoanRecord {
            Objects.requireNonNull(reference, "The reference cannot be null");
            Objects.requireNonNull(materialReference, "The material cannot be null");
            Objects.requireNonNull(employeeId, "The employee cannot be null");
            if (fine < 0) {
                throw new IllegalArgumentException("The fine cannot be negative: " + fine);
            }
        }

        public boolean isReturned() { return returnDay >= 0; }
    }

    private final File file;

    public LoanStore(String path) {
        this.file = new File(Objects.requireNonNull(path, "The path cannot be null"));
    }

    // ---------------------------- WRITING ----------------------------

    /**
     * Saves all the loans. ATOMIC write (07-02): it writes to a
     * temporary file and only renames at the end.
     */
    public void save(List<LoanRecord> loans) throws IOException {
        Objects.requireNonNull(loans, "The list cannot be null");

        File temp = new File(file.getAbsolutePath() + ".tmp");
        boolean completed = false;

        try {
            try (DataOutputStream output = new DataOutputStream(
                    new BufferedOutputStream(new FileOutputStream(temp)))) {

                // Header
                output.writeInt(MAGIC_NUMBER);
                output.writeInt(CURRENT_VERSION);
                output.writeInt(loans.size());

                // Records, in the SAME order in which they will be read
                for (LoanRecord l : loans) {
                    output.writeUTF(l.reference());
                    output.writeUTF(l.materialReference());
                    output.writeUTF(l.employeeId());
                    output.writeInt(l.startDay());
                    output.writeInt(l.returnDay());
                    output.writeDouble(l.fine());
                }
            }   // close() -> flush guaranteed

            if (file.exists() && !file.delete()) {
                throw new IOException("Could not replace " + file.getName());
            }
            if (!temp.renameTo(file)) {
                throw new IOException("Could not rename " + temp.getName());
            }
            completed = true;

            LOG.info(() -> String.format("Saved %d loans in %s (%d bytes)",
                    loans.size(), file.getName(), file.length()));

        } finally {
            if (!completed && temp.exists() && !temp.delete()) {
                LOG.warning(() -> "Temporary file left undeleted: " + temp.getAbsolutePath());
            }
        }
    }

    // ---------------------------- READING ----------------------------

    /**
     * Loads the saved loans.
     *
     * @throws IOException if the file is not ours, the version is not
     *                     supported or it is truncated
     */
    public List<LoanRecord> load() throws IOException {
        if (!file.exists()) {
            LOG.warning(() -> "There is no store at " + file.getAbsolutePath()
                    + "; returning an empty list");
            return new ArrayList<>();               // graceful degradation (07-01)
        }

        try (DataInputStream input = new DataInputStream(
                new BufferedInputStream(new FileInputStream(file)))) {

            // 1. VALIDATE THE MAGIC NUMBER.
            //    Without this, somebody else's file would be interpreted as
            //    ours and would produce absurd data WITH NO ERROR AT ALL. It is
            //    the difference between failing and corrupting.
            int magic = input.readInt();
            if (magic != MAGIC_NUMBER) {
                throw new IOException(String.format(
                        "%s is not a BiblioTech store "
                                + "(magic number 0x%08X, expected 0x%08X)",
                        file.getName(), magic, MAGIC_NUMBER));
            }

            // 2. VALIDATE THE VERSION
            int version = input.readInt();
            if (version > CURRENT_VERSION) {
                throw new IOException(String.format(
                        "The store uses version %d of the format and this version "
                                + "of BiblioTech only understands up to %d. "
                                + "Update the application.",
                        version, CURRENT_VERSION));
            }

            // 3. Number of records, with a minimum sanity check
            int howMany = input.readInt();
            if (howMany < 0) {
                throw new IOException("Invalid number of records: " + howMany);
            }

            List<LoanRecord> loans = new ArrayList<>(howMany);

            for (int i = 0; i < howMany; i++) {
                try {
                    loans.add(new LoanRecord(
                            input.readUTF(),        // the ORDER must match
                            input.readUTF(),        // save() exactly
                            input.readUTF(),
                            input.readInt(),
                            input.readInt(),
                            input.readDouble()));

                } catch (EOFException e) {
                    // TRUNCATED file: a previous write was cut short.
                    // The cause is chained (06-03) and it says how many there were.
                    throw new IOException(String.format(
                            "Truncated store: %d records were expected and only "
                                    + "%d are complete", howMany, i), e);
                }
            }

            LOG.info(() -> String.format("Loaded %d loans from %s (format v%d)",
                    loans.size(), file.getName(), version));
            return loans;
        }
    }

    // ---------------------------- DEMONSTRATION ----------------------------

    public static void main(String[] args) throws IOException {
        LoanStore store = new LoanStore("data/loans.blib");

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

        store.save(originals);

        System.out.println("=== RETRIEVED ===");
        for (LoanRecord l : store.load()) {
            System.out.printf("  %s  material=%s  employee=%s  days %d..%s  fine %.2f%n",
                    l.reference(), l.materialReference(), l.employeeId(),
                    l.startDay(),
                    l.isReturned() ? String.valueOf(l.returnDay()) : "pending",
                    l.fine());
        }

        // --- Checking the rejection of somebody else's file ---
        File impostor = new File("data/impostor.blib");
        try (DataOutputStream d = new DataOutputStream(new FileOutputStream(impostor))) {
            d.writeInt(0xDEADBEEF);      // incorrect magic number
            d.writeInt(1);
            d.writeInt(0);
        }

        System.out.println();
        System.out.println("=== SOMEBODY ELSE'S FILE ===");
        try {
            new LoanStore(impostor.getPath()).load();
            System.out.println("  ERROR: it should have been rejected");
        } catch (IOException e) {
            System.out.println("  Correctly rejected:");
            System.out.println("  " + e.getMessage());
        }
        impostor.delete();
    }
}

=== RETRIEVED ===
  LN-0001  material=978-0000000001  employee=EMP-001  days 10..22  fine 1.75
  LN-0002  material=978-0000000002  employee=EMP-002  days 12..pending  fine 0.00
  LN-0003  material=978-0000000003  employee=EMP-003  days 5..45  fine 20.00

=== SOMEBODY ELSE'S FILE ===
  Correctly rejected:
  impostor.blib is not a BiblioTech store (magic number 0xDEADBEEF, expected 0x424C4942)