Java – Crear directorio o carpeta

En Java se puede crear una carpeta o directorio con los métodos mkdir y mkdirs de la clase File. El primero crea una sola carpeta; el segundo, con ese plural, crea además todas las carpetas intermedias que falten. Más abajo veremos la diferencia ejecutándola, y también la alternativa moderna con java.nio.file, que explica los fallos en vez de limitarse a devolver false. Empecemos por el caso sencillo:

» Ver más ejemplos de Java

import java.io.File;

/**
 *
 * @author decodigo.com
 */
public class EjemploCrearDirectorio {
    public static void main(String args[]){
        File directorio = new File("/ruta/directorio_nuevo");
        if (!directorio.exists()) {
            if (directorio.mkdirs()) {
                System.out.println("Directorio creado");
            } else {
                System.out.println("Error al crear directorio");
            }
        }
    }
}

En este ejemplo creamos un directorio llamado directorio_nuevo; la ruta, obviamente, deberás cambiarla por la tuya. Fíjate en que el código llama a mkdirs(), en plural: así funciona aunque la carpeta que lo contiene tampoco exista todavía.

Crear múltiples carpetas

El método mkdir también te permite crear múltiples directorios cuando estos se encuentran de forma sucesiva uno dentro de otro.

import java.io.File;

/**
 *
 * @author decodigo.com
 */
public class EjemploCrearDirectorios {
    public static void main(String args[]){
        File directorios = new File("/ruta/archivos/dir1/dir2");
        if (!directorios.exists()) {
            if (directorios.mkdirs()) {
                System.out.println("Multiples directorios fueron creados");
            } else {
                System.out.println("Error al crear directorios");
            }
        }
    }
}

Como puedes ver se han creado en la misma sentencia dos directorios: dir1 y dir2.

Desde luego, estas operaciones dependen de los permisos de lectura y escritura que se tengan, por lo que debes considerarlo a la hora de escribir tu código. Por otro lado, en ambos ejemplos siempre verificamos la existencia de la carpeta antes de intentar crearla con la ayuda del método exists.

mkdir y mkdirs no son lo mismo

Es la confusión más común con esta parte de Java, y conviene dejarla clara porque cambia el resultado. mkdir() crea una sola carpeta y da por hecho que la carpeta que la contiene ya existe. mkdirs(), con ese plural, crea además todas las carpetas intermedias que falten.

File uno = new File("salida/informes");   // salida/ todavía no existe

System.out.println(uno.mkdir());    // intenta crear solo informes
System.out.println(uno.exists());

System.out.println(uno.mkdirs());   // crea salida/ y además informes
System.out.println(uno.exists());

System.out.println(uno.mkdirs());   // y ahora que ya existe...

salidafalse
false
true
true
false

Fíjate en la primera línea: mkdir() devuelve false y no crea nada, porque le falta el padre. Y fíjate sobre todo en la última.

El problema de false: tres motivos distintos, la misma respuesta

Esa última línea devuelve false y, sin embargo, no ha pasado nada malo: la carpeta existe, que es lo que querías. mkdirs() no devuelve «ha ido bien o mal», devuelve «la he creado yo o no». Y eso convierte el valor en algo bastante inútil para decidir, porque hay al menos tres situaciones muy distintas detrás:

new File("ya_esta").mkdirs();          // la creamos antes
new File("estorbo").createNewFile();   // un archivo, no una carpeta

System.out.println(new File("ya_esta").mkdirs());
System.out.println(new File("estorbo").mkdirs());
System.out.println(new File("/prohibido/nueva").mkdirs());

salidafalse      ← la carpeta ya existía, y eso no es un error
false      ← hay un archivo con ese nombre estorbando
false      ← no hay permiso de escritura

Tres problemas completamente distintos y un único false que no distingue entre «todo en orden» y «el disco está protegido contra escritura». De ahí viene el mensaje «Error al crear directorio» que aparece cuando no hay ningún error.

La forma moderna: java.nio.file

Desde Java 7 hay una alternativa que resuelve justo eso. En vez de devolver un boolean mudo, lanza una excepción que dice qué ha fallado. Son Files.createDirectory() y Files.createDirectories(), con el mismo singular y plural de antes.

import java.nio.file.*;

Path destino = Path.of("salida", "informes");

Files.createDirectory(destino);     // falta el padre salida/
Files.createDirectories(destino);   // esta sí lo crea todo
Files.createDirectories(destino);   // y repetirla no molesta
Files.createDirectory(destino);     // esta otra sí protesta

salidaNoSuchFileException: salida/informes
(creada)
(no pasa nada)
FileAlreadyExistsException: salida/informes

Y con los otros dos casos de antes, el mensaje también dice lo que hay que saber:

salidaFileAlreadyExistsException: estorbo     ← el archivo que estorbaba
AccessDeniedException: /prohibido       ← y además señala la carpeta culpable

Tres recetas que vas a necesitar

Crear la carpeta de un archivo antes de escribirlo

Es con diferencia el caso más frecuente: tienes la ruta completa de un archivo y necesitas que su carpeta exista. getParent() te la da sin tener que partir cadenas a mano.

Path destino = Path.of("salida", "2026", "octubre", "ventas.csv");

Files.createDirectories(destino.getParent());
Files.writeString(destino, "producto;unidades\ncamiseta;12\n");

System.out.println(destino);
System.out.println(Files.readString(destino).strip());

salidasalida/2026/octubre/ventas.csv
producto;unidades
camiseta;12

Observa también que la ruta se construye con Path.of("salida", "2026", "octubre"), con cada tramo por separado, en vez de pegando cadenas con barras. Así el mismo código funciona en Linux y en Windows, que usan separadores distintos.

Una carpeta temporal

Cuando necesitas un sitio donde trabajar y no te importa dónde, no inventes una ruta: pídesela al sistema. Te garantiza un nombre que no choca con nada y, en Linux y macOS, permisos privados.

Path tmp = Files.createTempDirectory("informe-");

System.out.println(tmp);
System.out.println(PosixFilePermissions.toString(Files.getPosixFilePermissions(tmp)));

salida/tmp/informe-6002518667697120311
rwx------

El número largo lo pone Java para que el nombre sea único. Ojo con una cosa: esa carpeta no se borra sola al terminar el programa; si quieres que desaparezca, tienes que borrarla tú.

Crearla con unos permisos concretos

var permisos = PosixFilePermissions.fromString("rwxr-x---");

Path privada = Files.createDirectories(Path.of("privada"),
                   PosixFilePermissions.asFileAttribute(permisos));

System.out.println(PosixFilePermissions.toString(
                       Files.getPosixFilePermissions(privada)));

salidarwxr-x---

Entonces, ¿cuál uso?

La regla corta: si empiezas hoy, usa Path y Files. La clase File sigue funcionando y seguirá funcionando —hay muchísimo código escrito con ella—, pero devuelve boolean donde debería explicarse, y eso acaba costando una tarde de depuración tarde o temprano.

Nota: los dos primeros ejemplos están editados y ejecutados en NetBeans. Los añadidos después se compilaron y ejecutaron con OpenJDK 21 sobre Linux, y las salidas que aparecen están copiadas de esa ejecución.

Esperamos que estos ejemplos de crear directorio o carpeta en Java te sean de utilidad.

Más información en inglés: https://geekole.com/create-directory-or-folder-in-java/