A pesar que trabajar con Bases de Datos es algo muy bueno y que nos ahorra mucha cantidad de trabajo al momento de hacer consultas y relacionar registros, hay veces en las que necesitamos generar archivos, ya sea que no tenemos un servidor de Base de Datos disponibles o tal vez porque no necesitamos guardar un registro si no un conjunto de datos sin relación.

El manejo de archivos es un área que aún muchos ven como algo complejo o tal vez obsoleto, sin embargo esto es incorrecto, la generación de archivos es vital en el desarrollo de sistemas y aplicaciones. Un archivo puede ir desde la generación de un .txt con algunas líneas en particular, hasta la generación de grandes .xml que nos pueden definir una configuración.

La clase java.io.File

Para poder manejar todo lo que involucra crear un archivo en un sistema, Java cuenta con la clase File dentro del paquete de librerías para el manejo de entrada y salida de datos java.io. Esta clase nos provee de diferentes métodos que nos permiten realizar operaciones que van desde crear y borrar archivos, hasta crear directorios, validar permisos, etc.

Métodos principales

Antes de ver en la práctica cómo podemos utilizar la clase para realizar operaciones de archivos, debemos entender que hacen algunos de sus métodos principales, con ello tendremos una base teórica a la cual podemos acudir cuando se nos presente algún problema en particular que requiera del manejo de archivos en nuestros programas:

Crear un archivo

La creación de un archivo es un proceso mediante el cual escribimos dentro del sistema donde se ejecuta nuestro programa. Hay una diferencia entre escribir un archivo y escribir dentro de un archivo, la primera nos indica que generamos el fichero dentro del sistema, pero no necesariamente le hemos agregado el contenido; en cambio la segunda nos indica que a un archivo existente le añadimos contenido.

Podrán preguntarse para que queremos un archivo vacío, un archivo vacío no es algo inútil, puede ser parte de un proceso mayor dentro de una aplicación, por ejemplo un método crea el archivo y luego de un resultado de un proceso, otro método se encarga de añadir datos al mismo. También puede ser vital en las validaciones, donde generamos archivos temporales para indicar al programa en qué fase del proceso estamos, etc.

Veamos a continuación un pequeño código donde generamos un archivo plano vacío.

import java.io.*;
import java.io.File;

public class CrearArchivos {
public static void main(String[] argv) throws IOException {
	
	 if (argv.length == 0) {
	 	 System.err.println("Debe escribir un nombre por parametro");
		 System.exit(1);
	 }
	 for (String nombrearchivo : argv) {
		 new File(nombrearchivo).createNewFile();
	 }
}
}

Vemos que lo primero que hacemos es una importación de las clases de java.io para poder tener acceso al manejo de excepciones con IOException, luego importamos la clase java.io.File que es la que nos permite manipular los archivos directamente.

Luego creamos nuestra clase y en su método main indicamos que recibirá argumentos, esto lo hacemos para poder indicar de forma dinámica los nombres de los archivos. Como necesitamos un nombre, lo que hacemos es una pequeña validación, que indica que si no se recibe un nombre de archivo se pide que se coloque y se termina el programa. Por último por cada argumento recibido crearemos un nuevo archivo, con ello lo que hacemos es una nueva instancia de la clase File y con el método createNewFile() generamos el archivo en el sistema.

Debemos estar conscientes que si nuestro programa no tiene suficientes permisos para crear un archivo en su directorio obtendremos un error. Sin más veamos como luce nuestro programa al ejecutarlo en la consola:

Podemos notar como funcionó nuestra validación inicial y luego cuando le hemos pasado el nombre del archivo se ha generado, para verificar esto último simplemente hemos hecho un dir de nuestro directorio y así comprobamos la existencia del archivo.

Renombrar el archivo

Otra de las operaciones más comunes al trabajar con archivos luego de escribir y borrar es renombrar, para ello en Java debemos seguir un proceso que puede parecer complicado pero que como veremos en el ejemplo que acompañará a la explicación es algo bastante fácil de entender.



Veamos el código que necesitamos para realizar la operación de renombrado sobre nuestro archivo:

import java.io.*;
import java.io.File;

public class RenombrarArchivos {
public static void main(String[] argv) throws IOException {
	 File objetoPrimero = new File("ArchivoNuevo.txt");
	 File objetoSegundo = new File("ArchivoConNuevoNombre.txt");
	 objetoPrimero.renameTo(objetoSegundo);
}
}

Hacemos las importaciones de clases y paquetes correspondientes, manteniendo las mismas del ejemplo anterior.

Dentro del método main() vamos a crear nuestro primer objeto y le vamos a colocar el nombre del archivo que habíamos creado en el ejemplo anterior en este caso es ArchivoNuevo.txt. Luego creamos un segundo objeto con el nuevo nombre que deseamos para nuestro archivo, en el ejemplo hemos elegido ArchivoConNuevoNombre.txt.

Finalmente al primer objeto le aplicamos el método renameTo() y como argumento o parámetro le pasamos el segundo objeto que tiene el nuevo nombre para nuestro archivo. Veamos como luce en la consola cuando ejecutamos nuestro código:

Notamos como cambió la carpeta y ahora refleja nuestro nuevo archivo respecto a la ejecución del primer ejemplo de creación de archivos.

Borrar un archivo

Finalmente veremos la otra operación que es bastante común al trabajar con archivos y es la de borrar, esta es quizás una de las más simples, ya que solo necesitamos saber el nombre del archivo, validar que exista y luego proceder a borrarlo utilizando el método delete() donde le pasaremos el nombre del archivo en cuestión. Veamos en el siguiente código como logramos esto:

import java.io.*;
import java.io.File;

public class BorrarArchivo {
public static void main(String[] argv) {
			
	 borrar('ArchivoConNuevoNombre.txt');
}
public static void borrar(String nombreArchivoBorrar) {
	 try {
		
		 File archivo = new File(nombreArchivoBorrar);
		 if (!archivo.exists()) {
			 System.err.println("El archivo " + nombreArchivoBorrar +
				 " no existe en este directorio");
			 return;
		 }
		
		 if (archivo.delete())
			 System.err.println("** El archivo " + nombreArchivoBorrar + " ha sido borrado **");
		 else
			 System.err.println("No se ha podido borrar el archivo: " + nombreArchivoBorrar);
	 } catch (SecurityException e) {
		 System.err.println("No es posible borrar el archivo: " + nombreArchivoBorrar +
			 "(" + e.getMessage() + ")");
	 }
}
}

Vemos que este programa es un poco más extenso que los anteriores, esto se debe a que hemos creado una función reutilizable para el borrado de archivos, donde validamos en primer lugar que el archivo exista, luego procedemos a hacer el borrado del mismo, aquí vamos a validar que efectivamente haya sido borrado, de lo contrario le informamos al usuario que el archivo no pudo ser eliminado del sistema de archivos.

En consola podemos observar como pudimos ejecutar con éxito esta operación, para ello utilizamos el archivo que habíamos renombrado en el ejemplo anterior, por lo que al hacer un listado del contenido de la carpeta veremos el cambio reflejado:

Finalmente vamos a intentar borrar nuevamente para que podamos observar las validaciones trabajando:

Con esto damos por finalizado este tutorial, hemos aprendido a generar archivos, además de ejecutar dos de las acciones más usadas para la manipulación de archivos, con esto podremos incorporar estas técnicas en nuestros programas y aplicaciones, disfrutando de las ventajas que este tipo de técnicas nos puede traer.