1. Creación de archivos
Crear archivos programáticamente es algo frecuente: para logs, datos temporales, exportación de informes, importación de datos, guardado de ajustes y mucho más. En Java, para ello, como probablemente ya lo hayas adivinado, lo mejor es usar el API moderno — java.nio.file.
Herramienta principal: Files.createFile(Path)
Este método crea un archivo nuevo en la ruta indicada. Si el archivo ya existe, se lanzará una excepción.
Ejemplo: creamos un archivo de texto en el directorio actual
import java.nio.file.*;
public class CreateFileExample {
public static void main(String[] args) {
Path path = Path.of("hello.txt");
try {
Files.createFile(path);
System.out.println("Archivo creado: " + path.toAbsolutePath());
} catch (FileAlreadyExistsException e) {
System.out.println("El archivo ya existe: " + path);
} catch (Exception e) {
System.out.println("Error al crear el archivo: " + e.getMessage());
}
}
}
Ten en cuenta:
Files.createFile lanza FileAlreadyExistsException si el archivo ya existe. Por eso, a menudo se comprueba su existencia antes de crearlo.
Comprobación de existencia de un archivo
Path path = Path.of("hello.txt");
if (!Files.exists(path)) {
Files.createFile(path);
}
Consejo:
Comprobar la existencia de un archivo no protege contra condiciones de carrera entre hilos, pero para la mayoría de escenarios de usuario es un enfoque perfectamente válido.
En breve: ¿qué ocurre al crear un archivo?
- Si el archivo no existe y la ruta es válida — se crea un archivo vacío nuevo.
- Si el archivo ya existe — se lanza una excepción.
- Si la ruta no es válida, no hay permisos o la carpeta no existe — se lanzará otra excepción (IOException, NoSuchFileException, etc.).
2. Creación de directorios
Diferencia entre Files.createDirectory y Files.createDirectories
- Files.createDirectory(Path) — crea solo una carpeta. Si no existe la carpeta padre — habrá un error.
- Files.createDirectories(Path) — crea toda la cadena de carpetas que falten (como un mago que construye la escalera justo bajo tus pies).
Ejemplo: creamos una sola carpeta
Path dir = Path.of("data");
try {
Files.createDirectory(dir);
System.out.println("Carpeta creada: " + dir.toAbsolutePath());
} catch (FileAlreadyExistsException e) {
System.out.println("La carpeta ya existe: " + dir);
} catch (Exception e) {
System.out.println("Error al crear la carpeta: " + e.getMessage());
}
Ejemplo: creamos una estructura de carpetas anidadas
Path nested = Path.of("data/reports/2024");
try {
Files.createDirectories(nested);
System.out.println("Estructura de carpetas creada: " + nested.toAbsolutePath());
} catch (Exception e) {
System.out.println("Error al crear la estructura: " + e.getMessage());
}
Ten en cuenta: si alguna de las carpetas ya existe, createDirectories no se asusta — simplemente crea las que faltan. Si usas createDirectory para una carpeta anidada y aún no existe la carpeta padre — habrá un error.
Tabla: comparación de los métodos de creación de carpetas
| Método | Crea solo una carpeta | Crea carpetas anidadas | No falla si alguna ya existe |
|---|---|---|---|
|
✔ | ✗ | ✗ |
|
✔ | ✔ | ✔ |
3. Eliminación de archivos
Eliminar archivos es casi como tirar la basura: lo principal — ¡no tirar algo necesario! En Java hay dos métodos principales para ello:
- Files.delete(Path) — elimina un archivo o una carpeta vacía. Si el archivo no existe — se lanzará una excepción.
- Files.deleteIfExists(Path) — elimina el archivo, pero si no existía — simplemente no hace nada.
Ejemplo: eliminamos un archivo temporal
Path tempFile = Path.of("temp.txt");
try {
Files.delete(tempFile);
System.out.println("Archivo eliminado: " + tempFile);
} catch (NoSuchFileException e) {
System.out.println("Archivo no encontrado: " + tempFile);
} catch (DirectoryNotEmptyException e) {
System.out.println("La carpeta no está vacía: " + tempFile);
} catch (Exception e) {
System.out.println("Error al eliminar: " + e.getMessage());
}
Opción más segura
boolean deleted = Files.deleteIfExists(tempFile);
if (deleted) {
System.out.println("El archivo fue eliminado.");
} else {
System.out.println("Archivo no encontrado: no hay nada que eliminar.");
}
¡Importante!
- Si el archivo está abierto en otro programa — puede lanzarse una excepción (por ejemplo, en Windows).
- Si intentas eliminar una carpeta que no está vacía — habrá un error DirectoryNotEmptyException.
4. Eliminación de directorios
En Java eliminamos carpetas de forma parecida a los archivos. Con un matiz: los métodos estándar eliminan solo carpetas vacías.
Ejemplo: eliminamos una carpeta vacía
Path emptyDir = Path.of("empty_folder");
try {
Files.delete(emptyDir);
System.out.println("Carpeta eliminada: " + emptyDir);
} catch (DirectoryNotEmptyException e) {
System.out.println("La carpeta no está vacía: " + emptyDir);
} catch (NoSuchFileException e) {
System.out.println("Carpeta no encontrada: " + emptyDir);
} catch (Exception e) {
System.out.println("Error al eliminar la carpeta: " + e.getMessage());
}
¿Qué hacer con las carpetas no vacías?
Para eliminar directorios no vacíos tendrás que borrar recursivamente todos los archivos y subcarpetas. Es tema para otra lección (y otra aventura), pero si ya no puedes esperar, aquí tienes el código, analízalo y prueba a reproducirlo:
import java.nio.file.*;
import java.io.IOException;
public class DeleteDirectoryRecursively {
public static void deleteRecursively(Path path) throws IOException {
if (Files.isDirectory(path)) {
try (var entries = Files.list(path)) {
for (Path entry : entries.toList()) {
deleteRecursively(entry);
}
}
}
Files.delete(path);
}
}
Atención:
¡Este código eliminará todo lo que haya dentro de la carpeta! Úsalo con precaución.
5. Consejos prácticos
Comprobación de existencia antes de eliminar
if (Files.exists(path)) {
Files.delete(path);
} else {
System.out.println("El archivo/carpeta no existe.");
}
Pero si usas deleteIfExists, no es necesario hacerlo.
Manejo de excepciones
Al trabajar con archivos nos topamos a menudo con imprevistos. Para ello, Java lanza distintas excepciones:
- NoSuchFileException — el archivo o la carpeta no se encuentran. Por ejemplo, intentas abrir algo que ya se eliminó.
- DirectoryNotEmptyException — quieres eliminar una carpeta, pero aún hay algo dentro.
- IOException — aviso genérico: algo ha ido mal. La causa puede variar — falta de permisos, el archivo está en uso por otro programa, la ruta es incorrecta.
Esquema visual: métodos principales
+-------------------+ +--------------------+
| Files.createFile | ----> | Archivo nuevo |
+-------------------+ +--------------------+
+---------------------+ +--------------------+
| Files.createDirectory|----> | Carpeta nueva |
+---------------------+ +--------------------+
+-------------------+ +--------------------+
| Files.delete | ----> | Archivo/carpeta eliminado |
+-------------------+ +--------------------+
(pero solo si la carpeta está vacía)
6. Errores típicos al crear y eliminar archivos y carpetas
Error n.º 1: intentamos crear un archivo/carpeta que ya existe. Los métodos Files.createFile y Files.createDirectory lanzan una excepción si el objeto ya existe. Solución — comprobar la existencia de antemano o capturar la excepción.
Error n.º 2: intentamos crear una carpeta anidada con createDirectory, pero la carpeta padre aún no existe. En este caso habrá un error NoSuchFileException. Usa createDirectories para crear la cadena de carpetas.
Error n.º 3: intentamos eliminar una carpeta no vacía con Files.delete. Obtendrás DirectoryNotEmptyException. Para eliminar directorios no vacíos se necesita recursión.
Error n.º 4: no hay permisos para crear/eliminar en el directorio indicado. Se lanzará AccessDeniedException o IOException. Ejecuta el programa con los permisos adecuados o usa carpetas accesibles.
Error n.º 5: el archivo está en uso por otro proceso. En Windows (y a veces en otros SO) no se puede eliminar un archivo si está abierto en otro programa. Recibirás IOException. Cierra todas las aplicaciones que usen el archivo antes de eliminarlo.
Error n.º 6: uso de rutas relativas sin saber «dónde estás». El archivo se crea en un lugar diferente al esperado. Para estar seguro, usa toAbsolutePath() y muestra la ruta por pantalla.
GO TO FULL VERSION