Java

Clase Files

1. Introducción a la clase `Files`

La clase Files es parte de la biblioteca java.nio.file y proporciona métodos estáticos para trabajar con archivos, directorios y otros sistemas de archivos. Su propósito es hacer más fácil y eficiente el manejo de archivos y directorios, y superar las limitaciones de la antigua API basada en clases como File.

Tema	Descripción	Ejemplo
Copiar Archivos	Copiar archivos o directorios usando `Files.copy()`, con opciones para sobreescribir o no.	Ejemplo de copiar un archivo con `Files.copy()` y la opción `StandardCopyOption.REPLACE_EXISTING`.
Mover Archivos	Mover archivos o directorios con `Files.move()`.	Ejemplo de mover un archivo con `Files.move()` y la opción `StandardCopyOption.REPLACE_EXISTING`.
Eliminar Archivos y Directorios	Eliminar archivos con `Files.delete()` y directorios con `Files.walk()` (eliminación recursiva).	Ejemplo de eliminar un archivo con `Files.delete()` y un directorio recursivamente con `Files.walk()`.
Crear Directorios	Crear directorios con `Files.createDirectory()` y directorios intermedios con `Files.createDirectories()`.	Ejemplo de creación de directorios con `Files.createDirectories()`.
Modificar Atributos de Archivos	Modificar atributos como permisos y propietarios usando `Files.setAttribute()` y `Files.getAttribute()`.	Ejemplo de cambiar permisos con `Files.setPosixFilePermissions()`.
Enlaces Simbólicos	Crear y eliminar enlaces simbólicos con `Files.createSymbolicLink()` y `Files.delete()`.	Ejemplo de crear y eliminar un enlace simbólico con `Files.createSymbolicLink()` y `Files.delete()`.
Comparar Archivos	Comparar archivos utilizando `Files.isSameFile()` para verificar si dos archivos son iguales.	Ejemplo de comparación de dos archivos con `Files.isSameFile()`.
Observación de Directorios (WatchService)	Monitorear cambios en directorios con `WatchService` para reaccionar a eventos como creación o modificación.	Ejemplo de monitoreo de cambios en directorios con `WatchService`.

Algunas de las operaciones avanzadas que puedes realizar con Files incluyen:

Copiar y mover archivos y directorios.
Eliminar archivos y directorios.
Modificar atributos de archivos y directorios.
Trabajar con enlaces simbólicos.
Crear directorios y subdirectorios.
Obtener información detallada sobre archivos y directorios.
Comparar archivos y directorios.
Leer y escribir archivos de manera más eficiente.

2. Operaciones Avanzadas con `Files`

2.1. Copiar y Mover Archivos y Directorios

Uno de los métodos más útiles de la clase Files es copy(), que te permite copiar archivos o directorios de forma fácil y eficiente. Además, puedes controlar el comportamiento en caso de que el archivo de destino ya exista.

Copiar archivos:

import java.nio.file.*;
import java.io.IOException;

public class CopiarArchivo {
    public static void main(String[] args) {
        Path origen = Paths.get("archivo_origen.txt");
        Path destino = Paths.get("archivo_destino.txt");

        try {
            Files.copy(origen, destino, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("Archivo copiado exitosamente.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

En este ejemplo, el archivo archivo_origen.txt se copia a archivo_destino.txt. La opción StandardCopyOption.REPLACE_EXISTING asegura que, si el archivo de destino ya existe, se sobreescriba.

Mover archivos:

import java.nio.file.*;
import java.io.IOException;

public class MoverArchivo {
    public static void main(String[] args) {
        Path origen = Paths.get("archivo_origen.txt");
        Path destino = Paths.get("directorio_destino/archivo_moved.txt");

        try {
            Files.move(origen, destino, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("Archivo movido exitosamente.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Aquí, el archivo se mueve desde archivo_origen.txt a un nuevo directorio directorio_destino. Al igual que con copy(), puedes usar StandardCopyOption.REPLACE_EXISTING para reemplazar el archivo de destino si ya existe.

2.2. Eliminar Archivos y Directorios

Para eliminar archivos, usamos el método delete(), que elimina un archivo o directorio vacío. Si deseas eliminar un directorio con contenido, necesitarás usar un enfoque recursivo o eliminar los archivos dentro del directorio antes de eliminar el directorio.

import java.nio.file.*;
import java.io.IOException;

public class EliminarArchivo {
    public static void main(String[] args) {
        Path archivo = Paths.get("archivo_a_eliminar.txt");

        try {
            Files.delete(archivo);
            System.out.println("Archivo eliminado exitosamente.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Para eliminar directorios no vacíos, puedes hacerlo de forma recursiva con un enfoque similar al siguiente:

import java.nio.file.*;
import java.io.IOException;

public class EliminarDirectorio {
    public static void main(String[] args) {
        Path directorio = Paths.get("directorio_a_eliminar");

        try {
            Files.walk(directorio) // Recorrer todos los archivos dentro del directorio
                .sorted(Comparator.reverseOrder()) // Eliminar primero los archivos más profundos
                .map(Path::toFile)
                .forEach(File::delete); // Eliminar cada archivo
            Files.delete(directorio); // Finalmente, eliminar el directorio vacío
            System.out.println("Directorio y su contenido eliminados exitosamente.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.3. Crear Directorios

Puedes crear directorios con Files.createDirectory() o incluso crear directorios de manera recursiva usando Files.createDirectories(), que crea el directorio y todos los directorios intermedios si no existen.

import java.nio.file.*;
import java.io.IOException;

public class CrearDirectorio {
    public static void main(String[] args) {
        Path directorio = Paths.get("nuevo_directorio");

        try {
            Files.createDirectories(directorio);
            System.out.println("Directorio creado exitosamente.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

En este caso, si los directorios intermedios no existen, Files.createDirectories() los crea automáticamente.

2.4. Modificar Atributos de Archivos

Puedes leer y modificar los atributos de un archivo o directorio, como sus permisos, propietario, etc. Usando Files.getAttribute() o Files.setAttribute() puedes obtener o establecer atributos específicos de archivos.

Obtener atributos de un archivo:

import java.nio.file.*;
import java.io.IOException;

public class ObtenerAtributosArchivo {
    public static void main(String[] args) {
        Path archivo = Paths.get("archivo.txt");

        try {
            // Obtener el tamaño del archivo
            long size = (long) Files.getAttribute(archivo, "size");
            System.out.println("Tamaño del archivo: " + size + " bytes");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Cambiar permisos de archivo:

import java.nio.file.*;
import java.io.IOException;

public class ModificarPermisosArchivo {
    public static void main(String[] args) {
        Path archivo = Paths.get("archivo.txt");

        try {
            // Establecer permisos de solo lectura
            Files.setPosixFilePermissions(archivo,
                PosixFilePermissions.fromString("r--r--r--"));
            System.out.println("Permisos modificados exitosamente.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.5. Trabajar con Enlaces Simbólicos

Con NIO.2 también puedes crear y eliminar enlaces simbólicos de manera sencilla. Los enlaces simbólicos son archivos que apuntan a otros archivos o directorios.

Crear un enlace simbólico:

import java.nio.file.*;
import java.io.IOException;

public class CrearEnlaceSimbolico {
    public static void main(String[] args) {
        Path original = Paths.get("archivo_original.txt");
        Path enlace = Paths.get("enlace_simbólico.txt");

        try {
            Files.createSymbolicLink(enlace, original);
            System.out.println("Enlace simbólico creado.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Eliminar un enlace simbólico:

import java.nio.file.*;
import java.io.IOException;

public class EliminarEnlaceSimbolico {
    public static void main(String[] args) {
        Path enlace = Paths.get("enlace_simbólico.txt");

        try {
            Files.delete(enlace);
            System.out.println("Enlace simbólico eliminado.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.6. Comparar Archivos

Si necesitas verificar si dos archivos son iguales (por ejemplo, si tienen el mismo contenido), puedes usar Files.isSameFile() para comparar los archivos de forma eficiente.

import java.nio.file.*;
import java.io.IOException;

public class CompararArchivos {
    public static void main(String[] args) {
        Path archivo1 = Paths.get("archivo1.txt");
        Path archivo2 = Paths.get("archivo2.txt");

        try {
            if (Files.isSameFile(archivo1, archivo2)) {
                System.out.println("Los archivos son iguales.");
            } else {
                System.out.println("Los archivos son diferentes.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}