Eliminar archivos en un directorio usando Java

1. Eliminar archivos en un directorio usando delete() de la clase File en Java
2. Eliminar archivos en un directorio usando Java 8 Streams y NIO2
3. Eliminar archivos en un directorio usando Apache Common IO
4. Conclusión

En este artículo, aprenderemos cómo eliminar archivos presentes dentro de la carpeta sin eliminar la carpeta en sí.

Hay varias maneras de hacer esto. Veámoslos uno por uno.

Eliminar archivos en un directorio usando delete() de la clase File en 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 en la unidad D: de nuestro sistema existe un directorio con un nombre como prueba, y digamos que contiene algunos archivos de texto y algunas subcarpetas. 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);

    for (File temp : Objects.requireNonNull(obj.listFiles())) {
      if (!temp.isDirectory()) {
        temp.delete();
      }
    }
  }
}

Cuando se ejecuta el código anterior, podemos ver que todos los archivos dentro de la prueba se eliminan, pero la carpeta principal prueba y las subcarpetas no se modifican.

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

Luego usamos el método listFiles() para listar los contenidos presentes en esa ruta.

Usando la condición if, comprobamos si es un directorio o un archivo. Si es un archivo, lo borramos; de lo contrario, no hacemos nada.

Eliminar archivos en un directorio usando Java 8 Streams y NIO2

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

Luego verificamos si es un directorio o un archivo usando la condición if. Si es un archivo, lo borramos; de lo contrario, no hacemos nada.

Código de ejemplo:

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

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

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

Producción :

deleting: D:\test\subfolder 2\file4.txt
deleting: D:\test\subfolder 1\file3.txt
deleting: D:\test\file2.txt
deleting: D:\test\file1.txt

Cuando se ejecuta el código anterior, elimina todos los archivos del directorio y los archivos del subdirectorio en una forma de primera búsqueda en profundidad.

Podemos observar que el directorio prueba y los subdirectorios subcarpeta 1 y subcarpeta 2 permanecieron intactos.

Eliminar archivos en un directorio usando Apache Common IO

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.cleanDirectory() para eliminar recursivamente todos los archivos y los subdirectorios dentro del directorio principal sin eliminar el directorio principal en sí.

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 las 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.cleanDirectory(obj);
  }
}

Conclusión

Este artículo ha mostrado diferentes formas de eliminar directorios usando Java. Entendimos cómo usar el método delete() y los flujos de Java 8 y cómo usar 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.