Java: compruebe si el archivo o el directorio están vacíos

En este tutorial, repasaremos ejemplos de código de cómo verificar si un archivo o directorio está vacío en Java usando las clases File, Files y DirectoryStream.

Introducción

En Java, trabajar con archivos y directorios es bastante común. A menudo también estamos interesados ​​en el contenido de esos archivos y directorios.

Dependiendo del contenido del archivo, es posible que queramos comportarnos de manera diferente. Podríamos estar escribiendo algunos datos en un archivo y primero queremos verificar si ya contiene alguna información antes de sobrescribirla. Del mismo modo, es posible que queramos eliminar un directorio si está vacío. El conocimiento de si está vacío o no puede, en estos casos, ser de vital importancia.

En este tutorial, repasaremos algunos ejemplos de cómo verificar si un archivo o directorio está vacío en Java.

Comprobar si un archivo está vacío en Java

Hay dos formas de comprobar si un Archivo está vacío.

Trabajaremos con dos archivos, uno vacío y otro no vacío:

1
2
09/17/2020  01:00 PM                 0 file
09/17/2020  01:00 PM                 2 file2

archivo tiene una longitud de 0 bytes, mientras que archivo2 tiene una longitud de 2 bytes.

Vale la pena señalar que antes de realizar cualquier operación en un archivo o directorio, también debe verificar si existe un archivo o directorio como su tipo para evitar ejecutar los métodos incorrectos.

Uso de File.length()

De acuerdo con su documentación, un objeto File es "una representación abstracta de nombres de ruta de archivos y directorios ". Cada objeto File tiene métodos para obtener información sobre ese archivo específico.

Avancemos y creemos un método de ayuda simple que devuelva “verdadero” si la longitud del “archivo” es “0” y “falso” en caso contrario:

1
2
3
public boolean isFileEmpty(File file) {
    return file.length() == 0;
}

Ahora, probemos en un archivo vacío y no vacío:

1
2
3
4
5
File file1 = new File("/file");
File file2 = new File("/file2");

System.out.println(isFileEmpty(file1));
System.out.println(isFileEmpty(file2));

Este código devuelve:

1
2
true
false

Usando BufferedReader

Otra forma de verificar si la longitud del Archivo es 0 o no es usar BufferedReader. Nos permite llegar a los contenidos de los caracteres de las secuencias (como los archivos). Si no hay contenido en el archivo, está vacío:

1
2
3
4
public boolean isFileEmpty(File file) {
    BufferedReader br = new BufferedReader(new FileReader(file));     
    return br.readLine() == null;
}

La declaración del método sigue siendo la misma que antes: acepta un ‘Archivo’ y devuelve un ‘booleano’. Aunque esta vez, hemos instanciado un BufferedReader y le hemos proporcionado un FileReader que acepta nuestro File. Es ligeramente más complejo que antes, pero hace el trabajo igual de bien.

Entonces, si BufferedReader no tiene nada que leer del archivo, sabemos que está vacío.

Nuevamente, probemos esto en un archivo vacío y no vacío:

1
2
3
4
5
File file1 = new File("/file");
File file2 = new File("/file2");

System.out.println(isFileEmpty(file1));
System.out.println(isFileEmpty(file2));

Este código devuelve:

1
2
true
false

Comprobar si el directorio está vacío en Java

También hay dos formas de verificar si un directorio está vacío en Java.

Usando File.list()

La clase File tiene un método conveniente para recopilar todos los archivos y directorios (entradas, es decir, tanto archivos como directorios) dentro de un directorio dado. Podemos usar este método para verificar si el número de tales entradas es cero:

1
2
3
4
public boolean isDirectoryEmpty(File directory) {  
    String[] files = directory.list();
    return files.length == 0;  
}

El método devuelve una matriz de nombres de entrada. Si la longitud de esta matriz es 0, el directorio está vacío.

Ejecutemos esto en un directorio vacío y no vacío:

1
2
3
4
5
File directory1 = new File("/empty_directory");
File directory2 = new File("/directory");

System.out.println(isDirectoryEmpty(directory1));
System.out.println(isDirectoryEmpty(directory1));

Esto devuelve:

1
2
true
false

Uso de DirectoryStream

Otra técnica rápida, aunque más avanzada, implica el uso de secuencias. Primero, creamos un nuevo DirectoryStream llamando a la clase Files.newDirectoryStream(). Este método acepta una Ruta por lo que necesitamos convertir nuestro Archivo en una Ruta llamando al método toPath():

1
2
3
4
public boolean isDirectoryEmpty(File directory) throws IOException {
    DirectoryStream<Path> stream = Files.newDirectoryStream(directory.toPath());
    return !stream.iterator().hasNext();  
}

Luego, recopilamos el iterador de flujo y verificamos si contiene una entrada siguiente llamando a hasNext(). Si no contiene al menos una entrada, el directorio está vacío.

Vamos a ejecutar este código:

1
2
3
4
5
File directory1 = new File("/empty_directory");
File directory2 = new File("/directory");

System.out.println(isDirectoryEmpty(directory1));
System.out.println(isDirectoryEmpty(directory1));

Y esto da como resultado:

1
2
true
false

Conclusión

En este tutorial, hemos establecido algunos ejemplos para verificar si los archivos y directorios están vacíos. Primero, verificamos si los archivos están vacíos usando la clase File y su método length(), seguido de un enfoque BufferedReader.

Luego, verificamos si un directorio está vacío usando File.list() y creando un DirectoryStream.

Licensed under CC BY-NC-SA 4.0