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

public class PrimeraEscritura {

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

// Sobrescribe. Charset de la plataforma: NO USAR (07-01, apartado 10)
new FileWriter("salida.txt");

// Sobrescribe, charset explicito (Java 11+). ESTA es la forma correcta
new FileWriter("salida.txt", StandardCharsets.UTF_8);

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

// Anade al final, charset explicito (Java 11+). La otra forma correcta
new FileWriter("salida.txt", StandardCharsets.UTF_8, true);

// BiblioTech registra cada prestamo en un fichero de auditoria.
// El fichero lleva tres anos acumulando operaciones.

public void registrarOperacion(String linea) throws IOException {
    // BUG: falta el 'true'. Cada llamada BORRA todo el historico
    // y deja solo la ultima linea.
    try (FileWriter escritor = new FileWriter("datos/auditoria.txt", StandardCharsets.UTF_8)) {
        escritor.write(linea + System.lineSeparator());
    }
}

public void registrarOperacion(String linea) throws IOException {
    // El 'true' final: ANADIR, no sobrescribir
    try (FileWriter escritor =
                 new FileWriter("datos/auditoria.txt", StandardCharsets.UTF_8, true)) {
        escritor.write(linea + System.lineSeparator());
    }
}

private static final boolean ANADIR      = true;
private static final boolean SOBRESCRIBIR = false;

new FileWriter(ruta, StandardCharsets.UTF_8, ANADIR);   // se lee solo

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

public class FormasDeEscribir {

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

            w.write("Texto completo");              // String entero
            w.write('\n');                          // un solo caracter (int)
            w.write("Solo una parte", 5, 3);        // subcadena: desde 5, 3 caracteres -> "una"
            w.write('\n');

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

            w.append("Encadenable")                 // append devuelve el Writer
             .append(' ')
             .append("y comodo");
        }
    }
}

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

public class InformeConPrintWriter {

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

            salida.println("INFORME DE MULTAS - BiblioTech");
            salida.println("==============================");
            salida.println();

            // printf con la misma sintaxis del modulo 1
            salida.printf("%-25s %-15s %8s%n", "MATERIAL", "EMPLEADO", "MULTA");
            salida.printf("%-25s %-15s %8.2f%n", "Java Efectivo",  "Marta Ruiz",   3.75);
            salida.printf("%-25s %-15s %8.2f%n", "Patrones de Diseno", "Diego Alonso", 0.00);
            salida.printf("%-25s %-15s %8.2f%n", "Refactorizacion", "Nuria Vidal",  20.00);

            // Locale explicito: en Espana el separador decimal es la coma.
            // Para un fichero que otro programa vaya a leer, fija Locale.ROOT.
            salida.printf(Locale.ROOT, "%nTOTAL: %.2f EUR%n", 23.75);
        }
    }
}

INFORME DE MULTAS - BiblioTech
==============================

MATERIAL                  EMPLEADO            MULTA
Java Efectivo             Marta Ruiz           3,75
Patrones de Diseno        Diego Alonso         0,00
Refactorizacion           Nuria Vidal         20,00

TOTAL: 23.75 EUR

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

    salida.println("linea 1");
    salida.println("linea 2");

    // COMPROBACION OBLIGATORIA en codigo serio.
    // checkError() vacia el buffer y devuelve true si HA HABIDO algun fallo
    // en cualquier momento desde que se abrio.
    if (salida.checkError()) {
        throw new IOException("Fallo al escribir el informe (detectado por checkError)");
    }
}

// Estos DOS abren el fichero por su cuenta, con el charset de la plataforma
// en las versiones antiguas. Son comodos y traicioneros.
new PrintWriter("salida.txt");
new PrintWriter(new File("salida.txt"));

// Con charset explicito (Java 10+): correcto
new PrintWriter("salida.txt", StandardCharsets.UTF_8);

// Envolviendo un Writer que tu controlas: la forma mas clara y flexible
new PrintWriter(new FileWriter("salida.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 linea\n");
        System.out.println("Tras write, tamano en disco: " + tamano());   // 0

        w.flush();
        System.out.println("Tras flush, tamano en disco: " + tamano());   // 15

        w.write("Segunda linea\n");
        System.out.println("Tras 2o write, tamano:       " + tamano());   // 15

        w.close();
        System.out.println("Tras close, tamano en disco: " + tamano());   // 29
    }

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

Tras write, tamano en disco: 0
Tras flush, tamano en disco: 15
Tras 2o write, tamano:       15
Tras close, tamano en disco: 29

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

public class SinCerrar {

    public static void main(String[] args) throws Exception {
        // MAL A PROPOSITO: sin try-with-resources y sin close
        FileWriter w = new FileWriter("sin-cerrar.txt", StandardCharsets.UTF_8);
        w.write("Esta linea puede no llegar nunca al disco.\n");

        System.out.println("Terminando sin cerrar...");
        // main termina aqui. No hay close(). No hay flush().
    }
}

try (FileWriter w = new FileWriter("bien-cerrado.txt", StandardCharsets.UTF_8)) {
    w.write("Esta linea SI llega al disco.\n");
}   // close() garantizado: con exito, con excepcion y con 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 tiene 'ñ' ni '€'
        try (FileWriter w = new FileWriter("ascii.txt", StandardCharsets.US_ASCII)) {
            w.write("Patrones de Diseño cuestan 45 €");
        }
        // NO lanza excepcion. Sustituye lo no representable por '?'.
        // En el fichero queda: "Patrones de Dise?o cuestan 45 ?"
    }
}

// SIEMPRE, en cada apertura de escritura de texto
new FileWriter(ruta, StandardCharsets.UTF_8);
new FileWriter(ruta, StandardCharsets.UTF_8, ANADIR);
new PrintWriter(new FileWriter(ruta, StandardCharsets.UTF_8));

package com.nexussoftware.bibliotech.infraestructura;

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

/** Convenciones de formato de todos los ficheros de BiblioTech. */
public final class FormatoFicheros {

    /** Charset unico de todos los ficheros de texto del sistema. */
    public static final Charset CHARSET = StandardCharsets.UTF_8;

    /** Separador de campos de los ficheros tabulados. */
    public static final String SEPARADOR_CAMPOS = ";";

    /** Prefijo de las lineas de comentario. */
    public static final String COMENTARIO = "#";

    private FormatoFicheros() { }
}

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

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

public class EscrituraConManejo {

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

    public void exportar(String ruta, String contenido) throws CatalogoNoAccesibleException {
        try (FileWriter w = new FileWriter(ruta, StandardCharsets.UTF_8)) {
            w.write(contenido);

        } catch (FileNotFoundException e) {
            // Problema de UBICACION o PERMISOS: el usuario puede corregirlo
            LOG.log(Level.WARNING, "No se puede escribir en "
                    + new java.io.File(ruta).getAbsolutePath(), e);
            throw new CatalogoNoAccesibleException(ruta, e);   // 06-04, con la causa

        } catch (IOException e) {
            // Problema DURANTE la escritura: disco lleno, red caida...
            LOG.log(Level.SEVERE, "Fallo de E/S escribiendo " + ruta, e);
            throw new CatalogoNoAccesibleException(ruta, e);
        }
    }
}

// PELIGROSO: regenera el catalogo completo sobrescribiendo el fichero bueno
try (PrintWriter w = new PrintWriter(
        new FileWriter("datos/catalogo.txt", StandardCharsets.UTF_8))) {

    for (Material m : catalogo.listar()) {       // 10 000 materiales
        w.println(serializar(m));
    }
    // Si falla en el material 6 000 (disco lleno, excepcion en serializar,
    // el proceso muere), el fichero queda con 6 000 lineas y el catalogo
    // ORIGINAL YA NO EXISTE: se trunco al abrir.
}

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;

/**
 * Escritura atomica de ficheros de texto.
 *
 * Escribe en un fichero temporal y, SOLO si todo ha ido bien, lo renombra
 * sobre el definitivo. Garantiza que el fichero destino nunca queda a medias.
 *
 * Es el equivalente en disco de la compensacion en finally de 06-05: si la
 * operacion no se completa, el estado anterior se conserva intacto.
 */
public final class EscrituraAtomica {

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

    private static final String SUFIJO_TEMPORAL = ".tmp";

    private EscrituraAtomica() { }

    /**
     * Contrato de lo que se va a escribir. Interfaz funcional (04-06):
     * permite pasar la logica de escritura como lambda.
     *
     * No es java.util.function.Consumer porque necesitamos que pueda
     * declarar IOException, y Consumer.accept() no la declara.
     */
    @FunctionalInterface
    public interface Contenido {
        void escribirEn(PrintWriter salida) throws IOException;
    }

    /**
     * Escribe de forma atomica.
     *
     * @param destino   fichero final
     * @param contenido que escribir
     * @throws IOException si falla la escritura o el renombrado
     */
    public static void escribir(File destino, Contenido contenido) throws IOException {
        File temporal = new File(destino.getAbsolutePath() + SUFIJO_TEMPORAL);

        // 1. Asegurar que existe el directorio padre (FileWriter no lo crea)
        File padre = destino.getAbsoluteFile().getParentFile();
        if (padre != null && !padre.exists() && !padre.mkdirs()) {
            throw new IOException("No se pudo crear el directorio " + padre.getAbsolutePath());
        }

        boolean completado = false;
        try {
            // 2. Escribir TODO en el temporal
            try (PrintWriter salida = new PrintWriter(
                    new FileWriter(temporal, StandardCharsets.UTF_8))) {

                contenido.escribirEn(salida);

                // PrintWriter se traga las IOException: hay que preguntarle
                if (salida.checkError()) {
                    throw new IOException("Fallo al escribir en "
                            + temporal.getAbsolutePath());
                }
            }   // close() garantizado: aqui el temporal esta cerrado y completo

            // 3. Renombrar SOLO si llegamos hasta aqui
            if (!renombrar(temporal, destino)) {
                throw new IOException("No se pudo renombrar "
                        + temporal.getName() + " sobre " + destino.getName());
            }
            completado = true;
            LOG.fine(() -> "Escritura atomica completada: " + destino.getAbsolutePath());

        } finally {
            // 4. COMPENSACION (06-05): si no se completo, no dejar basura.
            //    El destino original sigue intacto porque nunca se abrio.
            if (!completado && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Quedo un fichero temporal sin borrar: "
                        + temporal.getAbsolutePath());
            }
        }
    }

    /**
     * Renombra el temporal sobre el destino.
     *
     * File.renameTo devuelve un boolean mudo (07-01) y en Windows falla si
     * el destino existe. De ahi el borrado previo. En 07-06 esto se resuelve
     * con Files.move y ATOMIC_MOVE, que es la forma correcta.
     */
    private static boolean renombrar(File temporal, File destino) {
        if (destino.exists() && !destino.delete()) {
            return false;
        }
        return temporal.renameTo(destino);
    }
}

EscrituraAtomica.escribir(new File("datos/catalogo.txt"), salida -> {
    salida.println("# Catalogo de BiblioTech");
    for (Material m : catalogo.listar()) {
        salida.printf("%s;%s;%s;%b%n",
                m.getTipo(), m.getReferencia(), m.getTitulo(), m.estaDisponible());
    }
});

package com.nexussoftware.bibliotech.infraestructura;

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

/**
 * Bloqueo entre procesos basado en la existencia de un fichero.
 *
 * AutoCloseable (06-06): el bloqueo se libera al salir del try, se salga
 * como se salga. Sin esa garantia, un bloqueo huerfano deja el sistema
 * inutilizable hasta que alguien borre el fichero a mano.
 */
public class BloqueoFichero implements AutoCloseable {

    private final File bloqueo;
    private boolean adquirido = false;

    public BloqueoFichero(String rutaProtegida) throws IOException {
        this.bloqueo = new File(rutaProtegida + ".lock");

        // createNewFile() es ATOMICO: comprueba y crea en una sola operacion.
        // Por eso sirve como bloqueo y un exists() + create() NO serviria:
        // entre las dos llamadas cabe el otro proceso (TOCTOU, 06-07).
        if (!bloqueo.createNewFile()) {
            throw new IOException("El fichero '" + rutaProtegida
                    + "' esta siendo usado por otro proceso"
                    + " (existe " + bloqueo.getName() + ")");
        }
        adquirido = true;
        bloqueo.deleteOnExit();      // red de seguridad ante una salida brusca
    }

    @Override
    public void close() {
        if (!adquirido) {
            return;                  // idempotente (06-06)
        }
        adquirido = false;
        if (!bloqueo.delete()) {
            System.err.println("Aviso: no se pudo liberar " + bloqueo.getAbsolutePath());
        }
    }
}

try (BloqueoFichero lock = new BloqueoFichero("datos/catalogo.txt")) {
    EscrituraAtomica.escribir(new File("datos/catalogo.txt"), salida -> { /* ... */ });
}   // el bloqueo se libera aqui, pase lo que pase

/** Conserva la version anterior antes de sobrescribir. */
private static void hacerCopiaSeguridad(File fichero) {
    if (!fichero.exists()) {
        return;
    }
    File copia = new File(fichero.getAbsolutePath() + ".bak");
    if (copia.exists()) {
        copia.delete();
    }
    if (!fichero.renameTo(copia)) {
        LOG.warning("No se pudo hacer copia de seguridad de " + fichero.getName());
    }
}

package com.nexussoftware.bibliotech.servicio;

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

/**
 * Exporta el catalogo y el registro de prestamos de BiblioTech a ficheros
 * de texto, de forma ATOMICA: el fichero destino nunca queda a medias.
 *
 * Cambio de diseno respecto a 06-06: esta clase ya NO es Closeable.
 * No mantiene ningun fichero abierto entre llamadas; cada exportacion
 * abre, escribe y cierra dentro de EscrituraAtomica. Un objeto que no
 * posee recursos vivos no debe ser cerrable: seria una promesa vacia.
 *
 * El formato es el que lee CargadorCatalogo (07-01). Ambos comparten las
 * constantes de FormatoFicheros para que no puedan discrepar.
 */
public class ExportadorCatalogo {

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

    private static final String CABECERA_CATALOGO =
            FormatoFicheros.COMENTARIO + " Catalogo de BiblioTech - Nexus Software";
    private static final String CAMPOS_CATALOGO =
            FormatoFicheros.COMENTARIO + " tipo;referencia;titulo;autor;anio";

    private final File directorio;

    public ExportadorCatalogo(String directorioDatos) {
        this.directorio = new File(
                Objects.requireNonNull(directorioDatos, "El directorio no puede ser nulo"));
    }

    /**
     * Exporta el catalogo completo.
     *
     * @return numero de materiales escritos
     * @throws IOException si no se pudo completar la escritura
     */
    public int exportarCatalogo(Catalogo catalogo) throws IOException {
        Objects.requireNonNull(catalogo, "El catalogo no puede ser nulo");

        List<Material> materiales = catalogo.listar();
        File destino = new File(directorio, "catalogo.txt");

        long inicio = System.nanoTime();

        EscrituraAtomica.escribir(destino, salida -> {
            salida.println(CABECERA_CATALOGO);
            salida.println(CAMPOS_CATALOGO);
            for (Material m : materiales) {
                salida.println(serializar(m));
            }
        });

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

        // Logger, nunca System.out para diagnostico (06-07). Forma perezosa.
        LOG.info(() -> String.format("Catalogo exportado: %d materiales en %s (%.1f ms)",
                materiales.size(), destino.getAbsolutePath(), ms));

        return materiales.size();
    }

    /**
     * Serializa un material a una linea.
     *
     * Los campos se saneen: un ';' dentro de un titulo romperia el fichero
     * al releerlo. Aqui se sustituye; en 07-07 se hara BIEN, entrecomillando
     * y escapando segun la convencion CSV.
     */
    private String serializar(Material m) {
        String sep = FormatoFicheros.SEPARADOR_CAMPOS;

        if (m instanceof Libro libro) {                  // patron de 03-06
            return String.join(sep,
                    "LIBRO",
                    sanear(libro.getIsbn()),
                    sanear(libro.getTitulo()),
                    sanear(libro.getAutor()),
                    String.valueOf(libro.getAnioPublicacion()));
        }
        return String.join(sep,
                m.getTipo().toUpperCase(),
                sanear(m.getReferencia()),
                sanear(m.getTitulo()),
                "-",
                "0");
    }

    /** Elimina separadores y saltos de linea que romperian el formato. */
    private String sanear(String valor) {
        if (valor == null) {
            return "";
        }
        return valor.replace(FormatoFicheros.SEPARADOR_CAMPOS, ",")
                    .replace("\n", " ")
                    .replace("\r", " ")
                    .trim();
    }

    /**
     * Anade una linea al registro de auditoria de prestamos.
     *
     * ESTE fichero SI se abre en modo ANADIR: es un historico acumulativo,
     * no un fichero que se regenera. No lleva escritura atomica porque no
     * hay nada que reemplazar; solo se agrega al final.
     */
    public void registrarPrestamo(Prestamo prestamo, String operacion) {
        Objects.requireNonNull(prestamo, "El prestamo no puede ser nulo");

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

        // El 'true' final es ANADIR. Sin el, cada llamada borraria el historico.
        try (PrintWriter salida = new PrintWriter(
                new java.io.FileWriter(auditoria, FormatoFicheros.CHARSET, true))) {

            salida.printf("%s;%s;%s;%s%n",
                    operacion,
                    prestamo.getReferencia(),
                    prestamo.getMaterial().getReferencia(),
                    prestamo.getTitular().getIdentificador());

            if (salida.checkError()) {
                throw new IOException("Fallo escribiendo en " + auditoria.getAbsolutePath());
            }

        } catch (IOException e) {
            // POLITICA: la auditoria NO debe tumbar la operacion de negocio.
            // El prestamo ya se ha registrado en memoria y es valido.
            // Se degrada: se avisa en el log y se sigue (06-07).
            LOG.log(Level.WARNING, "No se pudo auditar la operacion "
                    + operacion + " de " + prestamo.getReferencia(), e);
        }
    }
}

package com.nexussoftware.bibliotech.presentacion;

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

import com.nexussoftware.bibliotech.servicio.Catalogo;
import com.nexussoftware.bibliotech.servicio.CargadorCatalogo;
import com.nexussoftware.bibliotech.servicio.ExportadorCatalogo;
import com.nexussoftware.bibliotech.infraestructura.ConfiguracionLog;

public class BiblioTechApp {

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

    public static void main(String[] args) {
        ConfiguracionLog.inicializar();

        Catalogo catalogo = new CargadorCatalogo(DIRECTORIO_DATOS + "/catalogo.txt").cargar();
        ExportadorCatalogo exportador = new ExportadorCatalogo(DIRECTORIO_DATOS);

        // Guardado al salir. Cubre la salida normal y Ctrl+C; NO cubre kill -9.
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                int n = exportador.exportarCatalogo(catalogo);
                LOG.info("Catalogo guardado al salir: " + n + " materiales");
            } catch (IOException e) {
                LOG.log(Level.SEVERE, "NO SE PUDO GUARDAR EL CATALOGO AL SALIR", e);
            }
        }, "guardado-final"));

        System.out.println("BiblioTech - Nexus Software");
        System.out.println("Materiales en catalogo: " + catalogo.tamano());

        new MenuBiblioTech(catalogo, exportador).ejecutar();
    }
}

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;

/**
 * Demostracion empirica del parametro append.
 */
public class DemoAppend {

    /** Nombres para el boolean: evita el 'true' suelto e ilegible. */
    private static final boolean ANADIR       = true;
    private static final boolean SOBRESCRIBIR = false;

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

    public static void escribirLinea(String ruta, String texto, boolean anadir)
            throws IOException {
        try (FileWriter w = new FileWriter(ruta, StandardCharsets.UTF_8, anadir)) {
            w.write(texto);
            w.write('\n');
        }   // close() vacia el buffer: sin el, el fichero quedaria vacio
    }

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

        System.out.println("    tamano: " + 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("    lineas: " + n);
        } catch (IOException e) {
            System.out.println("    error al leer: " + e.getMessage());
        }
    }

    public static void main(String[] args) throws IOException {
        File f = new File(RUTA);
        if (f.exists() && !f.delete()) {
            System.err.println("No se pudo borrar el fichero previo");
            return;
        }

        System.out.println("=== EXPERIMENTO 1: SIN append (sobrescribir) ===");
        for (int i = 1; i <= 3; i++) {
            escribirLinea(RUTA, "Operacion numero " + i, SOBRESCRIBIR);
            System.out.println("  Tras escribir la linea " + i + ":");
            mostrar(RUTA);
        }

        f.delete();

        System.out.println();
        System.out.println("=== EXPERIMENTO 2: CON append (anadir) ===");
        for (int i = 1; i <= 3; i++) {
            escribirLinea(RUTA, "Operacion numero " + i, ANADIR);
            System.out.println("  Tras escribir la linea " + i + ":");
            mostrar(RUTA);
        }

        // CONCLUSION: sin append, cada escritura TRUNCA el fichero a cero
        // en el momento de abrirlo, asi que solo sobrevive la ultima linea.
        // Con append, el puntero se situa al final y el contenido crece.
    }
}

=== EXPERIMENTO 1: SIN append (sobrescribir) ===
  Tras escribir la linea 1:
    tamano: 20 bytes
      | Operacion numero 1
    lineas: 1
  Tras escribir la linea 2:
    tamano: 20 bytes
      | Operacion numero 2
    lineas: 1
  Tras escribir la linea 3:
    tamano: 20 bytes
      | Operacion numero 3
    lineas: 1

=== EXPERIMENTO 2: CON append (anadir) ===
  Tras escribir la linea 1:
    tamano: 20 bytes
      | Operacion numero 1
    lineas: 1
  Tras escribir la linea 2:
    tamano: 40 bytes
      | Operacion numero 1
      | Operacion numero 2
    lineas: 2
  Tras escribir la linea 3:
    tamano: 60 bytes
      | Operacion numero 1
      | Operacion numero 2
      | Operacion numero 3
    lineas: 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;

/**
 * Escritura atomica con verificacion previa al renombrado.
 *
 * Anade una comprobacion de integridad ANTES de sustituir el fichero bueno:
 * si el resultado no es el esperado, el original se conserva intacto.
 */
public final class EscrituraAtomicaVerificada {

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

    private static final String SUFIJO_TEMPORAL = ".tmp";

    private EscrituraAtomicaVerificada() { }

    @FunctionalInterface
    public interface Contenido {
        void escribirEn(PrintWriter salida) throws IOException;
    }

    /**
     * Escribe de forma atomica verificando el resultado.
     *
     * @param lineasEsperadas numero de lineas que DEBE tener el resultado
     * @throws IOException si falla la escritura o la verificacion
     */
    public static void escribirVerificado(File destino, Contenido contenido,
                                          int lineasEsperadas) throws IOException {

        File temporal = new File(destino.getAbsolutePath() + SUFIJO_TEMPORAL);

        File padre = destino.getAbsoluteFile().getParentFile();
        if (padre != null && !padre.exists() && !padre.mkdirs()) {
            throw new IOException("No se pudo crear el directorio " + padre.getAbsolutePath());
        }

        boolean completado = false;
        try {
            // ---- FASE 1: escribir en el temporal ----
            try (PrintWriter salida = new PrintWriter(
                    new FileWriter(temporal, StandardCharsets.UTF_8))) {

                contenido.escribirEn(salida);

                if (salida.checkError()) {
                    throw new IOException("Fallo de escritura en " + temporal.getName());
                }
            }

            // ---- FASE 2: verificar ANTES de tocar el destino ----
            long tamano = temporal.length();
            if (tamano == 0) {
                throw new IOException("El fichero temporal quedo vacio; no se sustituye "
                        + destino.getName());
            }

            int lineasReales = contarLineas(temporal);
            if (lineasReales != lineasEsperadas) {
                throw new IOException(String.format(
                        "Verificacion fallida en %s: se esperaban %d lineas y hay %d. "
                                + "El fichero original NO se ha modificado.",
                        destino.getName(), lineasEsperadas, lineasReales));
            }

            LOG.fine(() -> String.format("Verificacion OK: %d lineas, %d bytes",
                    lineasReales, tamano));

            // ---- FASE 3: sustituir. Solo si todo lo anterior fue bien ----
            if (destino.exists() && !destino.delete()) {
                throw new IOException("No se pudo eliminar el destino " + destino.getName());
            }
            if (!temporal.renameTo(destino)) {
                throw new IOException("No se pudo renombrar " + temporal.getName());
            }

            completado = true;
            LOG.info(() -> String.format("Escritura verificada de %s: %d lineas, %d bytes",
                    destino.getAbsolutePath(), lineasEsperadas, tamano));

        } finally {
            // COMPENSACION (06-05): sin basura, y con el original intacto
            if (!completado && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sin borrar: " + temporal.getAbsolutePath());
            }
        }
    }

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

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

    public static void main(String[] args) throws IOException {
        File destino = new File("datos/catalogo-verificado.txt");

        // 1. Escritura correcta de 3 lineas
        escribirVerificado(destino, salida -> {
            salida.println("LIBRO;978-0000000001;Java Efectivo;Bloch;2018");
            salida.println("LIBRO;978-0000000002;Patrones de Diseno;Gamma;1994");
            salida.println("LIBRO;978-0000000003;Refactorizacion;Fowler;1999");
        }, 3);

        System.out.println("Tras la escritura correcta: "
                + destino.length() + " bytes, "
                + contarLineas(destino) + " lineas");

        // 2. Escritura que FALLA a mitad
        try {
            escribirVerificado(destino, salida -> {
                salida.println("LIBRO;978-0000000004;Nuevo libro;Autor;2024");
                // Fallo simulado: disco lleno, error de serializacion, lo que sea
                throw new IOException("Fallo simulado a mitad de la exportacion");
            }, 4);

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

        // 3. COMPROBACION CLAVE: el fichero bueno sigue ahi, entero
        System.out.println("Tras el fallo:             "
                + destino.length() + " bytes, "
                + contarLineas(destino) + " lineas");

        System.out.println("¿Quedo basura .tmp? "
                + new File(destino.getAbsolutePath() + ".tmp").exists());

        // 4. Escritura con numero de lineas incorrecto: se rechaza
        try {
            escribirVerificado(destino, salida -> salida.println("Solo una linea"), 5);
        } catch (IOException e) {
            System.out.println("Verificacion: " + e.getMessage());
        }

        System.out.println("Tras la verificacion fallida: "
                + contarLineas(destino) + " lineas (intacto)");
    }
}

Tras la escritura correcta: 138 bytes, 3 lineas
Fallo capturado: Fallo simulado a mitad de la exportacion
Tras el fallo:             138 bytes, 3 lineas
¿Quedo basura .tmp? false
Verificacion: Verificacion fallida en catalogo-verificado.txt: se esperaban 5 lineas y hay 1. El fichero original NO se ha modificado.
Tras la verificacion fallida: 3 lineas (intacto)

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;

/**
 * Registro de auditoria de BiblioTech con rotacion por tamano.
 *
 * Modo ANADIR: el fichero crece, no se regenera. Por eso NO usa escritura
 * atomica: no hay nada que reemplazar.
 *
 * Separador de linea fijo '\n': es un fichero de DATOS que se puede comparar
 * entre maquinas, no un informe para leer en pantalla (apartado 8).
 */
public class AuditoriaBiblioTech {

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

    private static final boolean ANADIR = true;
    private static final String  SALTO  = "\n";
    private static final String  SEP    = ";";

    /** 1 KB, pequeno a proposito para poder probar la rotacion. */
    private static final long TAMANO_MAXIMO = 1024L;

    /** Ficheros historicos que se conservan: auditoria-1 .. auditoria-3. */
    private static final int MAX_HISTORICOS = 3;

    private final File directorio;
    private final String nombreBase;

    private int operacionesRegistradas = 0;
    private int rotaciones = 0;
    private int fallos = 0;

    public AuditoriaBiblioTech(String directorio) {
        this.directorio = new File(
                Objects.requireNonNull(directorio, "El directorio no puede ser nulo"));
        this.nombreBase = "auditoria";

        if (!this.directorio.exists() && !this.directorio.mkdirs()) {
            LOG.warning("No se pudo crear " + this.directorio.getAbsolutePath());
        }
    }

    /**
     * Registra una operacion.
     *
     * POLITICA: un fallo de auditoria NUNCA se propaga. La operacion de
     * negocio ya es valida; perder su rastro es una degradacion aceptable
     * y se avisa en el log (06-07).
     */
    public void registrar(String operacion, String referencia, String idEmpleado) {
        Objects.requireNonNull(operacion, "La operacion no puede ser nula");

        File actual = new File(directorio, nombreBase + ".txt");

        try {
            // 1. Rotar ANTES de escribir, si toca
            if (actual.exists() && actual.length() >= TAMANO_MAXIMO) {
                rotar(actual);
            }

            // 2. Anadir la linea. El 'true' es lo que hace que esto sea
            //    un historico y no un fichero de una sola linea.
            try (PrintWriter salida = new PrintWriter(
                    new FileWriter(actual, StandardCharsets.UTF_8, ANADIR))) {

                salida.write(String.join(SEP, operacion, referencia, idEmpleado));
                salida.write(SALTO);

                if (salida.checkError()) {
                    throw new IOException("Fallo escribiendo en " + actual.getAbsolutePath());
                }
            }
            operacionesRegistradas++;

        } catch (IOException e) {
            fallos++;
            LOG.log(Level.WARNING, "No se pudo auditar " + operacion
                    + " de " + referencia, e);
            // Sin relanzar: la degradacion es deliberada
        }
    }

    /**
     * Desplaza los historicos: -2 pasa a -3, -1 pasa a -2, el actual a -1.
     *
     * Se recorre de MAYOR a MENOR. Al reves, el primer renombrado
     * machacaria el siguiente antes de haberlo desplazado.
     */
    private void rotar(File actual) throws IOException {
        // El mas antiguo se pierde
        File masAntiguo = historico(MAX_HISTORICOS);
        if (masAntiguo.exists() && !masAntiguo.delete()) {
            throw new IOException("No se pudo borrar " + masAntiguo.getName());
        }

        for (int i = MAX_HISTORICOS - 1; i >= 1; i--) {
            File origen  = historico(i);
            File destino = historico(i + 1);
            if (origen.exists() && !origen.renameTo(destino)) {
                throw new IOException("No se pudo rotar " + origen.getName());
            }
        }

        if (!actual.renameTo(historico(1))) {
            throw new IOException("No se pudo rotar " + actual.getName());
        }

        rotaciones++;
        LOG.fine(() -> "Auditoria rotada (rotacion numero " + rotaciones + ")");
    }

    private File historico(int n) {
        return new File(directorio, nombreBase + "-" + n + ".txt");
    }

    public int getOperacionesRegistradas() { return operacionesRegistradas; }
    public int getRotaciones()             { return rotaciones; }
    public int getFallos()                 { return fallos; }

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

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

        String[] operaciones = { "PRESTAMO", "DEVOLUCION", "ALTA", "BAJA" };
        String[] empleados   = { "E-001", "E-002", "E-003" };

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

        System.out.println("=== AUDITORIA ===");
        System.out.printf("  Operaciones registradas: %d%n",
                auditoria.getOperacionesRegistradas());
        System.out.printf("  Rotaciones realizadas  : %d%n", auditoria.getRotaciones());
        System.out.printf("  Fallos                 : %d%n", auditoria.getFallos());

        System.out.println("  --- Ficheros ---");
        File dir = new File("datos/auditoria");
        File[] ficheros = dir.listFiles();      // puede ser null: se comprueba
        if (ficheros != null) {
            java.util.Arrays.sort(ficheros);    // 05-09
            for (File f : ficheros) {
                System.out.printf("    %-20s %6d bytes%n", f.getName(), f.length());
            }
        }
    }
}

=== AUDITORIA ===
  Operaciones registradas: 200
  Rotaciones realizadas  : 4
  Fallos                 : 0
  --- Ficheros ---
    auditoria-1.txt        1043 bytes
    auditoria-2.txt        1044 bytes
    auditoria-3.txt        1043 bytes
    auditoria.txt           836 bytes