Cargando

Ir a contenido


 


Generando archivos desde Java

En este tutorial veremos todo lo relacionado con la generación de archivos en Java, las clases involucradas en el proceso así como sus métodos y las operaciones que podemos realizar sobre estos.


Escrito por el dic 09 2014 01:00 java


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:

exists()
Este método nos da una respuesta booleana sobre la existencia de un determinado archivo en un directorio que especifiquemos al momento de invocarlo, obviamente retorna verdadero o true si el archivo se encuentra y falso o false si no es así.


getCanonicalPath()
Este método nos devuelve el nombre completo incluyendo la ruta del archivo, es muy importante para obtener la posición absoluta de nuestro archivo dentro del sistema donde estamos ejecutando nuestro programa.


getName()
Al contrario del método anterior, este solo nos devuelve el nombre relativo y corto del archivo, es decir, sin incluir dirección o carpeta donde se encuentra el mismo.


canRead()
Este método nos permite verificar si tenemos el permiso para leer el archivo, es muy importante para validar si podemos o no leer un archivo antes de emprender una operación con el mismo, de esta forma podemos disminuir las excepciones y ahorrar recursos del sistema.


canWrite()
Este es otro método que nos ayuda a validar los permisos sobre los archivos, al aplicarlo sobre una instancia de la clase File nos dará a conocer si podemos escribir el archivo correspondiente.


length()
Este método es uno de los más útiles ya que nos permite saber el tamaño de un archivo, una comprobación importante a la hora de hacer procesamientos.


isFile()
Por último este método nos permite saber si lo que estamos evaluando es un archivo o un directorio, así sabremos si estamos trabajando sobre la estructura que deseamos.


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.

¿Cómo hacerlo?
Renombrar un archivo en Java requiere dos objetos del tipo File, el primero va a contener el archivo que queremos renombrar y el segundo contiene el nuevo nombre del archivo, una vez que cumplimos esas condiciones debemos llamar al método renameTo() sobre el objeto del archivo existente y pasarle el nuevo objeto con el nombre nuevo.


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.
¿Te ha gustado y ayudado este Tutorial?
Puedes premiar al autor pulsando este botón para darle un punto positivo
  • -
  • 0
10
VOTA
5
100%
4
0%
3
0%
2
0%
1
0%

  Información

  •   Publicado dic 09 2014 01:00
  •   Actualizado dic 09 2014 20:16
  •   Visitas 916
  •   Nivel
    Profesional



Tutoriales Relacionados


Sin comentarios, sé el primero!

No esperes más y entra en Solvetic
Deja tus comentarios y aprovecha las ventajas de la cuenta de usuario ¡Únete!
Demuestra que eres experto!
  ESCRIBIR TUTORIAL
Suscribirse