ARCHIVOS EN JAVA.

Todas las estructuras comentadas en los temas anteriores para almacenar los datos, residen en memoria. De hecho cuando el programa termina, desaparecen. Para evitar este problema existen los archivos. Se trata de un elemento que pone a disposición el Sistema Operativo para almacenar información de todo tipo bajo un nombre y una extensión. La extensión indica el tipo de archivo que tenemos. En definitiva es la estructura habitual en la que se almacena información y cuyo manejo parte de que sabemos sus fundamentos en base al sistema operativo que estemos manejando. Su finalidad es la de poder almacenar datos de forma permanente. 

La forma de interactuar con los sistemas de archivos locales se realiza a través de la clase File, esta clase proporciona muchas utilidades relacionadas con archivos y con la obtención de información básica sobre esos archivos.

Los tipos de archivos que maneja java son:

Archivos de texto.

Archivos binarios.

ARCHIVOS DE TEXTO:

Son aquellos archivos que sólo almacenan datos de tipos carácter o cadenas de caracteres. 

Son utilizados para: 

Información del tipo registro. 

Guardar información que no necesita de un formato específico. 

Guardar información de cualquier otro tipo en estos archivos no es una solución 

óptima.

Los archivos de texto en Java se manejan mediante la clase BufferedReader y la clase PrintWriter.

BufferedReader:

Es una clase de las librerías java.io, es bastante precisa a la hora de capturar datos. Al instanciarse, debemos pasarle como parámetro un objeto Reader, de preferencia unInputStreamReader, también de la clase java.io, que crea un flujo de lectura al pasarle el parámetro System.in (ya luego de su creación, bastará con llamar el métodoBufferedReader.readLine() para leer el texto desde la consola, aclarando que ese método leerá todo cuanto hayamos escrito antes de presionar Enter, incluso espacios):

1	BufferedReader lector=new BufferedReader(new InputStreamReader(System.in));

Como vemos, estamos creando la instancia de un objeto InputStreamReader donde van los parámetros de la nueva instacia del BufferedReader, esto es posible gracias a que (probablemente) el InputStreamReader lo vamos a usar una sola vez. Si llegaramos a reutilizarlo, lo recomendable sería:

1 2 3

InputStreamReader flujoLectura=new InputStreamReader(System.in); BufferedReader lector=new BufferedReader(flujoLectura); BufferedReader segundoLector=new BufferedReader(flujoLectura);

Así evitamos tener que instanciar varias veces algún nuevo objeto InputStreamReader, si es que lo reutilizamos. Al final, podremos leer con un código como el siguiente:

1	String frase=lector.readLine();

Leeremos la línea completa que hayamos escrito antes de presionar Enter en la consola. Se incluirán los espacios, por lo que si escribimos, por ejemplo, puros espacios dejando presionada la barra espaciadora, esos espacios se almacenarán en el String que escojamos, dándole un tamaño mayor que 0 al mismo.

PrintWriter:

Clase pensada para secuencias de datos orientados a la impresión de textos. Es una clase escritora de caracteres en flujos de salida, que posee los métodos print y println, que otorgan gran potencia a la escritura. 

Un objeto PrintWriter se crea a partir de un objeto FileWriter.

Ejemplo:

FileWriter fw = new FileWriter("c:/ficheros/datos.txt");

PrintWriter salida = new PrintWriter(fw);

A partir de Java 5 se puede crear un objeto PrintWriter directamente a partir de un objeto File o de la ruta:

PrintWriter salida = new PrintWriter("c:/ficheros/datos.txt");

En este caso, si el fichero no existe se crea. Si no se puede crear un archivo con ese nombre o si ocurre algún error se lanza una excepción FileNotFoundException.

Una vez creado el objeto podemos utilizar print(), println() y printf() para escribir en el fichero como si fuese en pantalla.

ARCHIVOS EN BINARIOS:

Es un archivo informático que contiene información de cualquier tipo codificada en binario para el propósito de almacenamiento y procesamiento en ordenadores. Por ejemplo los archivos informáticos que almacenan texto formateado o fotografías, así como los archivos ejecutables que contienen programas.

Muchos formatos binarios contienen partes que pueden ser interpretadas como texto. Un archivo binario que sólo contiene información de tipo textual sin información sobre el formato del mismo se dice que es un archivo de texto plano. Habitualmente se contraponen los términos 'archivo binario' y 'archivo de texto', de forma que los primeros no contienen solamente texto.

CREACIÓN DE ARCHIVOS.

Para crear un fichero con Java nos tenemos que apoyar en la clase File de Java IO la cual nos proporciona un método creteNewFile que generará el fichero en el path que le indiquemos.

Si bien debemos de tener en cuenta que el "directorio base" donde creemos el fichero debe de existir. Por ejemplo, en el caso de que creemos un fichero indicando el path "c:templineadecodigoficheroTexto", los directorios temporal y lineadecodigo deben de existir.

Así instanciaremos el objeto File de la siguiente forma:

File fichero = new File ("c:\temp\lineadecodigo\fichero.txt");

o bien indicando el directorio y el fichero por separado:

File fichero = new File ("c:\temp\victor","fichero.txt");

Debemos de tener cuidado en utilizar la doble barra para indicar el directorio ya que cuando utilizamos la barra sola se asume que es una secuencia de escape del estilo n b t...

Una vez creado el fichero simplemente bastará invocar el método createNewFile teniendo cuidado de que puede ser lanzada la excepción IOException a si que debemos de capturarla.

try {


  // A partir del objeto File creamos el fichero físicamente


  if (fichero.createNewFile())


    System.out.println("El fichero se ha creado correctamente");


  else


    System.out.println("No ha podido ser creado el fichero");


} catch (IOException ioe) {


  ioe.printStackTrace();


}

El método devolverá true si ha podido crear el fichero y false si no ha podido llevarlo a cabo.

GRABACIÓN DE ARCHIVOS:

Si vamos a escribir en un fichero de texto, sería una buena práctica el validar si dicho fichero existe o no. También podríamos escribir sobre el fichero directamente. Ahora que esto lo haríamos si no nos importase mucho el contenido que este tuviese.

Para validar si existe un fichero podemos leer el ejemplo saber si existe un fichero con java. Dicho artículo nos explica de forma detallada lo simple que esto resulta.

Resumiendo, bastará utilizar el método exists() de la clase File.

String sFichero = "fichero.txt";


File fichero = new File(sFichero);





if (fichero.exists()) {...}

En el caso de que no exista el fichero, nos pondremos manos a la obra para escribir sobre el fichero.

Lo primero que tendremos que hacer será crear un BufferedWriter. Esta clase nos ayuda a manejar los stream en forma de buffer con métodos muy sencillos. Este buffer necesitará saber cual es el fichero. Esto se lo proporcionamos desde la clase FileWriter.

Recuerda que la filosofía de acceso a la lectura y escritura a los ficheros, siempre es la misma. Buffer, que envuelve a Reader, que a su vez envuelve al fichero (o stream).

El código nos quedaría algo así:

BufferedWriter bw = new BufferedWriter(new FileWriter(sFichero));

Para escribir texto nos apoyamos en el método .write() del buffer. Muy sencillo. La verdad es que no se me ocurría que texto grabar sobre el fichero, a si que, al final, vamos a volcar 10 líneas iguales ayudándonos de un bucle for.

for (int x=0;x<10;x++)


   bw.write("Fila numero " + x + "\n");

No nos podemos olvidar de dos últimas cosas. Siempre que manejemos el fichero para escribir deberemos de cerrarle con el método .close().

Y lo otro, que toda la operativa de la clase java.io.* nos avisará de sus problemas de acceso a fichero, elevándonos una excepción IOException. Que habrá que capturar en alguna parte de nuestro código.

CONSULTA DE ARCHIVOS.

Por nuestro bien, cuando estamos trabajando con ficheros, deberíamos de validar la existencia o no del fichero o directorio con el que vamos a trabajar. Ahora, que hay mucho lanzado en esta vida, que puede pensar que que más da.

Claro, que si instanciamos la clase File, en Java, con un fichero que no existe y por ejemplo, intentamos recuperar el tamaño del mismo, no nos vamos a llevar ninguna desagradable sorpresa de que salte una excepción y nos desmonte el "chiringuito".

Pero, como más vale prevenir que curar, en primer lugar instanciaremos la clase File con el path que queramos investigar:

String sFichero = "c:\misficheros\fichero.txt";


File fichero = new File(sFichero);

Solo nos quedará invocar al método exits() para conocer si existe o no el fichero instanciado:

if (fichero.exists())


  System.out.println("El fichero " + sFichero + " existe");


else


  System.out.println("Pues va a ser que no");