File f = new File("/datos/catalogo.txt");
if (!f.delete()) {
    // ¿Por que? ¿No existia? ¿No tengo permiso? ¿Estaba abierto?
    // ¿Era un directorio no vacio? La API no lo dice.
}

File[] hijos = directorio.listFiles();
for (File h : hijos) {          // NullPointerException si el directorio no existe
    // ...
}

// java.io: copiar un fichero
try (InputStream in = new BufferedInputStream(new FileInputStream(origen));
     OutputStream out = new BufferedOutputStream(new FileOutputStream(destino))) {
    byte[] bloque = new byte[8192];
    int leidos;
    while ((leidos = in.read(bloque)) != -1) {
        out.write(bloque, 0, leidos);
    }
}

// NIO.2: lo mismo
Files.copy(origen, destino, StandardCopyOption.REPLACE_EXISTING);

import java.nio.file.Path;
import java.nio.file.Paths;

public class ConstruirRutas {

    public static void main(String[] args) {
        // Java 11+: la forma recomendada
        Path p1 = Path.of("datos", "catalogo.txt");

        // Java 7-10: equivalente, todavia muy comun en codigo existente
        Path p2 = Paths.get("datos", "catalogo.txt");

        // Ruta completa en una cadena
        Path p3 = Path.of("datos/informes/2026/enero.txt");

        // Ruta absoluta
        Path p4 = Path.of("/home/marta/bibliotech/datos/catalogo.txt");

        // Desde un URI
        Path p5 = Path.of(java.net.URI.create("file:///home/marta/catalogo.txt"));

        System.out.println(p1);      // datos/catalogo.txt
        System.out.println(p1.equals(p2));   // true
    }
}

import java.nio.file.Path;

public class ConsultarRutas {

    public static void main(String[] args) {
        Path p = Path.of("/home/marta/bibliotech/datos/catalogo.txt");

        System.out.println("Ruta completa  : " + p);
        System.out.println("Nombre         : " + p.getFileName());     // catalogo.txt
        System.out.println("Directorio     : " + p.getParent());       // .../datos
        System.out.println("Raiz           : " + p.getRoot());         // /
        System.out.println("¿Es absoluta?  : " + p.isAbsolute());      // true
        System.out.println("Segmentos      : " + p.getNameCount());    // 5

        // Iterar los segmentos: Path es Iterable<Path>
        System.out.println("  Recorrido:");
        for (Path segmento : p) {
            System.out.println("    " + segmento);
        }

        // Acceso por indice
        System.out.println("Segmento 0     : " + p.getName(0));        // home
        System.out.println("Segmento 3     : " + p.getName(3));        // datos

        // Subruta [inicio, fin)
        System.out.println("Subruta 1..3   : " + p.subpath(1, 3));     // marta/bibliotech

        // Comprobaciones
        System.out.println("¿Empieza por /home? " + p.startsWith("/home"));   // true
        System.out.println("¿Acaba en .txt?     "
                + p.getFileName().toString().endsWith(".txt"));               // true
    }
}

Path p = Path.of("/home/marta/datos");
p.startsWith("/home/mar");      // false: "mar" no es un segmento completo
p.startsWith("/home/marta");    // true

Path base = Path.of("/home/marta/bibliotech");

base.resolve("datos/catalogo.txt");
// /home/marta/bibliotech/datos/catalogo.txt

base.resolve("/etc/config");
// /etc/config   <-- si el argumento es ABSOLUTO, sustituye a la base

base.resolve("");
// /home/marta/bibliotech

Path catalogo = Path.of("/home/marta/bibliotech/datos/catalogo.txt");

catalogo.resolveSibling("catalogo.txt.tmp");
// /home/marta/bibliotech/datos/catalogo.txt.tmp

catalogo.resolveSibling("catalogo.bak");
// /home/marta/bibliotech/datos/catalogo.bak

Path base    = Path.of("/home/marta/bibliotech");
Path informe = Path.of("/home/marta/bibliotech/datos/informes/enero.txt");

base.relativize(informe);
// datos/informes/enero.txt

informe.relativize(base);
// ../../..

Path fea = Path.of("/home/marta/./bibliotech/../bibliotech/datos/../datos/catalogo.txt");
fea.normalize();
// /home/marta/bibliotech/datos/catalogo.txt

/**
 * Comprueba que una ruta pedida por el usuario queda DENTRO del directorio
 * de datos.
 *
 * Sin esta comprobacion, un nombre como "../../etc/passwd" permitiria salir
 * del directorio permitido. Es la vulnerabilidad conocida como "path
 * traversal", y es de las mas frecuentes en aplicaciones que aceptan nombres
 * de fichero del usuario. La seguridad de aplicaciones se trata en 12-07.
 */
public static Path resolverSeguro(Path directorioBase, String nombrePedido) {
    Path base = directorioBase.toAbsolutePath().normalize();
    Path candidata = base.resolve(nombrePedido).normalize();

    if (!candidata.startsWith(base)) {
        throw new IllegalArgumentException(
                "Ruta fuera del directorio permitido: " + nombrePedido);
    }
    return candidata;
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.LinkOption;

Path p = Path.of("datos/catalogo.txt");

Files.exists(p);            // true si existe y se puede comprobar
Files.notExists(p);         // true si NO existe y se puede comprobar
Files.isRegularFile(p);     // fichero normal (no directorio, no enlace)
Files.isDirectory(p);
Files.isSymbolicLink(p);
Files.isReadable(p);
Files.isWritable(p);
Files.isExecutable(p);
Files.isHidden(p);          // lanza IOException

// Sin seguir enlaces simbolicos
Files.exists(p, LinkOption.NOFOLLOW_LINKS);

// Un fichero vacio. Lanza FileAlreadyExistsException si ya existe.
Files.createFile(Path.of("datos/nuevo.txt"));

// Un directorio. Lanza NoSuchFileException si falta el padre.
Files.createDirectory(Path.of("datos"));

// Un directorio Y TODOS SUS PADRES. No falla si ya existen.
Files.createDirectories(Path.of("datos/informes/2026/enero"));

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

// NIO.2: una linea, idempotente, y con excepcion informativa si falla
Files.createDirectories(destino.getParent());

// Borra. Lanza NoSuchFileException si no existe.
Files.delete(p);

// Borra si existe. Devuelve true si borro algo. NO lanza si no existe.
boolean borrado = Files.deleteIfExists(p);

// java.io: sabes que fallo, no por que
if (!fichero.delete()) {
    System.err.println("No se pudo borrar");
}

// NIO.2: sabes exactamente que paso y puedes actuar en consecuencia
try {
    Files.delete(ruta);
} catch (NoSuchFileException e) {
    LOG.fine(() -> "Ya no estaba: " + ruta);              // no es un problema
} catch (DirectoryNotEmptyException e) {
    LOG.warning(() -> "El directorio tiene contenido: " + ruta);
} catch (AccessDeniedException e) {
    LOG.severe(() -> "Sin permiso para borrar " + ruta);  // esto si hay que mirarlo
} catch (IOException e) {
    LOG.log(Level.SEVERE, "Fallo borrando " + ruta, e);
}

import java.nio.file.StandardCopyOption;

// Copia. Lanza FileAlreadyExistsException si el destino existe.
Files.copy(origen, destino);

// Sobrescribe el destino
Files.copy(origen, destino, StandardCopyOption.REPLACE_EXISTING);

// Conserva fecha de modificacion, propietario y permisos
Files.copy(origen, destino,
        StandardCopyOption.REPLACE_EXISTING,
        StandardCopyOption.COPY_ATTRIBUTES);

// Desde un InputStream a un fichero (07-03)
Files.copy(entrada, destino, StandardCopyOption.REPLACE_EXISTING);

// Desde un fichero a un OutputStream
Files.copy(origen, salida);

// Mueve o renombra
Files.move(origen, destino);

// Sobrescribiendo el destino
Files.move(origen, destino, StandardCopyOption.REPLACE_EXISTING);

// ATOMICO: o esta entero o no esta. Nunca a medias.
Files.move(temporal, destino,
        StandardCopyOption.REPLACE_EXISTING,
        StandardCopyOption.ATOMIC_MOVE);

// 07-02, con java.io: DOS operaciones, con un hueco peligroso entre ellas
if (destino.exists() && !destino.delete()) {    // 1. borrar
    return false;
}
return temporal.renameTo(destino);              // 2. renombrar
// Entre 1 y 2, el fichero destino NO EXISTE. Si el proceso muere ahi,
// te quedas sin nada. Y otro proceso que lea en ese instante no encuentra
// el fichero.

// NIO.2: UNA operacion atomica. No hay hueco.
Files.move(temporal, destino, REPLACE_EXISTING, ATOMIC_MOVE);

package com.nexussoftware.bibliotech.infraestructura;

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.logging.Logger;

/**
 * Escritura atomica con NIO.2.
 *
 * Sustituye a la version de 07-02 escrita con java.io. Misma garantia
 * —el destino nunca queda a medias— en una fraccion del codigo, y con
 * una atomicidad REAL en lugar de la secuencia borrar-mas-renombrar.
 */
public final class EscrituraAtomica {

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

    private EscrituraAtomica() { }

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

    public static void escribir(Path destino, Contenido contenido) throws IOException {
        // 1. Crear el directorio si falta. Idempotente.
        Path directorio = destino.toAbsolutePath().getParent();
        Files.createDirectories(directorio);

        // 2. El temporal, EN EL MISMO DIRECTORIO: ATOMIC_MOVE lo exige.
        //    resolveSibling hace exactamente esto (apartado 3).
        Path temporal = destino.resolveSibling(destino.getFileName() + ".tmp");

        boolean completado = false;
        try {
            // 3. Escribir todo en el temporal. BufferedWriter, no PrintWriter:
            //    sus metodos SI lanzan IOException (07-04).
            try (BufferedWriter salida = Files.newBufferedWriter(
                    temporal, StandardCharsets.UTF_8,
                    StandardOpenOption.CREATE,
                    StandardOpenOption.TRUNCATE_EXISTING,
                    StandardOpenOption.WRITE)) {

                contenido.escribirEn(salida);
            }

            // 4. Sustituir de forma ATOMICA. Una sola operacion.
            Files.move(temporal, destino,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.ATOMIC_MOVE);

            completado = true;
            LOG.fine(() -> "Escritura atomica completada: " + destino);

        } catch (AtomicMoveNotSupportedException e) {
            // Puede pasar si el temporal y el destino estan en sistemas de
            // ficheros distintos. Se degrada a un move no atomico, avisando.
            LOG.warning(() -> "El sistema de ficheros no soporta ATOMIC_MOVE; "
                    + "se sustituye de forma no atomica: " + destino);
            Files.move(temporal, destino, StandardCopyOption.REPLACE_EXISTING);
            completado = true;

        } finally {
            // 5. Compensacion (06-05): sin basura si algo fallo.
            if (!completado) {
                Files.deleteIfExists(temporal);       // no lanza si ya no esta
            }
        }
    }
}

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

Path p = Path.of("datos/catalogo.txt");

// Java 11+: el fichero entero como String
String todo = Files.readString(p, StandardCharsets.UTF_8);

// Todas las lineas en una lista
List<String> lineas = Files.readAllLines(p, StandardCharsets.UTF_8);

// Todos los bytes (para binario)
byte[] bytes = Files.readAllBytes(p);

// Un BufferedReader ya construido (07-04)
try (java.io.BufferedReader lector =
             Files.newBufferedReader(p, StandardCharsets.UTF_8)) {
    String linea;
    while ((linea = lector.readLine()) != null) {
        procesar(linea);
    }
}

// Un InputStream (07-03)
try (java.io.InputStream entrada = Files.newInputStream(p)) {
    // ...
}

// Java 11+: escribir una cadena
Files.writeString(p, "contenido", StandardCharsets.UTF_8);

// Anadiendo al final
Files.writeString(p, "una linea mas\n", StandardCharsets.UTF_8,
        StandardOpenOption.CREATE, StandardOpenOption.APPEND);

// Escribir una coleccion de lineas (anade el salto a cada una)
Files.write(p, lineas, StandardCharsets.UTF_8);

// Escribir bytes
Files.write(p, bytes);

// Un BufferedWriter ya construido
try (java.io.BufferedWriter salida =
             Files.newBufferedWriter(p, StandardCharsets.UTF_8)) {
    salida.write("...");
    salida.newLine();
}

// 07-02, con java.io
try (PrintWriter salida = new PrintWriter(
        new BufferedWriter(new FileWriter(ruta, StandardCharsets.UTF_8)))) {
    for (String linea : lineas) {
        salida.println(linea);
    }
    if (salida.checkError()) {
        throw new IOException("Fallo al escribir");
    }
}

// NIO.2
Files.write(Path.of(ruta), lineas, StandardCharsets.UTF_8);

// SOBRESCRIBIR: crear si falta, vaciar si existe
Files.newBufferedWriter(p, UTF_8,
        StandardOpenOption.CREATE,
        StandardOpenOption.TRUNCATE_EXISTING,
        StandardOpenOption.WRITE);

// ANADIR: crear si falta, escribir al final
Files.newBufferedWriter(p, UTF_8,
        StandardOpenOption.CREATE,
        StandardOpenOption.APPEND);

// CREAR NUEVO: fallar si ya existe. Util como bloqueo (07-02)
Files.newBufferedWriter(p, UTF_8,
        StandardOpenOption.CREATE_NEW,
        StandardOpenOption.WRITE);

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;

public class LeerConLines {

    public static void mostrar(Path fichero) throws IOException {
        // try-with-resources OBLIGATORIO: el flujo mantiene el fichero abierto
        try (Stream<String> lineas = Files.lines(fichero, StandardCharsets.UTF_8)) {

            // forEach: procesa cada linea. La API completa, en 10-04.
            lineas.forEach(System.out::println);
        }
    }
}

public static void contar(Path fichero) throws IOException {
    // Los contadores tienen que ser efectivamente finales para usarlos en
    // una lambda (04-05). Un array de un elemento es el truco clasico;
    // en 10-04 veras formas mejores.
    int[] contadores = new int[2];      // [0] = lineas, [1] = con datos

    try (Stream<String> lineas = Files.lines(fichero, StandardCharsets.UTF_8)) {
        lineas.forEach(linea -> {
            contadores[0]++;
            if (!linea.isBlank() && !linea.startsWith("#")) {
                contadores[1]++;
            }
        });
    }
    System.out.printf("%d lineas, %d con datos%n", contadores[0], contadores[1]);
}

public static void listar(Path directorio) throws IOException {
    try (Stream<Path> hijos = Files.list(directorio)) {
        hijos.forEach(hijo -> System.out.println("  " + hijo.getFileName()));
    }
}

public static void recorrer(Path raiz) throws IOException {
    try (Stream<Path> arbol = Files.walk(raiz)) {
        arbol.forEach(p -> System.out.println("  " + p));
    }
}

/** Limitando la profundidad. */
public static void recorrerHasta(Path raiz, int profundidad) throws IOException {
    try (Stream<Path> arbol = Files.walk(raiz, profundidad)) {
        arbol.forEach(System.out::println);
    }
}

/** Localiza todos los informes de un arbol de directorios. */
public static void localizarInformes(Path raiz) throws IOException {
    try (Stream<Path> arbol = Files.walk(raiz)) {
        arbol.forEach(p -> {
            if (Files.isRegularFile(p) && p.getFileName().toString().endsWith(".informe")) {
                System.out.println("  " + raiz.relativize(p));
            }
        });
    }
}

package com.nexussoftware.bibliotech.util;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.logging.Logger;

/**
 * Recorrido de arboles con control completo, usando walkFileTree.
 *
 * Ventaja decisiva sobre Files.walk: puede DECIDIR que hacer ante cada
 * elemento y ante cada fallo, en lugar de abortar el recorrido entero
 * cuando un solo directorio no es accesible.
 */
public class RecorridoControlado {

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

    /** Calcula el tamano total de un arbol, saltandose lo inaccesible. */
    public static Resultado calcularTamano(Path raiz) throws IOException {
        Resultado resultado = new Resultado();

        Files.walkFileTree(raiz, new SimpleFileVisitor<Path>() {

            /** Antes de entrar en un directorio. */
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                // Saltar directorios ocultos y de trabajo sin entrar en ellos
                String nombre = dir.getFileName().toString();
                if (nombre.startsWith(".") || nombre.equals("tmp")) {
                    return FileVisitResult.SKIP_SUBTREE;
                }
                resultado.directorios++;
                return FileVisitResult.CONTINUE;
            }

            /** Por cada fichero. */
            @Override
            public FileVisitResult visitFile(Path fichero, BasicFileAttributes attrs) {
                resultado.ficheros++;
                resultado.bytes += attrs.size();

                if (attrs.size() > resultado.mayorTamano) {
                    resultado.mayorTamano = attrs.size();
                    resultado.mayorFichero = fichero;
                }
                return FileVisitResult.CONTINUE;
            }

            /**
             * Cuando un fichero o directorio NO se puede visitar.
             *
             * ESTE es el metodo que hace superior a walkFileTree: devolviendo
             * CONTINUE, el recorrido SIGUE. Con Files.walk, un solo directorio
             * sin permisos aborta todo.
             */
            @Override
            public FileVisitResult visitFileFailed(Path fichero, IOException e) {
                resultado.inaccesibles++;
                LOG.fine(() -> "No accesible: " + fichero + " (" + e.getMessage() + ")");
                return FileVisitResult.CONTINUE;
            }

            /** Al salir de un directorio, tras visitar todo su contenido. */
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException e) {
                return FileVisitResult.CONTINUE;
            }
        });

        return resultado;
    }

    public static class Resultado {
        int directorios = 0;
        int ficheros = 0;
        int inaccesibles = 0;
        long bytes = 0;
        long mayorTamano = 0;
        Path mayorFichero = null;

        public String informe() {
            return String.format(
                    "%d directorios, %d ficheros, %.2f MB, %d inaccesibles.%n"
                            + "  Mayor: %s (%.2f MB)",
                    directorios, ficheros, bytes / 1024.0 / 1024.0, inaccesibles,
                    mayorFichero == null ? "(ninguno)" : mayorFichero.getFileName(),
                    mayorTamano / 1024.0 / 1024.0);
        }
    }
}

/** Borra un directorio y todo su contenido. USAR CON MUCHO CUIDADO. */
public static void borrarArbol(Path raiz) throws IOException {
    if (Files.notExists(raiz)) {
        return;
    }
    Files.walkFileTree(raiz, new SimpleFileVisitor<Path>() {

        @Override
        public FileVisitResult visitFile(Path f, BasicFileAttributes attrs)
                throws IOException {
            Files.delete(f);
            return FileVisitResult.CONTINUE;
        }

        /**
         * El directorio se borra DESPUES de su contenido: por eso va en
         * postVisitDirectory y no en pre. Al reves, Files.delete lanzaria
         * DirectoryNotEmptyException.
         */
        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException e)
                throws IOException {
            if (e != null) {
                throw e;                  // no borrar si el recorrido fallo
            }
            Files.delete(dir);
            return FileVisitResult.CONTINUE;
        }
    });
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;

Path p = Path.of("datos/catalogo.txt");

// De uno en uno: cada llamada consulta el sistema de ficheros
long tamano = Files.size(p);
FileTime modificado = Files.getLastModifiedTime(p);

// TODOS DE GOLPE: una sola consulta. Mas eficiente y CONSISTENTE.
BasicFileAttributes attrs = Files.readAttributes(p, BasicFileAttributes.class);

System.out.println("Tamano        : " + attrs.size());
System.out.println("Creado        : " + attrs.creationTime());
System.out.println("Modificado    : " + attrs.lastModifiedTime());
System.out.println("Ultimo acceso : " + attrs.lastAccessTime());
System.out.println("¿Fichero?     : " + attrs.isRegularFile());
System.out.println("¿Directorio?  : " + attrs.isDirectory());
System.out.println("¿Enlace?      : " + attrs.isSymbolicLink());

FileTime momento = Files.getLastModifiedTime(p);

System.out.println(momento);              // 2026-08-05T14:23:11.482Z
System.out.println(momento.toMillis());   // 1785943391482

// Comparar dos ficheros
FileTime a = Files.getLastModifiedTime(rutaA);
FileTime b = Files.getLastModifiedTime(rutaB);
if (a.compareTo(b) > 0) {
    System.out.println("A es mas reciente que B");
}

// Antiguedad en dias, con aritmetica de milisegundos
long diasDeAntiguedad = (System.currentTimeMillis() - momento.toMillis())
        / (1000L * 60 * 60 * 24);

// Cambiar la fecha de modificacion
Files.setLastModifiedTime(p, FileTime.fromMillis(System.currentTimeMillis()));

import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;

try {
    Set<PosixFilePermission> permisos = Files.getPosixFilePermissions(p);
    System.out.println(PosixFilePermissions.toString(permisos));   // rw-r--r--

    // Establecer permisos: solo el propietario puede leer y escribir
    Files.setPosixFilePermissions(p,
            PosixFilePermissions.fromString("rw-------"));

} catch (UnsupportedOperationException e) {
    // En Windows el modelo POSIX no existe: hay que usar ACL
    LOG.fine("Sistema sin permisos POSIX");
}

// Crear el fichero YA con permisos restringidos, en una sola operacion
Files.createFile(p, PosixFilePermissions.asFileAttribute(
        PosixFilePermissions.fromString("rw-------")));

// Fichero temporal en el directorio temporal del sistema
Path temporal = Files.createTempFile("bibliotech-", ".tmp");

// En un directorio concreto: necesario si luego vas a hacer ATOMIC_MOVE
Path temporalLocal = Files.createTempFile(Path.of("datos"), "catalogo-", ".tmp");

// Directorio temporal
Path dirTemporal = Files.createTempDirectory("bibliotech-import-");

Path temporal = Files.createTempFile("bibliotech-", ".tmp");

try (var salida = Files.newBufferedWriter(temporal, StandardCharsets.UTF_8,
        StandardOpenOption.WRITE,
        StandardOpenOption.DELETE_ON_CLOSE)) {    // se borra al cerrar

    salida.write("datos de trabajo");
}
// Aqui el fichero YA NO EXISTE

import java.nio.file.*;

/**
 * Vigilancia de un directorio.
 *
 * NOTA: este bucle es BLOQUEANTE. En una aplicacion real se ejecuta en un
 * hilo aparte, y eso es el modulo 8. Aqui queda como demostracion del
 * mecanismo, no como codigo que meterias en tu main.
 */
public static void vigilar(Path directorio) throws IOException, InterruptedException {

    try (WatchService vigilante = FileSystems.getDefault().newWatchService()) {

        directorio.register(vigilante,
                StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_MODIFY,
                StandardWatchEventKinds.ENTRY_DELETE);

        System.out.println("Vigilando " + directorio + "...");

        while (true) {
            WatchKey clave = vigilante.take();       // BLOQUEA hasta que pase algo

            for (WatchEvent<?> evento : clave.pollEvents()) {
                System.out.printf("  %s: %s%n", evento.kind().name(), evento.context());
            }

            if (!clave.reset()) {                    // el directorio ya no existe
                break;
            }
        }
    }
}

// De File a Path
File f = new File("datos/catalogo.txt");
Path p = f.toPath();

// De Path a File
Path p2 = Path.of("datos/catalogo.txt");
File f2 = p2.toFile();

package com.nexussoftware.bibliotech.infraestructura;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Stream;

/**
 * Capa de persistencia de BiblioTech sobre NIO.2.
 *
 * Sustituye a todo el codigo de java.io de 07-01 a 07-05:
 *   - creacion de directorios     -> Files.createDirectories
 *   - escritura atomica           -> Files.move con ATOMIC_MOVE
 *   - copias rotativas            -> Files.move y Files.deleteIfExists
 *   - localizacion de informes    -> Files.walk
 *   - fallos                      -> excepciones especificas, no boolean mudos
 *
 * Estructura de directorios que gestiona:
 *   datos/
 *     catalogo.txt
 *     auditoria.txt
 *     copias/
 *       catalogo.bak.1  (la mas reciente)
 *       catalogo.bak.2
 *       catalogo.bak.3
 *     informes/
 *       2026/
 *         01/ *.informe
 *     sesiones/
 */
public class AlmacenBiblioTech {

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

    private static final java.nio.charset.Charset CHARSET = StandardCharsets.UTF_8;

    private static final String CATALOGO   = "catalogo.txt";
    private static final String AUDITORIA  = "auditoria.txt";
    private static final String EXT_INFORME = ".informe";

    private static final int COPIAS_CONSERVADAS = 3;

    private final Path raiz;
    private final Path copias;
    private final Path informes;
    private final Path sesiones;

    /**
     * Prepara la estructura de directorios.
     *
     * createDirectories es IDEMPOTENTE: si ya existen, no hace nada y no
     * falla. Se acabo el "if (!existe) crear" con su boolean mudo.
     */
    public AlmacenBiblioTech(String directorioRaiz) throws IOException {
        this.raiz = Path.of(Objects.requireNonNull(directorioRaiz,
                "El directorio no puede ser nulo")).toAbsolutePath().normalize();

        this.copias   = raiz.resolve("copias");
        this.informes = raiz.resolve("informes");
        this.sesiones = raiz.resolve("sesiones");

        Files.createDirectories(copias);
        Files.createDirectories(informes);
        Files.createDirectories(sesiones);

        LOG.config(() -> "Almacen de BiblioTech preparado en " + raiz);
    }

    // ---------------------- ESCRITURA ATOMICA ----------------------

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

    /**
     * Escribe un fichero de forma atomica, tras hacer copia de seguridad.
     *
     * Secuencia:
     *   1. rotar las copias de seguridad existentes
     *   2. copiar el fichero actual a copias/nombre.bak.1
     *   3. escribir el nuevo contenido en un temporal HERMANO del destino
     *   4. moverlo sobre el destino con ATOMIC_MOVE
     */
    public void escribirConCopia(String nombre, Contenido contenido) throws IOException {
        Path destino = raiz.resolve(nombre);

        // 1 y 2: copia de seguridad rotativa
        if (Files.exists(destino)) {
            rotarCopias(nombre);
            Files.copy(destino, copias.resolve(nombre + ".bak.1"),
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.COPY_ATTRIBUTES);
        }

        // 3: temporal HERMANO. ATOMIC_MOVE exige el mismo sistema de ficheros.
        Path temporal = destino.resolveSibling(destino.getFileName() + ".tmp");
        boolean completado = false;

        try {
            try (BufferedWriter salida = Files.newBufferedWriter(temporal, CHARSET,
                    StandardOpenOption.CREATE,
                    StandardOpenOption.TRUNCATE_EXISTING,
                    StandardOpenOption.WRITE)) {

                contenido.escribirEn(salida);
            }

            // 4: sustitucion atomica de verdad
            Files.move(temporal, destino,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.ATOMIC_MOVE);
            completado = true;

            LOG.info(() -> String.format("Escrito %s (%d bytes)",
                    destino.getFileName(), tamanoSeguro(destino)));

        } catch (AtomicMoveNotSupportedException e) {
            LOG.warning(() -> "Sin soporte de ATOMIC_MOVE; sustitucion no atomica");
            Files.move(temporal, destino, StandardCopyOption.REPLACE_EXISTING);
            completado = true;

        } finally {
            if (!completado) {
                Files.deleteIfExists(temporal);      // compensacion (06-05)
            }
        }
    }

    /**
     * Rotacion de copias: .bak.2 pasa a .bak.3, .bak.1 a .bak.2, y la mas
     * antigua se pierde.
     *
     * De MAYOR a MENOR, como en 07-02: al reves, cada renombrado machacaria
     * la copia siguiente antes de haberla desplazado.
     */
    private void rotarCopias(String nombre) throws IOException {
        Files.deleteIfExists(copias.resolve(nombre + ".bak." + COPIAS_CONSERVADAS));

        for (int i = COPIAS_CONSERVADAS - 1; i >= 1; i--) {
            Path origen  = copias.resolve(nombre + ".bak." + i);
            Path destino = copias.resolve(nombre + ".bak." + (i + 1));

            if (Files.exists(origen)) {
                Files.move(origen, destino, StandardCopyOption.REPLACE_EXISTING);
            }
        }
    }

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

    /**
     * Lee el catalogo linea a linea, con memoria constante.
     *
     * Files.newBufferedReader devuelve el BufferedReader de 07-04, con el
     * charset obligatorio y una excepcion especifica si el fichero falta.
     */
    public List<String> leerCatalogo() throws IOException {
        Path fichero = raiz.resolve(CATALOGO);
        List<String> lineas = new ArrayList<>();

        if (Files.notExists(fichero)) {
            // DEGRADACION ELEGANTE (06-07, 07-01): la primera ejecucion no
            // tiene catalogo, y eso es normal, no un fallo.
            LOG.warning(() -> "No hay catalogo en " + fichero
                    + "; se arranca con catalogo vacio");
            return lineas;
        }

        try (BufferedReader lector = Files.newBufferedReader(fichero, CHARSET)) {
            String linea;
            while ((linea = lector.readLine()) != null) {      // bucle canonico (07-04)
                String limpia = linea.trim();
                if (!limpia.isEmpty() && !limpia.startsWith("#")) {
                    lineas.add(limpia);
                }
            }
        }

        LOG.info(() -> "Catalogo leido: " + lineas.size() + " lineas de " + fichero);
        return lineas;
    }

    /** Anade una linea a la auditoria. APPEND explicito: el fichero CRECE. */
    public void auditar(String linea) {
        Path fichero = raiz.resolve(AUDITORIA);

        try (BufferedWriter salida = Files.newBufferedWriter(fichero, CHARSET,
                StandardOpenOption.CREATE,
                StandardOpenOption.APPEND)) {          // imposible de confundir

            salida.write(linea);
            salida.write('\n');                        // fichero de datos: '\n' fijo

        } catch (IOException e) {
            // La auditoria no tumba la operacion de negocio (07-02)
            LOG.log(Level.WARNING, "No se pudo auditar: " + linea, e);
        }
    }

    // ---------------------- INFORMES ----------------------

    /** Guarda un informe en informes/AAAA/MM/nombre.informe. */
    public Path guardarInforme(String anio, String mes, String nombre, String contenido)
            throws IOException {

        Path directorio = informes.resolve(anio).resolve(mes);
        Files.createDirectories(directorio);

        Path fichero = directorio.resolve(nombre + EXT_INFORME);
        Files.writeString(fichero, contenido, CHARSET,
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING,
                StandardOpenOption.WRITE);

        LOG.info(() -> "Informe guardado: " + raiz.relativize(fichero));
        return fichero;
    }

    /**
     * Localiza todos los informes del arbol, ordenados del mas reciente al
     * mas antiguo.
     *
     * Files.walk devuelve un flujo PEREZOSO que HAY QUE CERRAR: mantiene
     * descriptores de directorio abiertos. De ahi el try-with-resources.
     * Se usa solo forEach; la API completa de Streams es 10-04.
     */
    public List<InfoInforme> localizarInformes() throws IOException {
        List<InfoInforme> encontrados = new ArrayList<>();

        try (Stream<Path> arbol = Files.walk(informes)) {
            arbol.forEach(p -> {
                if (!Files.isRegularFile(p)
                        || !p.getFileName().toString().endsWith(EXT_INFORME)) {
                    return;
                }
                try {
                    // readAttributes: UNA consulta para todos los atributos,
                    // en vez de tres llamadas independientes (apartado 10)
                    BasicFileAttributes attrs =
                            Files.readAttributes(p, BasicFileAttributes.class);

                    encontrados.add(new InfoInforme(
                            informes.relativize(p).toString(),
                            attrs.size(),
                            attrs.lastModifiedTime()));

                } catch (IOException e) {
                    LOG.fine(() -> "No se pudo leer atributos de " + p);
                }
            });
        }

        // Mas reciente primero (05-09)
        encontrados.sort(Comparator.comparing(InfoInforme::modificado).reversed());
        return encontrados;
    }

    /**
     * Informacion de un informe localizado.
     *
     * FileTime se muestra con toString() y se compara con compareTo().
     * Su conversion a fechas legibles es java.time, que es 10-05.
     */
    public record InfoInforme(String rutaRelativa, long bytes, FileTime modificado) {

        public String linea() {
            return String.format("%-40s %8d bytes  %s",
                    rutaRelativa, bytes, modificado);
        }

        /** Antiguedad en dias, con aritmetica de milisegundos (10-05 lo hara mejor). */
        public long diasDeAntiguedad() {
            return (System.currentTimeMillis() - modificado.toMillis())
                    / (1000L * 60 * 60 * 24);
        }
    }

    // ---------------------- MANTENIMIENTO ----------------------

    /**
     * Borra los informes con mas de N dias.
     *
     * @return cuantos se borraron
     */
    public int limpiarInformesAntiguos(int diasMaximos) throws IOException {
        int borrados = 0;

        for (InfoInforme info : localizarInformes()) {
            if (info.diasDeAntiguedad() > diasMaximos) {
                Path fichero = informes.resolve(info.rutaRelativa());
                if (Files.deleteIfExists(fichero)) {
                    borrados++;
                    LOG.fine(() -> "Informe antiguo borrado: " + info.rutaRelativa());
                }
            }
        }

        final int total = borrados;
        LOG.info(() -> "Limpieza: " + total + " informes con mas de "
                + diasMaximos + " dias");
        return borrados;
    }

    /** Resumen del espacio ocupado, con walkFileTree para no abortar por un fallo. */
    public String informeDeEspacio() throws IOException {
        long[] datos = new long[2];      // [0] bytes, [1] ficheros

        Files.walkFileTree(raiz, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path f, BasicFileAttributes attrs) {
                datos[0] += attrs.size();
                datos[1]++;
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path f, IOException e) {
                LOG.fine(() -> "No accesible: " + f);
                return FileVisitResult.CONTINUE;      // no aborta el recorrido
            }
        });

        return String.format("%s: %d ficheros, %.2f MB",
                raiz.getFileName(), datos[1], datos[0] / 1024.0 / 1024.0);
    }

    private long tamanoSeguro(Path p) {
        try {
            return Files.size(p);
        } catch (IOException e) {
            return -1;
        }
    }

    public Path getRaiz()     { return raiz; }
    public Path getSesiones() { return sesiones; }
}

package com.nexussoftware.bibliotech.presentacion;

import java.io.IOException;
import com.nexussoftware.bibliotech.infraestructura.AlmacenBiblioTech;

public class DemoAlmacen {

    public static void main(String[] args) throws IOException {
        AlmacenBiblioTech almacen = new AlmacenBiblioTech("datos");

        // 1. Escribir el catalogo con copia de seguridad y atomicidad
        almacen.escribirConCopia("catalogo.txt", salida -> {
            salida.write("# Catalogo de BiblioTech - Nexus Software");
            salida.newLine();
            salida.write("LIBRO;978-0000000001;Java Efectivo;Bloch;2018");
            salida.newLine();
            salida.write("LIBRO;978-0000000002;Patrones de Diseno;Gamma;1994");
            salida.newLine();
            salida.write("LIBRO;978-0000000003;Refactorizacion;Fowler;1999");
            salida.newLine();
        });

        // 2. Leer
        System.out.println("=== CATALOGO ===");
        for (String linea : almacen.leerCatalogo()) {
            System.out.println("  " + linea);
        }

        // 3. Auditoria (modo APPEND)
        almacen.auditar("PRESTAMO;PR-0001;978-0000000001;E-001");
        almacen.auditar("DEVOLUCION;PR-0001;978-0000000001;E-001");

        // 4. Informes en un arbol de directorios
        almacen.guardarInforme("2026", "01", "multas-enero", "Total: 142,50 EUR");
        almacen.guardarInforme("2026", "02", "multas-febrero", "Total: 98,25 EUR");
        almacen.guardarInforme("2026", "08", "multas-agosto", "Total: 210,00 EUR");

        System.out.println();
        System.out.println("=== INFORMES LOCALIZADOS ===");
        for (AlmacenBiblioTech.InfoInforme info : almacen.localizarInformes()) {
            System.out.println("  " + info.linea());
        }

        // 5. Espacio ocupado
        System.out.println();
        System.out.println("=== ESPACIO ===");
        System.out.println("  " + almacen.informeDeEspacio());
    }
}

=== CATALOGO ===
  LIBRO;978-0000000001;Java Efectivo;Bloch;2018
  LIBRO;978-0000000002;Patrones de Diseno;Gamma;1994
  LIBRO;978-0000000003;Refactorizacion;Fowler;1999

=== INFORMES LOCALIZADOS ===
  2026/08/multas-agosto.informe              17 bytes  2026-08-05T09:14:22.331Z
  2026/02/multas-febrero.informe             17 bytes  2026-08-05T09:14:22.329Z
  2026/01/multas-enero.informe               18 bytes  2026-08-05T09:14:22.327Z

=== ESPACIO ===
  datos: 9 ficheros, 0,01 MB

package com.nexussoftware.bibliotech.util;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.PosixFilePermissions;

/**
 * Informe completo de una ruta usando solo NIO.2.
 *
 * Sustituye al DiagnosticoRuta de 07-01, que usaba java.io: aqui cada
 * fallo dice POR QUE, en lugar de devolver un boolean mudo.
 */
public class ExploradorRutas {

    public static void analizar(String ruta) {
        Path p = Path.of(ruta);

        System.out.println("========================================");
        System.out.println("ANALISIS DE: " + ruta);
        System.out.println("========================================");

        // ---- 1. Formas de la ruta ----
        System.out.println("  Tal cual        : " + p);
        System.out.println("  Absoluta        : " + p.toAbsolutePath());
        System.out.println("  Normalizada     : " + p.toAbsolutePath().normalize());

        try {
            // toRealPath SI consulta el disco y resuelve enlaces simbolicos
            System.out.println("  Real            : " + p.toRealPath());
        } catch (NoSuchFileException e) {
            System.out.println("  Real            : (no existe, no se puede resolver)");
        } catch (IOException e) {
            System.out.println("  Real            : (error: " + e.getMessage() + ")");
        }

        // ---- 2. Estructura ----
        System.out.println("  Nombre          : " + p.getFileName());
        System.out.println("  Padre           : " + p.getParent());
        System.out.println("  Raiz            : " + p.getRoot());
        System.out.println("  ¿Absoluta?      : " + p.isAbsolute());
        System.out.println("  Segmentos       : " + p.getNameCount());

        StringBuilder segmentos = new StringBuilder();
        for (Path s : p) {                       // Path es Iterable<Path>
            segmentos.append('[').append(s).append(']');
        }
        System.out.println("  Recorrido       : " + segmentos);

        // ---- 5. exists / notExists ----
        boolean existe = Files.exists(p);
        boolean noExiste = Files.notExists(p);

        System.out.println("  ----");
        System.out.println("  exists()        : " + existe);
        System.out.println("  notExists()     : " + noExiste);
        System.out.println("  Interpretacion  : " + interpretar(existe, noExiste));

        if (!existe) {
            System.out.println();
            return;
        }

        // ---- 3. Atributos: UNA sola consulta ----
        try {
            BasicFileAttributes attrs = Files.readAttributes(p, BasicFileAttributes.class);

            System.out.println("  ----");
            System.out.println("  Tipo            : " + tipo(attrs));
            System.out.println("  Tamano          : " + attrs.size() + " bytes");
            System.out.println("  Creado          : " + attrs.creationTime());
            System.out.println("  Modificado      : " + attrs.lastModifiedTime());
            System.out.println("  Ultimo acceso   : " + attrs.lastAccessTime());
            System.out.println("  ¿Legible?       : " + Files.isReadable(p));
            System.out.println("  ¿Escribible?    : " + Files.isWritable(p));

            // ---- 4. Antiguedad ----
            long dias = (System.currentTimeMillis() - attrs.lastModifiedTime().toMillis())
                    / (1000L * 60 * 60 * 24);
            System.out.println("  Antiguedad      : " + dias + " dias");

            // Permisos POSIX si el sistema los tiene
            try {
                System.out.println("  Permisos POSIX  : " + PosixFilePermissions.toString(
                        Files.getPosixFilePermissions(p)));
            } catch (UnsupportedOperationException e) {
                System.out.println("  Permisos POSIX  : (sistema sin soporte, p.ej. Windows)");
            }

        } catch (IOException e) {
            System.out.println("  ERROR leyendo atributos: " + e.getMessage());
        }

        System.out.println();
    }

    private static String tipo(BasicFileAttributes a) {
        if (a.isDirectory())     { return "directorio"; }
        if (a.isRegularFile())   { return "fichero"; }
        if (a.isSymbolicLink())  { return "enlace simbolico"; }
        return "otro";
    }

    /** Los TRES estados posibles, no dos. */
    private static String interpretar(boolean existe, boolean noExiste) {
        if (existe && !noExiste) {
            return "EXISTE, y se ha podido comprobar";
        }
        if (!existe && noExiste) {
            return "NO EXISTE, y se ha podido comprobar";
        }
        if (!existe && !noExiste) {
            return "NO SE PUEDE DETERMINAR (probablemente sin permiso sobre "
                    + "el directorio que la contiene). Por eso !exists() NO "
                    + "significa 'no existe'.";
        }
        return "estado imposible";
    }

    public static void main(String[] args) {
        analizar("datos/catalogo.txt");
        analizar("datos");
        analizar("datos/no-existe.txt");
        analizar("datos/../datos/./informes/../catalogo.txt");   // sin normalizar
    }
}

========================================
ANALISIS DE: datos/../datos/./informes/../catalogo.txt
========================================
  Tal cual        : datos/../datos/./informes/../catalogo.txt
  Absoluta        : /home/marta/bibliotech/datos/../datos/./informes/../catalogo.txt
  Normalizada     : /home/marta/bibliotech/datos/catalogo.txt
  Real            : /home/marta/bibliotech/datos/catalogo.txt
  Nombre          : catalogo.txt
  Segmentos       : 7
  Recorrido       : [datos][..][datos][.][informes][..][catalogo.txt]
  ----
  exists()        : true
  notExists()     : false
  Interpretacion  : EXISTE, y se ha podido comprobar

package com.nexussoftware.bibliotech.util;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Logger;

/**
 * Sincroniza un directorio destino con un origen, copiando solo lo necesario.
 *
 * Es el nucleo de cualquier herramienta de copia incremental: no copiar lo
 * que ya esta igual ahorra la mayor parte del trabajo.
 */
public class SincronizadorDirectorios {

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

    public record Resultado(int copiados, int actualizados, int sinCambios,
                            int soloEnDestino, int errores,
                            List<String> detalleSoloEnDestino) {

        public String informe() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== SINCRONIZACION ===\n");
            sb.append(String.format("  Copiados (nuevos) : %d%n", copiados));
            sb.append(String.format("  Actualizados      : %d%n", actualizados));
            sb.append(String.format("  Sin cambios       : %d%n", sinCambios));
            sb.append(String.format("  Solo en destino   : %d%n", soloEnDestino));
            sb.append(String.format("  Errores           : %d%n", errores));

            if (!detalleSoloEnDestino.isEmpty()) {
                sb.append("  --- Solo en destino (candidatos a borrar) ---\n");
                int n = Math.min(10, detalleSoloEnDestino.size());
                for (int i = 0; i < n; i++) {
                    sb.append("    ").append(detalleSoloEnDestino.get(i)).append('\n');
                }
                if (detalleSoloEnDestino.size() > n) {
                    sb.append(String.format("    ... y %d mas%n",
                            detalleSoloEnDestino.size() - n));
                }
            }
            return sb.toString();
        }
    }

    /** Sincroniza origen hacia destino. NUNCA borra nada del destino. */
    public Resultado sincronizar(Path origen, Path destino) throws IOException {
        Path raizOrigen  = origen.toAbsolutePath().normalize();
        Path raizDestino = destino.toAbsolutePath().normalize();

        if (!Files.isDirectory(raizOrigen)) {
            throw new NotDirectoryException(raizOrigen.toString());
        }
        Files.createDirectories(raizDestino);

        int[] contadores = new int[4];        // copiados, actualizados, iguales, errores
        Set<Path> vistosEnOrigen = new HashSet<>();

        // ---- FASE 1: recorrer el origen y sincronizar ----
        Files.walkFileTree(raizOrigen, new SimpleFileVisitor<Path>() {

            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                    throws IOException {

                // relativize da la ruta equivalente en el destino (apartado 3)
                Path equivalente = raizDestino.resolve(raizOrigen.relativize(dir));
                Files.createDirectories(equivalente);       // idempotente
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFile(Path fichero, BasicFileAttributes attrsOrigen) {
                Path relativa = raizOrigen.relativize(fichero);
                Path equivalente = raizDestino.resolve(relativa);

                vistosEnOrigen.add(relativa);

                try {
                    if (Files.notExists(equivalente)) {
                        // NUEVO: copiar conservando los atributos
                        Files.copy(fichero, equivalente,
                                StandardCopyOption.COPY_ATTRIBUTES);
                        contadores[0]++;
                        LOG.fine(() -> "Nuevo: " + relativa);
                        return FileVisitResult.CONTINUE;
                    }

                    BasicFileAttributes attrsDestino =
                            Files.readAttributes(equivalente, BasicFileAttributes.class);

                    FileTime tOrigen  = attrsOrigen.lastModifiedTime();
                    FileTime tDestino = attrsDestino.lastModifiedTime();

                    // compareTo > 0 significa que el origen es MAS RECIENTE.
                    // Se compara tambien el tamano: un fichero con la misma
                    // fecha pero distinto tamano tambien hay que copiarlo.
                    if (tOrigen.compareTo(tDestino) > 0
                            || attrsOrigen.size() != attrsDestino.size()) {

                        Files.copy(fichero, equivalente,
                                StandardCopyOption.REPLACE_EXISTING,
                                StandardCopyOption.COPY_ATTRIBUTES);
                        contadores[1]++;
                        LOG.fine(() -> "Actualizado: " + relativa);
                    } else {
                        contadores[2]++;
                    }

                } catch (IOException e) {
                    contadores[3]++;
                    LOG.warning(() -> "Error sincronizando " + relativa
                            + ": " + e.getMessage());
                }
                return FileVisitResult.CONTINUE;
            }

            /**
             * CLAVE: un fichero inaccesible NO aborta la sincronizacion.
             * Con Files.walk esto no seria posible.
             */
            @Override
            public FileVisitResult visitFileFailed(Path fichero, IOException e) {
                contadores[3]++;
                LOG.warning(() -> "No accesible en origen: " + fichero);
                return FileVisitResult.CONTINUE;
            }
        });

        // ---- FASE 2: detectar lo que solo esta en destino ----
        List<String> soloDestino = new ArrayList<>();

        Files.walkFileTree(raizDestino, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path fichero, BasicFileAttributes attrs) {
                Path relativa = raizDestino.relativize(fichero);
                if (!vistosEnOrigen.contains(relativa)) {
                    soloDestino.add(relativa.toString());
                }
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path f, IOException e) {
                return FileVisitResult.CONTINUE;
            }
        });

        soloDestino.sort(null);

        return new Resultado(contadores[0], contadores[1], contadores[2],
                soloDestino.size(), contadores[3], soloDestino);
    }

    public static void main(String[] args) throws IOException {
        Resultado r = new SincronizadorDirectorios()
                .sincronizar(Path.of("datos"), Path.of("copia-seguridad/datos"));
        System.out.println(r.informe());
    }
}

=== SINCRONIZACION ===
  Copiados (nuevos) : 0
  Actualizados      : 1
  Sin cambios       : 11
  Solo en destino   : 2
  Errores           : 0
  --- Solo en destino (candidatos a borrar) ---
    informes/2025/12/multas-diciembre.informe
    catalogo-antiguo.txt

package com.nexussoftware.bibliotech.infraestructura;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.logging.Logger;
import java.util.stream.Stream;

/**
 * Copias de seguridad rotativas con marca de tiempo, sobre NIO.2.
 *
 * Cada copia se nombra fichero.AAAAMMDD-HHMMSS.bak. Se conservan las N mas
 * recientes; las demas se borran.
 *
 * NOTA: el nombre con fecha se compone con SimpleDateFormat porque java.time
 * es la leccion 10-05. Con LocalDateTime y DateTimeFormatter esto queda
 * bastante mejor, y alli lo veras.
 */
public class GestorCopias {

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

    private static final String SUFIJO = ".bak";
    private static final int MAX_COPIAS_DEFECTO = 3;

    private final Path directorioCopias;
    private final int maxCopias;

    public GestorCopias(Path directorioCopias) throws IOException {
        this(directorioCopias, MAX_COPIAS_DEFECTO);
    }

    public GestorCopias(Path directorioCopias, int maxCopias) throws IOException {
        this.directorioCopias = Objects.requireNonNull(directorioCopias)
                .toAbsolutePath().normalize();

        if (maxCopias < 1) {
            throw new IllegalArgumentException(
                    "Hay que conservar al menos una copia, y se pidio: " + maxCopias);
        }
        this.maxCopias = maxCopias;

        Files.createDirectories(this.directorioCopias);
    }

    /** Informacion de una copia existente. */
    public record InfoCopia(Path ruta, String nombre, long bytes, FileTime creada) {

        public String linea() {
            return String.format("%-45s %8d bytes  %s", nombre, bytes, creada);
        }
    }

    // ---------------------- CREAR ----------------------

    /**
     * Crea una copia con marca de tiempo y aplica la rotacion.
     *
     * @return la ruta de la copia creada
     */
    public Path crearCopia(Path fichero) throws IOException {
        Objects.requireNonNull(fichero, "El fichero no puede ser nulo");

        if (Files.notExists(fichero)) {
            throw new NoSuchFileException(fichero.toString(),
                    null, "No se puede copiar un fichero que no existe");
        }

        String nombreBase = fichero.getFileName().toString();
        String marca = new java.text.SimpleDateFormat("yyyyMMdd-HHmmss")
                .format(new Date(System.currentTimeMillis()));

        Path copia = directorioCopias.resolve(nombreBase + "." + marca + SUFIJO);

        // Si en el mismo segundo se pide otra copia, se anade un sufijo
        int intento = 1;
        while (Files.exists(copia)) {
            copia = directorioCopias.resolve(
                    nombreBase + "." + marca + "-" + intento + SUFIJO);
            intento++;
        }

        // COPY_ATTRIBUTES conserva la fecha original del fichero copiado
        Files.copy(fichero, copia, StandardCopyOption.COPY_ATTRIBUTES);

        final Path creada = copia;
        LOG.info(() -> "Copia creada: " + creada.getFileName());

        aplicarRotacion(nombreBase);
        return copia;
    }

    /** Borra las copias que sobran, empezando por las mas antiguas. */
    private void aplicarRotacion(String nombreBase) throws IOException {
        List<InfoCopia> copias = listarCopias(nombreBase);

        for (int i = maxCopias; i < copias.size(); i++) {
            InfoCopia sobrante = copias.get(i);        // ya vienen de nueva a vieja
            if (Files.deleteIfExists(sobrante.ruta())) {
                LOG.fine(() -> "Copia antigua borrada: " + sobrante.nombre());
            }
        }
    }

    // ---------------------- LISTAR ----------------------

    /** Copias de un fichero, de la MAS RECIENTE a la mas antigua. */
    public List<InfoCopia> listarCopias(String nombreBase) throws IOException {
        List<InfoCopia> encontradas = new ArrayList<>();
        String prefijo = nombreBase + ".";

        // Files.list devuelve un flujo PEREZOSO: try-with-resources obligatorio
        try (Stream<Path> hijos = Files.list(directorioCopias)) {
            hijos.forEach(p -> {
                String nombre = p.getFileName().toString();
                if (!nombre.startsWith(prefijo) || !nombre.endsWith(SUFIJO)) {
                    return;
                }
                try {
                    BasicFileAttributes attrs =
                            Files.readAttributes(p, BasicFileAttributes.class);
                    encontradas.add(new InfoCopia(p, nombre, attrs.size(),
                            attrs.lastModifiedTime()));
                } catch (IOException e) {
                    LOG.fine(() -> "No se pudo leer " + p);
                }
            });
        }

        // Mas reciente primero (05-09)
        encontradas.sort(Comparator.comparing(InfoCopia::creada).reversed());
        return encontradas;
    }

    public List<InfoCopia> listarCopias(Path fichero) throws IOException {
        return listarCopias(fichero.getFileName().toString());
    }

    // ---------------------- RESTAURAR ----------------------

    /**
     * Restaura la copia numero 'indice' (0 = la mas reciente).
     *
     * ANTES de restaurar, hace una copia del estado ACTUAL: si la
     * restauracion resulta ser un error, se puede deshacer. Restaurar sin
     * esa red es una forma habitual de perder el trabajo del dia.
     *
     * La sustitucion es ATOMICA: el fichero nunca queda a medias.
     */
    public void restaurar(Path fichero, int indice) throws IOException {
        List<InfoCopia> copias = listarCopias(fichero);

        if (copias.isEmpty()) {
            throw new NoSuchFileException(fichero.toString(),
                    null, "No hay ninguna copia de seguridad de este fichero");
        }
        if (indice < 0 || indice >= copias.size()) {
            throw new IllegalArgumentException(String.format(
                    "Indice %d fuera de rango: hay %d copias (0..%d)",
                    indice, copias.size(), copias.size() - 1));
        }

        InfoCopia elegida = copias.get(indice);

        // 1. Red de seguridad: copiar el estado actual antes de pisarlo
        if (Files.exists(fichero)) {
            crearCopia(fichero);
        }

        // 2. Temporal HERMANO del destino: ATOMIC_MOVE lo exige
        Path temporal = fichero.resolveSibling(fichero.getFileName() + ".restaurando");
        boolean completado = false;

        try {
            Files.copy(elegida.ruta(), temporal,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.COPY_ATTRIBUTES);

            Files.move(temporal, fichero,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.ATOMIC_MOVE);
            completado = true;

            LOG.info(() -> "Restaurado " + fichero.getFileName()
                    + " desde " + elegida.nombre());

        } catch (AtomicMoveNotSupportedException e) {
            LOG.warning(() -> "Sin ATOMIC_MOVE; restauracion no atomica");
            Files.move(temporal, fichero, StandardCopyOption.REPLACE_EXISTING);
            completado = true;

        } finally {
            if (!completado) {
                Files.deleteIfExists(temporal);        // compensacion (06-05)
            }
        }
    }

    // ---------------------- ESPACIO ----------------------

    /** Espacio total ocupado por las copias. */
    public long espacioOcupado() throws IOException {
        long[] total = new long[1];

        Files.walkFileTree(directorioCopias, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path f, BasicFileAttributes attrs) {
                if (f.getFileName().toString().endsWith(SUFIJO)) {
                    total[0] += attrs.size();
                }
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path f, IOException e) {
                return FileVisitResult.CONTINUE;       // no abortar por un fallo
            }
        });
        return total[0];
    }

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

    public static void main(String[] args) throws IOException, InterruptedException {
        Path fichero = Path.of("datos/catalogo.txt");
        Files.createDirectories(fichero.getParent());

        GestorCopias gestor = new GestorCopias(Path.of("datos/copias"), 3);

        // 1. Cinco versiones distintas, con maximo de 3 copias
        System.out.println("=== CREANDO 5 COPIAS (maximo 3) ===");
        for (int v = 1; v <= 5; v++) {
            Files.writeString(fichero,
                    "# Catalogo version " + v + "\n"
                            + "LIBRO;978-000000000" + v + ";Libro " + v + ";Autor;2020\n",
                    java.nio.charset.StandardCharsets.UTF_8,
                    StandardOpenOption.CREATE,
                    StandardOpenOption.TRUNCATE_EXISTING,
                    StandardOpenOption.WRITE);

            Path copia = gestor.crearCopia(fichero);
            System.out.println("  v" + v + " -> " + copia.getFileName());

            Thread.sleep(1100);        // para que la marca de tiempo cambie
        }

        // 2. Listar: solo deben quedar las 3 ultimas
        System.out.println();
        System.out.println("=== COPIAS CONSERVADAS ===");
        List<InfoCopia> copias = gestor.listarCopias(fichero);
        for (int i = 0; i < copias.size(); i++) {
            System.out.printf("  [%d] %s%n", i, copias.get(i).linea());
        }

        // 3. Contenido actual
        System.out.println();
        System.out.println("=== CONTENIDO ACTUAL ===");
        System.out.print(Files.readString(fichero));

        // 4. Restaurar la copia [1] (la penultima, es decir, la version 4)
        System.out.println();
        System.out.println("=== RESTAURANDO LA COPIA [1] ===");
        gestor.restaurar(fichero, 1);
        System.out.print(Files.readString(fichero));

        // 5. Espacio
        System.out.println();
        System.out.printf("=== ESPACIO OCUPADO: %.2f KB en %d copias ===%n",
                gestor.espacioOcupado() / 1024.0,
                gestor.listarCopias(fichero).size());
    }
}

=== CREANDO 5 COPIAS (maximo 3) ===
  v1 -> catalogo.txt.20260805-091422.bak
  v2 -> catalogo.txt.20260805-091423.bak
  v3 -> catalogo.txt.20260805-091424.bak
  v4 -> catalogo.txt.20260805-091425.bak
  v5 -> catalogo.txt.20260805-091426.bak

=== COPIAS CONSERVADAS ===
  [0] catalogo.txt.20260805-091426.bak              68 bytes  2026-08-05T09:14:26.118Z
  [1] catalogo.txt.20260805-091425.bak              68 bytes  2026-08-05T09:14:25.012Z
  [2] catalogo.txt.20260805-091424.bak              68 bytes  2026-08-05T09:14:23.907Z

=== CONTENIDO ACTUAL ===
# Catalogo version 5
LIBRO;978-0000000005;Libro 5;Autor;2020

=== RESTAURANDO LA COPIA [1] ===
# Catalogo version 4
LIBRO;978-0000000004;Libro 4;Autor;2020

=== ESPACIO OCUPADO: 0,20 KB en 3 copias ===