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

public class PrimeraEscriptura {

    public static void main(String[] args) throws IOException {
        try (FileWriter escriptor = new FileWriter("sortida.txt", StandardCharsets.UTF_8)) {
            escriptor.write("Cataleg de BiblioTech\n");
            escriptor.write("Nexus Software\n");
        }
        System.out.println("Escrit.");
    }
}

// Sobreescriu. Charset de la plataforma: NO FER SERVIR (07-01, apartat 10)
new FileWriter("sortida.txt");

// Sobreescriu, charset explicit (Java 11+). AQUESTA es la forma correcta
new FileWriter("sortida.txt", StandardCharsets.UTF_8);

// Afegeix al final, charset de la plataforma
new FileWriter("sortida.txt", true);

// Afegeix al final, charset explicit (Java 11+). L'altra forma correcta
new FileWriter("sortida.txt", StandardCharsets.UTF_8, true);

// BiblioTech registra cada prestec en un fitxer d'auditoria.
// El fitxer porta tres anys acumulant operacions.

public void registrarOperacio(String linia) throws IOException {
    // BUG: falta el 'true'. Cada crida ESBORRA tot l'historic
    // i deixa nomes l'ultima linia.
    try (FileWriter escriptor = new FileWriter("dades/auditoria.txt", StandardCharsets.UTF_8)) {
        escriptor.write(linia + System.lineSeparator());
    }
}

public void registrarOperacio(String linia) throws IOException {
    // El 'true' final: AFEGIR, no sobreescriure
    try (FileWriter escriptor =
                 new FileWriter("dades/auditoria.txt", StandardCharsets.UTF_8, true)) {
        escriptor.write(linia + System.lineSeparator());
    }
}

private static final boolean AFEGIR       = true;
private static final boolean SOBREESCRIURE = false;

new FileWriter(cami, StandardCharsets.UTF_8, AFEGIR);   // es llegeix sol

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

public class FormesDeEscriure {

    public static void main(String[] args) throws IOException {
        try (FileWriter w = new FileWriter("demo.txt", StandardCharsets.UTF_8)) {

            w.write("Text complet");                 // String sencer
            w.write('\n');                          // un sol caracter (int)
            w.write("Nomes una part", 6, 3);        // subcadena: des de 6, 3 caracters -> "una"
            w.write('\n');

            char[] buffer = { 'B', 'i', 'b', 'l', 'i', 'o' };
            w.write(buffer);                        // array complet
            w.write(buffer, 0, 3);                  // part de l'array -> "Bib"

            w.append("Encadenable")                 // append retorna el Writer
             .append(' ')
             .append("i comode");
        }
    }
}

import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Locale;

public class InformeAmbPrintWriter {

    public static void main(String[] args) throws IOException {
        try (PrintWriter sortida = new PrintWriter(
                new FileWriter("informe.txt", StandardCharsets.UTF_8))) {

            sortida.println("INFORME DE MULTES - BiblioTech");
            sortida.println("==============================");
            sortida.println();

            // printf amb la mateixa sintaxi del modul 1
            sortida.printf("%-25s %-15s %8s%n", "MATERIAL", "EMPLEAT", "MULTA");
            sortida.printf("%-25s %-15s %8.2f%n", "Java Eficac",  "Marta Ruiz",   3.75);
            sortida.printf("%-25s %-15s %8.2f%n", "Patrons de Disseny", "Diego Alonso", 0.00);
            sortida.printf("%-25s %-15s %8.2f%n", "Refactoritzacio", "Nuria Vidal",  20.00);

            // Locale explicit: a Catalunya el separador decimal es la coma.
            // Per a un fitxer que un altre programa hagi de llegir, fixa Locale.ROOT.
            sortida.printf(Locale.ROOT, "%nTOTAL: %.2f EUR%n", 23.75);
        }
    }
}

INFORME DE MULTES - BiblioTech
==============================

MATERIAL                  EMPLEAT            MULTA
Java Eficac               Marta Ruiz          3,75
Patrons de Disseny        Diego Alonso        0,00
Refactoritzacio           Nuria Vidal        20,00

TOTAL: 23.75 EUR

try (PrintWriter sortida = new PrintWriter(
        new FileWriter("informe.txt", StandardCharsets.UTF_8))) {

    sortida.println("linia 1");
    sortida.println("linia 2");

    // COMPROVACIO OBLIGATORIA en codi serios.
    // checkError() buida la memoria intermedia i retorna true si HI HA HAGUT alguna
    // fallada en qualsevol moment des que es va obrir.
    if (sortida.checkError()) {
        throw new IOException("Fallada en escriure l'informe (detectada per checkError)");
    }
}

// Aquests DOS obren el fitxer pel seu compte, amb el charset de la plataforma
// a les versions antigues. Son comodes i traidors.
new PrintWriter("sortida.txt");
new PrintWriter(new File("sortida.txt"));

// Amb charset explicit (Java 10+): correcte
new PrintWriter("sortida.txt", StandardCharsets.UTF_8);

// Embolcallant un Writer que tu controles: la forma mes clara i flexible
new PrintWriter(new FileWriter("sortida.txt", StandardCharsets.UTF_8, true));

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

public class DemoBuffer {

    public static void main(String[] args) throws Exception {
        FileWriter w = new FileWriter("demo-buffer.txt", StandardCharsets.UTF_8);

        w.write("Primera linia\n");
        System.out.println("Despres de write, mida al disc: " + mida());   // 0

        w.flush();
        System.out.println("Despres de flush, mida al disc: " + mida());   // 14

        w.write("Segona linia\n");
        System.out.println("Despres del 2n write, mida:     " + mida());   // 14

        w.close();
        System.out.println("Despres de close, mida al disc: " + mida());   // 27
    }

    private static long mida() {
        return new java.io.File("demo-buffer.txt").length();
    }
}

Despres de write, mida al disc: 0
Despres de flush, mida al disc: 14
Despres del 2n write, mida:     14
Despres de close, mida al disc: 27

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

public class SenseTancar {

    public static void main(String[] args) throws Exception {
        // MALAMENT A PROPOSIT: sense try-with-resources i sense close
        FileWriter w = new FileWriter("sense-tancar.txt", StandardCharsets.UTF_8);
        w.write("Aquesta linia pot no arribar mai al disc.\n");

        System.out.println("Acabant sense tancar...");
        // main acaba aqui. No hi ha close(). No hi ha flush().
    }
}

try (FileWriter w = new FileWriter("ben-tancat.txt", StandardCharsets.UTF_8)) {
    w.write("Aquesta linia SI que arriba al disc.\n");
}   // close() garantit: amb exit, amb excepcio i amb return (06-06)

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

public class CaracterNoRepresentable {

    public static void main(String[] args) throws IOException {
        // US-ASCII no te 'ç' ni '€'
        try (FileWriter w = new FileWriter("ascii.txt", StandardCharsets.US_ASCII)) {
            w.write("Els Patrons de Disseny costen 45 €");
        }
        // NO llanca excepcio. Substitueix el que no es representable per '?'.
        // Al fitxer queda: "Els Patrons de Disseny costen 45 ?"
    }
}

// SEMPRE, a cada obertura d'escriptura de text
new FileWriter(cami, StandardCharsets.UTF_8);
new FileWriter(cami, StandardCharsets.UTF_8, AFEGIR);
new PrintWriter(new FileWriter(cami, StandardCharsets.UTF_8));

package com.nexussoftware.bibliotech.infraestructura;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

/** Convencions de format de tots els fitxers de BiblioTech. */
public final class FormatFitxers {

    /** Charset unic de tots els fitxers de text del sistema. */
    public static final Charset CHARSET = StandardCharsets.UTF_8;

    /** Separador de camps dels fitxers tabulats. */
    public static final String SEPARADOR_CAMPS = ";";

    /** Prefix de les linies de comentari. */
    public static final String COMENTARI = "#";

    private FormatFitxers() { }
}

String salt = System.lineSeparator();      // "\n" o "\r\n" segons el sistema

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class EscripturaAmbGestio {

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

    public void exportar(String cami, String contingut) throws CatalegNoAccessibleException {
        try (FileWriter w = new FileWriter(cami, StandardCharsets.UTF_8)) {
            w.write(contingut);

        } catch (FileNotFoundException e) {
            // Problema d'UBICACIO o PERMISOS: l'usuari pot corregir-ho
            LOG.log(Level.WARNING, "No es pot escriure a "
                    + new java.io.File(cami).getAbsolutePath(), e);
            throw new CatalegNoAccessibleException(cami, e);   // 06-04, amb la causa

        } catch (IOException e) {
            // Problema DURANT l'escriptura: disc ple, xarxa caiguda...
            LOG.log(Level.SEVERE, "Fallada d'E/S escrivint " + cami, e);
            throw new CatalegNoAccessibleException(cami, e);
        }
    }
}

// PERILLOS: regenera el cataleg complet sobreescrivint el fitxer bo
try (PrintWriter w = new PrintWriter(
        new FileWriter("dades/cataleg.txt", StandardCharsets.UTF_8))) {

    for (Material m : cataleg.llistar()) {       // 10 000 materials
        w.println(serialitzar(m));
    }
    // Si falla al material 6 000 (disc ple, excepcio a serialitzar,
    // el proces mor), el fitxer queda amb 6 000 linies i el cataleg
    // ORIGINAL JA NO EXISTEIX: es va truncar en obrir.
}

package com.nexussoftware.bibliotech.infraestructura;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.FileWriter;
import java.nio.charset.StandardCharsets;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Escriptura atomica de fitxers de text.
 *
 * Escriu en un fitxer temporal i, NOMES si tot ha anat be, el reanomena
 * sobre el definitiu. Garanteix que el fitxer desti no queda mai a mitges.
 *
 * Es l'equivalent al disc de la compensacio al finally de 06-05: si
 * l'operacio no es completa, l'estat anterior es conserva intacte.
 */
public final class EscripturaAtomica {

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

    private static final String SUFIX_TEMPORAL = ".tmp";

    private EscripturaAtomica() { }

    /**
     * Contracte del que s'escriura. Interficie funcional (04-06):
     * permet passar la logica d'escriptura com a lambda.
     *
     * No es java.util.function.Consumer perque necessitem que pugui
     * declarar IOException, i Consumer.accept() no la declara.
     */
    @FunctionalInterface
    public interface Contingut {
        void escriureA(PrintWriter sortida) throws IOException;
    }

    /**
     * Escriu de forma atomica.
     *
     * @param desti     fitxer final
     * @param contingut que cal escriure
     * @throws IOException si falla l'escriptura o el reanomenat
     */
    public static void escriure(File desti, Contingut contingut) throws IOException {
        File temporal = new File(desti.getAbsolutePath() + SUFIX_TEMPORAL);

        // 1. Assegurar que existeix el directori pare (FileWriter no el crea)
        File pare = desti.getAbsoluteFile().getParentFile();
        if (pare != null && !pare.exists() && !pare.mkdirs()) {
            throw new IOException("No s'ha pogut crear el directori " + pare.getAbsolutePath());
        }

        boolean completat = false;
        try {
            // 2. Escriure-ho TOT al temporal
            try (PrintWriter sortida = new PrintWriter(
                    new FileWriter(temporal, StandardCharsets.UTF_8))) {

                contingut.escriureA(sortida);

                // PrintWriter s'empassa les IOException: cal preguntar-li
                if (sortida.checkError()) {
                    throw new IOException("Fallada en escriure a "
                            + temporal.getAbsolutePath());
                }
            }   // close() garantit: aqui el temporal esta tancat i complet

            // 3. Reanomenar NOMES si arribem fins aqui
            if (!reanomenar(temporal, desti)) {
                throw new IOException("No s'ha pogut reanomenar "
                        + temporal.getName() + " sobre " + desti.getName());
            }
            completat = true;
            LOG.fine(() -> "Escriptura atomica completada: " + desti.getAbsolutePath());

        } finally {
            // 4. COMPENSACIO (06-05): si no s'ha completat, no deixar brossa.
            //    El desti original continua intacte perque no es va obrir mai.
            if (!completat && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Ha quedat un fitxer temporal sense esborrar: "
                        + temporal.getAbsolutePath());
            }
        }
    }

    /**
     * Reanomena el temporal sobre el desti.
     *
     * File.renameTo retorna un boolean mut (07-01) i a Windows falla si
     * el desti existeix. D'aqui l'esborrat previ. A 07-06 aixo es resol
     * amb Files.move i ATOMIC_MOVE, que es la forma correcta.
     */
    private static boolean reanomenar(File temporal, File desti) {
        if (desti.exists() && !desti.delete()) {
            return false;
        }
        return temporal.renameTo(desti);
    }
}

EscripturaAtomica.escriure(new File("dades/cataleg.txt"), sortida -> {
    sortida.println("# Cataleg de BiblioTech");
    for (Material m : cataleg.llistar()) {
        sortida.printf("%s;%s;%s;%b%n",
                m.getTipus(), m.getReferencia(), m.getTitol(), m.estaDisponible());
    }
});

package com.nexussoftware.bibliotech.infraestructura;

import java.io.File;
import java.io.IOException;

/**
 * Bloqueig entre processos basat en l'existencia d'un fitxer.
 *
 * AutoCloseable (06-06): el bloqueig s'allibera en sortir del try, se surti
 * com se surti. Sense aquesta garantia, un bloqueig orfe deixa el sistema
 * inutilitzable fins que algu esborri el fitxer a ma.
 */
public class BloqueigFitxer implements AutoCloseable {

    private final File bloqueig;
    private boolean adquirit = false;

    public BloqueigFitxer(String camiProtegit) throws IOException {
        this.bloqueig = new File(camiProtegit + ".lock");

        // createNewFile() es ATOMIC: comprova i crea en una sola operacio.
        // Per aixo serveix com a bloqueig i un exists() + create() NO serviria:
        // entre les dues crides hi cap l'altre proces (TOCTOU, 06-07).
        if (!bloqueig.createNewFile()) {
            throw new IOException("El fitxer '" + camiProtegit
                    + "' l'esta fent servir un altre proces"
                    + " (existeix " + bloqueig.getName() + ")");
        }
        adquirit = true;
        bloqueig.deleteOnExit();     // xarxa de seguretat davant d'una sortida brusca
    }

    @Override
    public void close() {
        if (!adquirit) {
            return;                  // idempotent (06-06)
        }
        adquirit = false;
        if (!bloqueig.delete()) {
            System.err.println("Avis: no s'ha pogut alliberar " + bloqueig.getAbsolutePath());
        }
    }
}

try (BloqueigFitxer lock = new BloqueigFitxer("dades/cataleg.txt")) {
    EscripturaAtomica.escriure(new File("dades/cataleg.txt"), sortida -> { /* ... */ });
}   // el bloqueig s'allibera aqui, passi el que passi

/** Conserva la versio anterior abans de sobreescriure. */
private static void ferCopiaSeguretat(File fitxer) {
    if (!fitxer.exists()) {
        return;
    }
    File copia = new File(fitxer.getAbsolutePath() + ".bak");
    if (copia.exists()) {
        copia.delete();
    }
    if (!fitxer.renameTo(copia)) {
        LOG.warning("No s'ha pogut fer copia de seguretat de " + fitxer.getName());
    }
}

package com.nexussoftware.bibliotech.servei;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.domini.Llibre;
import com.nexussoftware.bibliotech.domini.Material;
import com.nexussoftware.bibliotech.domini.Prestec;
import com.nexussoftware.bibliotech.infraestructura.EscripturaAtomica;
import com.nexussoftware.bibliotech.infraestructura.FormatFitxers;

/**
 * Exporta el cataleg i el registre de prestecs de BiblioTech a fitxers
 * de text, de forma ATOMICA: el fitxer desti no queda mai a mitges.
 *
 * Canvi de disseny respecte a 06-06: aquesta classe ja NO es Closeable.
 * No mante cap fitxer obert entre crides; cada exportacio obre, escriu i
 * tanca dins d'EscripturaAtomica. Un objecte que no posseeix recursos
 * vius no ha de ser tancable: seria una promesa buida.
 *
 * El format es el que llegeix CarregadorCataleg (07-01). Tots dos comparteixen
 * les constants de FormatFitxers perque no puguin discrepar.
 */
public class ExportadorCataleg {

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

    private static final String CAPCALERA_CATALEG =
            FormatFitxers.COMENTARI + " Cataleg de BiblioTech - Nexus Software";
    private static final String CAMPS_CATALEG =
            FormatFitxers.COMENTARI + " tipus;referencia;titol;autor;any";

    private final File directori;

    public ExportadorCataleg(String directoriDades) {
        this.directori = new File(
                Objects.requireNonNull(directoriDades, "El directori no pot ser nul"));
    }

    /**
     * Exporta el cataleg complet.
     *
     * @return nombre de materials escrits
     * @throws IOException si no s'ha pogut completar l'escriptura
     */
    public int exportarCataleg(Cataleg cataleg) throws IOException {
        Objects.requireNonNull(cataleg, "El cataleg no pot ser nul");

        List<Material> materials = cataleg.llistar();
        File desti = new File(directori, "cataleg.txt");

        long inici = System.nanoTime();

        EscripturaAtomica.escriure(desti, sortida -> {
            sortida.println(CAPCALERA_CATALEG);
            sortida.println(CAMPS_CATALEG);
            for (Material m : materials) {
                sortida.println(serialitzar(m));
            }
        });

        double ms = (System.nanoTime() - inici) / 1_000_000.0;

        // Logger, mai System.out per a diagnostic (06-07). Forma mandrosa.
        LOG.info(() -> String.format("Cataleg exportat: %d materials a %s (%.1f ms)",
                materials.size(), desti.getAbsolutePath(), ms));

        return materials.size();
    }

    /**
     * Serialitza un material a una linia.
     *
     * Els camps es sanegen: un ';' dins d'un titol trencaria el fitxer
     * en rellegir-lo. Aqui se substitueix; a 07-07 es fara BE, entrecometant
     * i escapant segons la convencio CSV.
     */
    private String serialitzar(Material m) {
        String sep = FormatFitxers.SEPARADOR_CAMPS;

        if (m instanceof Llibre llibre) {                // patro de 03-06
            return String.join(sep,
                    "LLIBRE",
                    sanejar(llibre.getIsbn()),
                    sanejar(llibre.getTitol()),
                    sanejar(llibre.getAutor()),
                    String.valueOf(llibre.getAnyPublicacio()));
        }
        return String.join(sep,
                m.getTipus().toUpperCase(),
                sanejar(m.getReferencia()),
                sanejar(m.getTitol()),
                "-",
                "0");
    }

    /** Elimina separadors i salts de linia que trencarien el format. */
    private String sanejar(String valor) {
        if (valor == null) {
            return "";
        }
        return valor.replace(FormatFitxers.SEPARADOR_CAMPS, ",")
                    .replace("\n", " ")
                    .replace("\r", " ")
                    .trim();
    }

    /**
     * Afegeix una linia al registre d'auditoria de prestecs.
     *
     * AQUEST fitxer SI que s'obre en mode AFEGIR: es un historic acumulatiu,
     * no un fitxer que es regenera. No porta escriptura atomica perque no
     * hi ha res per reemplacar; nomes s'agrega al final.
     */
    public void registrarPrestec(Prestec prestec, String operacio) {
        Objects.requireNonNull(prestec, "El prestec no pot ser nul");

        File auditoria = new File(directori, "auditoria.txt");

        // El 'true' final es AFEGIR. Sense ell, cada crida esborraria l'historic.
        try (PrintWriter sortida = new PrintWriter(
                new java.io.FileWriter(auditoria, FormatFitxers.CHARSET, true))) {

            sortida.printf("%s;%s;%s;%s%n",
                    operacio,
                    prestec.getReferencia(),
                    prestec.getMaterial().getReferencia(),
                    prestec.getTitular().getIdentificador());

            if (sortida.checkError()) {
                throw new IOException("Fallada escrivint a " + auditoria.getAbsolutePath());
            }

        } catch (IOException e) {
            // POLITICA: l'auditoria NO ha de tombar l'operacio de negoci.
            // El prestec ja s'ha registrat en memoria i es valid.
            // Es degrada: s'avisa al log i es continua (06-07).
            LOG.log(Level.WARNING, "No s'ha pogut auditar l'operacio "
                    + operacio + " de " + prestec.getReferencia(), e);
        }
    }
}

package com.nexussoftware.bibliotech.presentacio;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.servei.Cataleg;
import com.nexussoftware.bibliotech.servei.CarregadorCataleg;
import com.nexussoftware.bibliotech.servei.ExportadorCataleg;
import com.nexussoftware.bibliotech.infraestructura.ConfiguracioLog;

public class BiblioTechApp {

    private static final Logger LOG = Logger.getLogger(BiblioTechApp.class.getName());
    private static final String DIRECTORI_DADES = "dades";

    public static void main(String[] args) {
        ConfiguracioLog.inicialitzar();

        Cataleg cataleg = new CarregadorCataleg(DIRECTORI_DADES + "/cataleg.txt").carregar();
        ExportadorCataleg exportador = new ExportadorCataleg(DIRECTORI_DADES);

        // Desat en sortir. Cobreix la sortida normal i Ctrl+C; NO cobreix kill -9.
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                int n = exportador.exportarCataleg(cataleg);
                LOG.info("Cataleg desat en sortir: " + n + " materials");
            } catch (IOException e) {
                LOG.log(Level.SEVERE, "NO S'HA POGUT DESAR EL CATALEG EN SORTIR", e);
            }
        }, "desat-final"));

        System.out.println("BiblioTech - Nexus Software");
        System.out.println("Materials al cataleg: " + cataleg.mida());

        new MenuBiblioTech(cataleg, exportador).executar();
    }
}

package com.nexussoftware.bibliotech.demo;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

/**
 * Demostracio empirica del parametre append.
 */
public class DemoAppend {

    /** Noms per al boolean: evita el 'true' solt i illegible. */
    private static final boolean AFEGIR        = true;
    private static final boolean SOBREESCRIURE = false;

    private static final String CAMI = "demo-append.txt";

    public static void escriureLinia(String cami, String text, boolean afegir)
            throws IOException {
        try (FileWriter w = new FileWriter(cami, StandardCharsets.UTF_8, afegir)) {
            w.write(text);
            w.write('\n');
        }   // close() buida la memoria intermedia: sense ell, el fitxer quedaria buit
    }

    public static void mostrar(String cami) {
        File f = new File(cami);
        if (!f.exists()) {
            System.out.println("    (el fitxer no existeix)");
            return;
        }

        System.out.println("    mida: " + f.length() + " bytes");
        try (Scanner sc = new Scanner(f, StandardCharsets.UTF_8)) {
            int n = 0;
            while (sc.hasNextLine()) {
                System.out.println("      | " + sc.nextLine());
                n++;
            }
            System.out.println("    linies: " + n);
        } catch (IOException e) {
            System.out.println("    error en llegir: " + e.getMessage());
        }
    }

    public static void main(String[] args) throws IOException {
        File f = new File(CAMI);
        if (f.exists() && !f.delete()) {
            System.err.println("No s'ha pogut esborrar el fitxer previ");
            return;
        }

        System.out.println("=== EXPERIMENT 1: SENSE append (sobreescriure) ===");
        for (int i = 1; i <= 3; i++) {
            escriureLinia(CAMI, "Operacio numero " + i, SOBREESCRIURE);
            System.out.println("  Despres d'escriure la linia " + i + ":");
            mostrar(CAMI);
        }

        f.delete();

        System.out.println();
        System.out.println("=== EXPERIMENT 2: AMB append (afegir) ===");
        for (int i = 1; i <= 3; i++) {
            escriureLinia(CAMI, "Operacio numero " + i, AFEGIR);
            System.out.println("  Despres d'escriure la linia " + i + ":");
            mostrar(CAMI);
        }

        // CONCLUSIO: sense append, cada escriptura TRUNCA el fitxer a zero
        // en el moment d'obrir-lo, aixi que nomes sobreviu l'ultima linia.
        // Amb append, el punter se situa al final i el contingut creix.
    }
}

=== EXPERIMENT 1: SENSE append (sobreescriure) ===
  Despres d'escriure la linia 1:
    mida: 18 bytes
      | Operacio numero 1
    linies: 1
  Despres d'escriure la linia 2:
    mida: 18 bytes
      | Operacio numero 2
    linies: 1
  Despres d'escriure la linia 3:
    mida: 18 bytes
      | Operacio numero 3
    linies: 1

=== EXPERIMENT 2: AMB append (afegir) ===
  Despres d'escriure la linia 1:
    mida: 18 bytes
      | Operacio numero 1
    linies: 1
  Despres d'escriure la linia 2:
    mida: 36 bytes
      | Operacio numero 1
      | Operacio numero 2
    linies: 2
  Despres d'escriure la linia 3:
    mida: 54 bytes
      | Operacio numero 1
      | Operacio numero 2
      | Operacio numero 3
    linies: 3

package com.nexussoftware.bibliotech.infraestructura;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Escriptura atomica amb verificacio previa al reanomenat.
 *
 * Afegeix una comprovacio d'integritat ABANS de substituir el fitxer bo:
 * si el resultat no es l'esperat, l'original es conserva intacte.
 */
public final class EscripturaAtomicaVerificada {

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

    private static final String SUFIX_TEMPORAL = ".tmp";

    private EscripturaAtomicaVerificada() { }

    @FunctionalInterface
    public interface Contingut {
        void escriureA(PrintWriter sortida) throws IOException;
    }

    /**
     * Escriu de forma atomica verificant el resultat.
     *
     * @param liniesEsperades nombre de linies que HA de tenir el resultat
     * @throws IOException si falla l'escriptura o la verificacio
     */
    public static void escriureVerificat(File desti, Contingut contingut,
                                         int liniesEsperades) throws IOException {

        File temporal = new File(desti.getAbsolutePath() + SUFIX_TEMPORAL);

        File pare = desti.getAbsoluteFile().getParentFile();
        if (pare != null && !pare.exists() && !pare.mkdirs()) {
            throw new IOException("No s'ha pogut crear el directori " + pare.getAbsolutePath());
        }

        boolean completat = false;
        try {
            // ---- FASE 1: escriure al temporal ----
            try (PrintWriter sortida = new PrintWriter(
                    new FileWriter(temporal, StandardCharsets.UTF_8))) {

                contingut.escriureA(sortida);

                if (sortida.checkError()) {
                    throw new IOException("Fallada d'escriptura a " + temporal.getName());
                }
            }

            // ---- FASE 2: verificar ABANS de tocar el desti ----
            long mida = temporal.length();
            if (mida == 0) {
                throw new IOException("El fitxer temporal ha quedat buit; no se substitueix "
                        + desti.getName());
            }

            int liniesReals = comptarLinies(temporal);
            if (liniesReals != liniesEsperades) {
                throw new IOException(String.format(
                        "Verificacio fallida a %s: s'esperaven %d linies i n'hi ha %d. "
                                + "El fitxer original NO s'ha modificat.",
                        desti.getName(), liniesEsperades, liniesReals));
            }

            LOG.fine(() -> String.format("Verificacio OK: %d linies, %d bytes",
                    liniesReals, mida));

            // ---- FASE 3: substituir. Nomes si tot l'anterior ha anat be ----
            if (desti.exists() && !desti.delete()) {
                throw new IOException("No s'ha pogut eliminar el desti " + desti.getName());
            }
            if (!temporal.renameTo(desti)) {
                throw new IOException("No s'ha pogut reanomenar " + temporal.getName());
            }

            completat = true;
            LOG.info(() -> String.format("Escriptura verificada de %s: %d linies, %d bytes",
                    desti.getAbsolutePath(), liniesEsperades, mida));

        } finally {
            // COMPENSACIO (06-05): sense brossa, i amb l'original intacte
            if (!completat && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sense esborrar: " + temporal.getAbsolutePath());
            }
        }
    }

    private static int comptarLinies(File f) throws IOException {
        int n = 0;
        try (Scanner sc = new Scanner(f, StandardCharsets.UTF_8)) {
            while (sc.hasNextLine()) {
                sc.nextLine();
                n++;
            }
        }
        return n;
    }

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

    public static void main(String[] args) throws IOException {
        File desti = new File("dades/cataleg-verificat.txt");

        // 1. Escriptura correcta de 3 linies
        escriureVerificat(desti, sortida -> {
            sortida.println("LLIBRE;978-0000000001;Java Eficac;Bloch;2018");
            sortida.println("LLIBRE;978-0000000002;Patrons de Disseny;Gamma;1994");
            sortida.println("LLIBRE;978-0000000003;Refactoritzacio;Fowler;1999");
        }, 3);

        System.out.println("Despres de l'escriptura correcta: "
                + desti.length() + " bytes, "
                + comptarLinies(desti) + " linies");

        // 2. Escriptura que FALLA a mitges
        try {
            escriureVerificat(desti, sortida -> {
                sortida.println("LLIBRE;978-0000000004;Llibre nou;Autor;2024");
                // Fallada simulada: disc ple, error de serialitzacio, el que sigui
                throw new IOException("Fallada simulada a mitja exportacio");
            }, 4);

        } catch (IOException e) {
            System.out.println("Fallada capturada: " + e.getMessage());
        }

        // 3. COMPROVACIO CLAU: el fitxer bo continua alla, sencer
        System.out.println("Despres de la fallada:            "
                + desti.length() + " bytes, "
                + comptarLinies(desti) + " linies");

        System.out.println("Ha quedat brossa .tmp? "
                + new File(desti.getAbsolutePath() + ".tmp").exists());

        // 4. Escriptura amb nombre de linies incorrecte: es rebutja
        try {
            escriureVerificat(desti, sortida -> sortida.println("Nomes una linia"), 5);
        } catch (IOException e) {
            System.out.println("Verificacio: " + e.getMessage());
        }

        System.out.println("Despres de la verificacio fallida: "
                + comptarLinies(desti) + " linies (intacte)");
    }
}

Despres de l'escriptura correcta: 147 bytes, 3 linies
Fallada capturada: Fallada simulada a mitja exportacio
Despres de la fallada:            147 bytes, 3 linies
Ha quedat brossa .tmp? false
Verificacio: Verificacio fallida a cataleg-verificat.txt: s'esperaven 5 linies i n'hi ha 1. El fitxer original NO s'ha modificat.
Despres de la verificacio fallida: 3 linies (intacte)

package com.nexussoftware.bibliotech.infraestructura;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Registre d'auditoria de BiblioTech amb rotacio per mida.
 *
 * Mode AFEGIR: el fitxer creix, no es regenera. Per aixo NO fa servir
 * escriptura atomica: no hi ha res per reemplacar.
 *
 * Separador de linia fix '\n': es un fitxer de DADES que es pot comparar
 * entre maquines, no un informe per llegir a la pantalla (apartat 8).
 */
public class AuditoriaBiblioTech {

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

    private static final boolean AFEGIR = true;
    private static final String  SALT   = "\n";
    private static final String  SEP    = ";";

    /** 1 KB, petit a proposit per poder provar la rotacio. */
    private static final long MIDA_MAXIMA = 1024L;

    /** Fitxers historics que es conserven: auditoria-1 .. auditoria-3. */
    private static final int MAX_HISTORICS = 3;

    private final File directori;
    private final String nomBase;

    private int operacionsRegistrades = 0;
    private int rotacions = 0;
    private int fallades = 0;

    public AuditoriaBiblioTech(String directori) {
        this.directori = new File(
                Objects.requireNonNull(directori, "El directori no pot ser nul"));
        this.nomBase = "auditoria";

        if (!this.directori.exists() && !this.directori.mkdirs()) {
            LOG.warning("No s'ha pogut crear " + this.directori.getAbsolutePath());
        }
    }

    /**
     * Registra una operacio.
     *
     * POLITICA: una fallada d'auditoria NO es propaga MAI. L'operacio de
     * negoci ja es valida; perdre'n el rastre es una degradacio acceptable
     * i s'avisa al log (06-07).
     */
    public void registrar(String operacio, String referencia, String idEmpleat) {
        Objects.requireNonNull(operacio, "L'operacio no pot ser nulla");

        File actual = new File(directori, nomBase + ".txt");

        try {
            // 1. Rotar ABANS d'escriure, si toca
            if (actual.exists() && actual.length() >= MIDA_MAXIMA) {
                rotar(actual);
            }

            // 2. Afegir la linia. El 'true' es el que fa que aixo sigui
            //    un historic i no un fitxer d'una sola linia.
            try (PrintWriter sortida = new PrintWriter(
                    new FileWriter(actual, StandardCharsets.UTF_8, AFEGIR))) {

                sortida.write(String.join(SEP, operacio, referencia, idEmpleat));
                sortida.write(SALT);

                if (sortida.checkError()) {
                    throw new IOException("Fallada escrivint a " + actual.getAbsolutePath());
                }
            }
            operacionsRegistrades++;

        } catch (IOException e) {
            fallades++;
            LOG.log(Level.WARNING, "No s'ha pogut auditar " + operacio
                    + " de " + referencia, e);
            // Sense rellancar: la degradacio es deliberada
        }
    }

    /**
     * Desplaca els historics: -2 passa a -3, -1 passa a -2, l'actual a -1.
     *
     * Es recorre de MAJOR a MENOR. A l'inreves, el primer reanomenat
     * matxucaria el seguent abans d'haver-lo desplacat.
     */
    private void rotar(File actual) throws IOException {
        // El mes antic es perd
        File mesAntic = historic(MAX_HISTORICS);
        if (mesAntic.exists() && !mesAntic.delete()) {
            throw new IOException("No s'ha pogut esborrar " + mesAntic.getName());
        }

        for (int i = MAX_HISTORICS - 1; i >= 1; i--) {
            File origen = historic(i);
            File desti  = historic(i + 1);
            if (origen.exists() && !origen.renameTo(desti)) {
                throw new IOException("No s'ha pogut rotar " + origen.getName());
            }
        }

        if (!actual.renameTo(historic(1))) {
            throw new IOException("No s'ha pogut rotar " + actual.getName());
        }

        rotacions++;
        LOG.fine(() -> "Auditoria rotada (rotacio numero " + rotacions + ")");
    }

    private File historic(int n) {
        return new File(directori, nomBase + "-" + n + ".txt");
    }

    public int getOperacionsRegistrades() { return operacionsRegistrades; }
    public int getRotacions()             { return rotacions; }
    public int getFallades()              { return fallades; }

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

    public static void main(String[] args) {
        AuditoriaBiblioTech auditoria = new AuditoriaBiblioTech("dades/auditoria");

        String[] operacions = { "PRESTEC", "DEVOLUCIO", "ALTA", "BAIXA" };
        String[] empleats   = { "E-001", "E-002", "E-003" };

        for (int i = 1; i <= 200; i++) {
            auditoria.registrar(
                    operacions[i % operacions.length],
                    String.format("PR-%04d", i),
                    empleats[i % empleats.length]);
        }

        System.out.println("=== AUDITORIA ===");
        System.out.printf("  Operacions registrades: %d%n",
                auditoria.getOperacionsRegistrades());
        System.out.printf("  Rotacions realitzades : %d%n", auditoria.getRotacions());
        System.out.printf("  Fallades              : %d%n", auditoria.getFallades());

        System.out.println("  --- Fitxers ---");
        File dir = new File("dades/auditoria");
        File[] fitxers = dir.listFiles();       // pot ser null: es comprova
        if (fitxers != null) {
            java.util.Arrays.sort(fitxers);     // 05-09
            for (File f : fitxers) {
                System.out.printf("    %-20s %6d bytes%n", f.getName(), f.length());
            }
        }
    }
}

=== AUDITORIA ===
  Operacions registrades: 200
  Rotacions realitzades : 4
  Fallades              : 0
  --- Fitxers ---
    auditoria-1.txt        1042 bytes
    auditoria-2.txt        1040 bytes
    auditoria-3.txt        1039 bytes
    auditoria.txt            85 bytes