Eliminar carpetas usando Java

1. Use remove() de la clase Archivo para eliminar carpetas vacías usando Java
2. Eliminar carpetas recursivamente usando Java
3. Use Java 8 Streams y NIO2 para eliminar carpetas usando Java
4. Use Apache Common IO para eliminar carpetas usando Java
5. Conclusión

En este artículo, aprenderemos cómo eliminar carpetas/directorios utilizando el lenguaje de programación Java. Hay varias maneras de hacer esto. Veámoslos uno por uno.

Use remove() de la clase Archivo para eliminar carpetas vacías usando Java

En Java tenemos la clase java.io.File, que contiene un método llamado delete() que sirve para borrar archivos y vaciar directorios.

Sintaxis:

file_object.delete()

Supongamos que existe un directorio vacío con el nombre prueba en la unidad D: de nuestro sistema. Ahora, veamos cómo borrar esto usando el método delete().

Código de ejemplo:

import java.io.File;

public class Example {
  public static void main(String[] args) {
    String path = "D:\\test";
    File obj = new File(path);
    obj.delete();
  }
}

Cuando se ejecuta el código anterior, vemos que la carpeta prueba se elimina de la unidad D: de nuestro sistema.

En el código anterior, hemos creado una variable de cadena que almacena la ruta del directorio. Luego usamos esta ruta para crear nuestro objeto de archivo obj.

Por último, hemos utilizado el método delete(), que elimina el directorio en esa ruta a la que hace referencia el objeto de archivo obj.

Pero, ¿y si la carpeta prueba contiene algunos archivos, digamos archivo1.txt y archivo2.txt? En este escenario, cuando se ejecuta el código anterior, no sucede nada ya que el directorio no está vacío y sabemos que el método delete() solo funciona para directorios vacíos.

Podemos superar este problema de eliminar directorios que no están vacíos mediante la eliminación recursiva.

Eliminar carpetas recursivamente usando Java

En este método, usaremos el método delete() junto con la recursividad. La idea es eliminar primero todas las subcarpetas y archivos presentes dentro de nuestro directorio test, y una vez que esté vacío, podemos eliminarlo usando el método delete().

Estructura de directorios:

             test
           /  |  \
          /   |   \
         /    |    \
   file1.txt  |   file2.txt
              |
             hero
            /    \
     file3.txt    file4.txt

Tenemos una carpeta test en la unidad D:, que tiene dos archivos de texto: file1.txt y file2.txt y una subcarpeta hero, que nuevamente contiene dos archivos de texto: file3.txt y archivo4.txt.

Así que aquí, eliminaremos archivo1.txt, archivo2.txt, y luego entraremos en la subcarpeta héroe y eliminaremos archivo3.txt y archivo4.txt. Como la subcarpeta está vacía, podemos eliminarla fácilmente.

Después de todo esto, el directorio prueba también queda vacío, que se puede eliminar fácilmente utilizando el método delete().

Algoritmo:

Tenemos que usar dos funciones para implementar el algoritmo anterior: listFiles() y isDirectory().

El método listFiles() devuelve una matriz de rutas abstractas (objetos) de todos los archivos y subcarpetas en nuestro directorio de destino. El isDirectory() es una función booleana que devuelve true si el objeto actual es un directorio; de lo contrario, devuelve false.

Código de ejemplo:

import java.io.File;

public class Example {
  static void recursiveDelete(File targetDirectory) {
    File[] data = targetDirectory.listFiles();

    for (File file : data) {
      if (file.isDirectory())
        recursiveDelete(file);

      else
        file.delete();
    }

    targetDirectory.delete();
  }

  public static void main(String[] args) {
    String path = "D:\\test";
    File obj = new File(path);
    recursiveDelete(obj);
  }
}

Use Java 8 Streams y NIO2 para eliminar carpetas usando Java

En este método, podemos usar el método Files.walk(Path) que devuelve Stream<Path>, que contiene todos los archivos y subcarpetas en esa ruta.

Código de ejemplo:

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

public class Example {
  public static void main(String[] args) throws IOException {
    Path path = Paths.get("D:\\test");

    Files.walk(path).sorted(Comparator.reverseOrder()).forEach(data -> {
      try {
        System.out.println("deleting: " + data);
        Files.delete(data);
      } catch (IOException obj) {
        obj.printStackTrace();
      }
    });
  }
}

Cuando se ejecuta el código anterior, elimina todo el contenido del directorio y luego el directorio en sí mismo en una forma de búsqueda en profundidad primero.

Producción :

deleting: D:\test\hero\file4.txt
deleting: D:\test\hero\file3.txt
deleting: D:\test\hero
deleting: D:\test\file2.txt
deleting: D:\test\file1.txt
deleting: D:\test

Use Apache Common IO para eliminar carpetas usando Java

Hasta ahora, todos los métodos que hemos visto son simples métodos antiguos de Java que usan algunos conceptos de recursividad junto con métodos de archivo y flujo. Pero podemos usar Apache Common IO FileUtils.deleteDirectory para eliminar un directorio.

La principal ventaja de usar esto sobre los métodos primitivos de Java es que la línea de códigos (LOC) es significativamente menor, lo que lo convierte en una forma de escritura más fácil y eficiente.

Para usar Apache common IO, primero debemos agregar dependencias en nuestro archivo pom.xml.

<dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.11.0</version>
</dependency>

Código de ejemplo:

import java.io.*;
import org.apache.commons.io.FileUtils;

public class Example {
  public static void main(String[] args) throws IOException {
    String path = "D:\\test";
    File obj = new File(path);
    FileUtils.deleteDirectory(obj);
  }
}

Conclusión

Este artículo ha mostrado diferentes formas de eliminar directorios usando Java. Entendimos cómo usar la recursión y las secuencias de Java 8.

También entendimos cómo el uso de Apache Commons IO podría ser más eficiente y ahorrar tiempo donde LOC (línea de códigos) afecta en gran medida el rendimiento de nuestro proyecto.