1. Creación de directorios
Un directorio (también llamado carpeta) no es solo un contenedor para archivos, sino la base de la organización de datos en el disco. En las aplicaciones creamos directorios continuamente para datos de entrada/salida, logs, archivos temporales, etc. El API java.nio.file lo hace de forma cómoda y multiplataforma.
Veamos cómo crear, eliminar y ver el contenido de las carpetas con las clases Files, Path y Paths.
Files.createDirectory(path)
Crea un único directorio en la ruta indicada. Si el directorio padre no existe — se lanzará una excepción.
import java.nio.file.*;
public class DirectoryDemo {
public static void main(String[] args) throws Exception {
Path dir = Paths.get("testDir");
if (!Files.exists(dir)) {
Files.createDirectory(dir);
System.out.println("Directorio creado: " + dir.toAbsolutePath());
} else {
System.out.println("El directorio ya existe: " + dir.toAbsolutePath());
}
}
}
Si intentas crear un directorio que ya existe, obtendrás FileAlreadyExistsException.
Files.createDirectories(path)
Crea toda la cadena de directorios. Si falta alguno de los directorios intermedios — se creará automáticamente. Si parte de la cadena ya existe — no habrá error.
Path nestedDir = Paths.get("parent/child/grandchild");
Files.createDirectories(nestedDir);
System.out.println("Se ha creado la cadena de directorios: " + nestedDir.toAbsolutePath());
Es como pedirle a Java que construya no solo la casa, sino también el portal y la calle si aún no existían.
Ejemplo típico: creamos una estructura para un proyecto
Supongamos que necesitas guardar informes en la carpeta output/reports/2024. No verifiques cada directorio manualmente — usa createDirectories.
Path reportsPath = Paths.get("output/reports/2024");
Files.createDirectories(reportsPath);
Java se encargará de determinar qué ya existe y qué debe crearse.
2. Eliminación de archivos y directorios
Files.delete(path)
Elimina un archivo o un directorio vacío. Si el directorio no está vacío — se lanzará DirectoryNotEmptyException.
Path dir = Paths.get("testDir");
try {
Files.delete(dir);
System.out.println("Directorio eliminado: " + dir.toAbsolutePath());
} catch (DirectoryNotEmptyException e) {
System.out.println("No es posible eliminar: ¡el directorio no está vacío!");
}
Files.deleteIfExists(path)
Funciona como delete, pero no lanza un error si el objeto no existe. Devuelve true si algo se ha eliminado, y false — si el objeto no existía.
Path file = Paths.get("output/reports/2024/report.txt");
if (Files.deleteIfExists(file)) {
System.out.println("Archivo eliminado.");
} else {
System.out.println("Archivo no encontrado, no se ha eliminado nada.");
}
¿Cómo eliminar un directorio no vacío?
No puedes eliminar una carpeta no vacía tal cual. Primero debes eliminar todo su contenido (archivos y subdirectorios), y luego la carpeta en sí. Esto se hace de forma recursiva, por ejemplo, con Files.walkFileTree:
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
public class DeleteDirectoryRecursively {
public static void main(String[] args) throws IOException {
Path dir = Paths.get("parent");
if (Files.exists(dir)) {
Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Files.delete(file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
Files.delete(dir);
return FileVisitResult.CONTINUE;
}
});
System.out.println("El directorio y todo su contenido han sido eliminados.");
}
}
}
Si estás empezando, no te asustes por este código — más adelante veremos walkFileTree en detalle.
3. Listado del contenido de un directorio
Files.list(path)
Devuelve Stream<Path> — un flujo de rutas. Puedes procesar el contenido de la carpeta mediante el Stream API. Cada entrada es un archivo o un subdirectorio (¡sin recursividad!).
Path dir = Paths.get("output/reports");
if (Files.exists(dir) && Files.isDirectory(dir)) {
try (var stream = Files.list(dir)) {
stream.forEach(path -> System.out.println(path.getFileName()));
}
}
Detalle importante: el flujo debe cerrarse obligatoriamente, por eso usamos try‑with‑resources.
Ejemplo: mostramos los nombres de archivos y subdirectorios
Path reports2024 = Paths.get("output/reports/2024");
try (var stream = Files.list(reports2024)) {
stream.forEach(path -> {
String type = Files.isDirectory(path) ? "directorio" : "archivo";
System.out.println(path.getFileName() + " — " + type);
});
}
Obtener la lista de archivos como colección
List<Path> files = Files.list(reports2024)
.filter(Files::isRegularFile)
.toList();
System.out.println("Archivos en la carpeta:");
files.forEach(System.out::println);
Importante: Files.list(path) devuelve solo el contenido del directorio actual (nivel superior). Para un recorrido recursivo usa Files.walk(path).
4. Práctica: mini gestor de archivos
La utilidad crea el directorio mydata/logs, el archivo log1.txt, muestra el contenido de la carpeta y luego lo elimina todo.
import java.nio.file.*;
import java.io.IOException;
public class MiniFileManager {
public static void main(String[] args) throws IOException {
Path logsDir = Paths.get("mydata/logs");
Files.createDirectories(logsDir);
Path logFile = logsDir.resolve("log1.txt");
Files.writeString(logFile, "¡Hola, log!");
System.out.println("Contenido de la carpeta " + logsDir + ":");
try (var stream = Files.list(logsDir)) {
stream.forEach(path -> System.out.println(" - " + path.getFileName()));
}
Files.deleteIfExists(logFile);
Files.deleteIfExists(logsDir);
System.out.println("El archivo y la carpeta han sido eliminados.");
}
}
Comentarios al código:
- Files.createDirectories garantiza la creación de toda la cadena.
- resolve — una forma cómoda de añadir al Path el nombre del archivo.
- Cerramos el stream de Files.list con try‑with‑resources — especialmente crítico en Windows.
5. Particularidades y matices
Comprobación de existencia
Antes de crear/eliminar es útil comprobar si la ruta existe:
if (!Files.exists(path)) {
Files.createDirectory(path);
}
Permisos de acceso
Si el programa no tiene permisos para crear/eliminar — obtendrás AccessDeniedException. Por ejemplo, crear una carpeta en la raíz del disco como usuario normal casi siempre terminará en error.
Directorio vacío y no vacío
Solo se puede eliminar un directorio vacío (Files.delete). Para eliminar junto con todo su contenido usa un recorrido recursivo (walkFileTree).
Multiplataforma
El API java.nio.file funciona correctamente en todos los SO populares y tiene en cuenta los separadores de ruta. Para construir rutas usa Paths.get y Path.resolve, no concatenes cadenas.
Enlaces simbólicos
En tareas básicas puedes no preocuparte por ellos, pero si te encuentras entradas «inusuales» que no son ni un archivo normal ni un directorio — es posible que sean enlaces simbólicos. Volveremos a ellos en lecciones avanzadas.
6. Errores típicos al trabajar con directorios
Error n.º 1: intento de eliminar un directorio no vacío con una simple llamada a Files.delete(path). Java lanzará DirectoryNotEmptyException. Primero elimina el contenido, después la carpeta.
Error n.º 2: olvidaste cerrar el stream de Files.list(). Si no usas try‑with‑resources, el stream permanecerá abierto, y en Windows puede producirse un error al eliminar la carpeta.
Error n.º 3: crear un directorio sin comprobar la existencia del padre. Llamar a Files.createDirectory con una ruta del tipo parent/child, cuando parent no existe, provocará NoSuchFileException. Usa Files.createDirectories.
Error n.º 4: usar rutas absolutas sin necesidad. Prefiere rutas relativas dentro del proyecto — así el código será más portable.
Error n.º 5: no manejar IOException. Cualquier operación con el sistema de archivos puede fallar. Envuelve en try-catch o propaga la excepción hacia arriba.
Error n.º 6: intentar crear/eliminar en una carpeta para la que no tienes permisos. En ese caso obtendrás AccessDeniedException. Revisa el contexto de ejecución y los permisos de acceso.
GO TO FULL VERSION