Bachillerato en Ciencias de la Educacin con nfasis en la enseanza de la Informtica

Curso: Programacin II

Fundamentos de archivos en Java

Profesor. Ing. Rodolfo Echandi Pacheco

Ivania Corrales Castro

II cuatrimestre, 2012

INDICE
Introduccin ............................................................................................................ 3 Fundamentos de archivos........................................................................................... 4 Clases necesarias para el uso de archivos .......................................................................... 5
Byte Streams ............................................................................................................................... 6 Character Streams ....................................................................................................................... 6 Buffered Stream .......................................................................................................................... 7 Data & Object Stream ................................................................................................................. 9

Importancia de las excepciones en el uso de archivos .................................................... 10 Archivos de acceso secuencial.......................................................................................... 11 Archivos de objetos .......................................................................................................... 11 Archivos de acceso aleatorio ............................................................................................ 12 Archivos de texto .............................................................................................................. 12 Conclusin ............................................................................................................ 14 Bibliografa ............................................................................................................ 16

2 II

Introduccin

El presente trabajo incluye una breve recopilacin de cmo se maneja el tema de fundamentos de archivos en Java y la importancia que tiene conocer como el procesamiento organizado y bien estructurado de datos a informacin culmina en archivos o ficheros en Java. Adems, se describe las clases necesarias para el uso de archivos, debido a que muchas aplicaciones tienen acceso a los dispositivos estndar y a los archivos en disco, este lenguaje define un conjunto de clases agrupadas en jerarquas que describen los distintos flujos (streams) de datos. Para algunas de estas clases doy un ejemplo programado en Java. Se analizar tambin la importancia de las excepciones en el uso de archivos; los programadores en cualquier lenguaje se esfuerzan por escribir programas libres de errores y el manejo de excepciones precisamente se ocupa de esto en cualquier aplicacin de archivos que se construya; en este caso mostrar los tipos de mecanismos sugeridos que se pueden usar para el manejo de excepciones. Describir en forma breve como Java administra y controla el uso de archivos tanto para la entrada y salida de la informacin o dicho de otra forma la lectura y escritura de datos. Para terminar mencionar como la organizacin de un archivo define la forma en la en que se estructuran u organizan los datos. Algunas de estas formas son: archivos secuenciales, de acceso aleatorio, archivos de texto u objetos.

3 III

Fundamentos de archivos
Para entender un poco lo que son archivos se debe de entender que es dato1. Los datos son expresiones generales que describen caractersticas de las entidades sobre las que operan los algoritmos. Estas expresiones deben presentarse de una cierta manera para que puedan ser tratadas por una computadora. Pero el dato por s mismo no representa nada a menos que se le pueda dar un tratamiento o procesamiento a los mismos a fin de convertir los datos en informacin.

La informacin es un conjunto de datos relacionados que constituyen una estructura de mayor complejidad como por ejemplo, un captulo de un libro de espaol o ciencias. En otras palabras, un conjunto de datos convenientemente estructurado y organizado. Los archivos o tambin llamados ficheros son una coleccin de informacin, (relacionados entre s), localizada o almacenada como una unidad en alguna parte de la computadora. Los archivos son el conjunto organizado de informaciones del mismo tipo, que pueden utilizarse en un mismo tratamiento. Los archivos se tratan como coleccin de datos que sirven para la entrada y salida a la computadora y son manipulados por programas. Este tipo de estructura es muy verstil y dinmica. A continuacin algunas caractersticas de los archivos: Independencia de las informaciones respecto de los programas. La informacin almacenada es permanente. Un archivo puede ser accedido por distintos programas en distintos momentos. Gran capacidad de almacenamiento.

Los archivos pueden actuar como origen o destino de un flujo de datos (streams). El manejo de archivos (persistencia), en Java nos permite interactuar con los dispositivos de almacenamiento externo para poder mantener la informacin en el tiempo.

http://lema.rae.es/drae/srv/search?id=ZUywCd3jZDXX2oYEJj5p|SZrU79n8CDXX2HlbL8FA: Informacin dispuesta de manera adecuada para su tratamiento por un ordenador

Clases necesarias para el uso de archivos

La librera de entrada y salida de Java (java.io) divide las clases que manejan los flujos en dos grandes categoras: las clases lectoras que se ocupan de los flujos de entrada y las clases escritoras que se ocupan de los flujos de salida.

La forma de interactuar con los sistemas de archivos locales se realiza a travs de la clase File, esta clase proporciona muchas utilidades relacionadas con archivos y con la obtencin de informacin bsica sobre esos archivos y adems forma parte de los streams de Java. En Java, el esquema de entrada y salida de datos (streams) est dado de la siguiente forma:

Streams: Es una abstraccin, que representa a un flujo de datos entre un origen y un destino en Java. Todo proceso de entrada y salida en Java se hace a travs de flujos.

Estos diferentes streams (secuencia de datos que van desde o hacia algn medio, como un puente que nos comunica con los datos) se acomodan a los requerimientos del programador y permitan escribir o leer por lneas o bien todo el archivo completo, preferiblemente usando bytes y evitando la conversin a caracteres. Al usar las clases debemos tener en cuenta (como recomendacin): Importar las Clases especficas necesarias para I/O. Instanciar los objetos I/O y hacerlos igual a null. En medio de una sentencia try inicializar nuestros objetos I/O y abrir el archivo a manipular, manipularlo. Arrojar (throw) o capturar (catch) las excepciones de cada objeto I/O manipulado. (obligatorio para manejar archivos.) En una sentencia finally cerrar nuestros objetos I/O. 5

Los pasos anteriores no son obligatorios al trabajar en Java, pero si recomendable, ya que cuando discriminamos las libreras especficas, le decimos al compilador exactamente donde est el objeto que utilizaremos. No es lo mismo decir "el archivo trabajo.txt est en el disco local" a "el archivo trabajo.txt se encuentra dentro de la carpeta Trabajos en mi carpeta personal", lo mismo sucede al importar, no es lo mismo importar "java.io.* " a "java.io.FileInputStream" el * (asterisco) es como un comodn que le dice al compilador algo como "busque entre todo eso". Especficamente, la definicin y uso de los stream en java son:

Byte Streams
El flujo de datos por medio de Byte Stream se hace byte a byte interpretando a 8-bit tanto para la entrada como para la salida de datos, generalmente usados para datos binarios, lenguaje maquina; an as son igualmente vlidos para tratar lenguaje humano como archivos de texto (.txt). Una de las clases de bytestreams (no es la nica) es FileInputStream/FileOutputStream, para su uso se debe tener en cuenta. Ubicacin de la clase a importar: java.io.FileInputStream / java.io.FileOutputStream; Excepciones a capturar/arrojar: java.io.IOException (excepcin arrojada cuando el archivo abierto no existe/ no es encontrado.) Ejemplo: Este programa permite duplicar archivos.

Character Streams
6

Flujo de datos de byte de byte interpretado a 16-bit, los Characters Streams son interpretados automticamente al formato local de carcteres. Usado preferiblemente para tratar con informacin humana, textos. Los Character Streams descienden tanto de Reader, Writer como de los Byte Streams, sus clases especializadas en I/O son FileReader y FileWriter. Ubicacin de la clase a importar: java.io.FileReader/ java.io.FileWriter; Excepciones a capturar/arrojar: java.io.IOException (excepcin arrojada cuando el archivo abierto no existe/ no es encontrado.)

Buffered Stream
Un buffered stream puede ser visto simplemente como leer o escribir muchos datos al tiempo y no byte a byte como veamos anteriormente. Especficamente un buffer es una seccin de la memoria que retiene datos mientras van de un lado a otro de esta forma, el trabajo de escribir/leer realizado por un programa es ms eficiente ya que por ejemplo al momento de leer, la forma nativa de como un SO escribe informacin solo es llamado cuando el buffer este lleno y no a cada momento. En java existen 4 clases tipo Buffer, dos para entrada y dos para salida las cuales son construidas a partir de byte stream o character streams. Por ejemplo:

Usando constructores ByteStreams:

in = new BufferedInputStream ( new FileInputStream("Miarchivo.txt") );

Usando constructores CharacterStreams:

in = new BufferedReader(new FileReader("Miarchivo.txt"));

Luego, a las clases a importar se suma las de ByteStreams o CharacterStream ms java.io.BufferedX donde X es el buffer que vayas a usar (leer o escribir). Ejemplo: El siguiente archivo hace una lectura y escritura de archivos y adems maneja las clases de Buffered Stream con constructores Character Streams, adems hace uso de excepciones. package ejemplo1; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; public class Invertidor 7

{ private String archivoFuente = null; private String archivoDestino = null; public void setArchivoFuente (String unNombre) { this.archivoFuente = unNombre; } public void setArchivoDestino (String unNombre) { this.archivoDestino = unNombre; } public void invertirArchivo() throws Exception { if(this.archivoFuente == null || this.archivoDestino == null) { throw new Exception ("El archivo fuente o el archivo destino es nulo"); } else { FileReader fr = new FileReader(this.archivoFuente); BufferedReader reader = new BufferedReader(fr); FileWriter fw = new FileWriter(this.archivoDestino); BufferedWriter writer = new BufferedWriter(fw); // Cuando agregamos corchetes a la definicin de String // estamos hablando de un arreglo de Strings String linea = reader.readLine(); while (linea != null) // mientras sea diferente de nulo { String[] palabras = linea.split(" "); for(int i=palabras.length - 1; i>=0; i--) { writer.write(palabras[i]); writer.write(" "); } writer.write(" "+"\r\n"); linea = reader.readLine(); } writer.flush(); fw.close(); fr.close(); } } } package ejemplo1; // @author ICORRALES public class Ejemplo1 { 8

public static void main(String[] args) throws Exception { Invertidor miInvertidor = new Invertidor(); miInvertidor.setArchivoFuente("Prueba.txt"); miInvertidor.setArchivoDestino("Respuesta.txt"); miInvertidor.invertirArchivo(); } }

Data & Object Stream

Estas clases soportan la entrada y salida binaria de los tipos de datos nativos de java (int, double, char, string... ), es decir que al momento de leer o escribir especificaremos el tipo de datos a leer escribir. Estas clases a diferencia de las anteriores, capturan el final de un archivo (EOF) por medio de la excepcin EOFException y no por medio de un indicador como -1 o null. Ests clases de construyen a partir de Buffered Stream, o sea para su uso se debe aadir a las importaciones de buffered streams las clases de Data Stream u Object Streams adems de la excepcin EOFException. Los Object Stream, adems de incluir lo de Data Stream, permite escribir o leer Objetos (Object). Prcticamente cualquier objeto puede ser escrito o ledo, solo se tiene como condicin que la clase del objeto implemente la interfaz Serializable. Un Object Stream es una gran solucin que te evita cargar mltiples tipos. Por ejemplo, si tenemos nuestra clase Persona, y queremos escribir una o varias personas a un archivo, debemos determinar unos protocolos y escribir atributo por atributo al archivo, igual al leer; si hacemos que nuestra clase Persona implemente la interfaz Serializable, podremos escribir todo el objeto Persona en el archivo para traerlo de vuelta, simplemente se hace un cast (operador para cambio de tipos de datos) sobre la clase que esperamos al objeto recibido. En trminos ms simples la serializacin es la conversin a bytes de los objetos. Esta serializacin est implcita en las clases ObjectInputStream y ObjectOutputStream. Hay muchas clases dedicadas a la manipulacin de datos desde o hacia un archivo. Esta es su jerarqua de acuerdo al lenguaje java:

Importancia de las excepciones en el uso de archivos

En el manejo de archivos la captura de errores inadecuados es importante para superar futuros problemas en el software, y de este modo se mantiene separado la parte lgica de las validaciones y as el mismo programa maneja sus potenciales errores sin que ste termine. Un programa lanza una excepcin en el punto en que primero se detecta un error. Cuando una aplicacin termina anormalmente pudo deberse a : archivos que se abrieron y no se cerraron, conexiones de redes que no se cerraron, datos que no se escribieron en disco. Al programar es importante manejar excepciones para evitar que en una aplicacin bien diseada suceda esto. Mecanismo de manejo de excepciones en JAVA: try catch throw throws finally El programador intentar (try) una operacin para anticipar errores, luego cuando una rutina encuentra un error, se lanza (throw) una excepcin. Por ltimo, una condicin de error lo capturar (catch). La instanciacios de los objetos I/O e igualados a null fuera de la sentencia try nos garantiza que cmplase o no lo que encierre dicha sentencia, el objeto seguir "existiendo", luego podemos cerrarlo de forma segura en la sentencia finally. 10

Un ventaja importante en el uso de excepciones es que sabremos donde se producen los errores en caso de haberlos.
Objeto de excepcin

Objeto de excepcin Qu hacer con los errores

Objeto de excepcin Detecta errores

Archivos de acceso secuencial

En este tipo de archivos, los registros son escritos consecutivamente cuando el archivo es creado, por lo tanto, deben ser accesados de ese modo cuando se consultan. La caracterstica ms importante de esta tcnica de organizacin de archivos es que solo permite el acceso secuencial, es decir, para accesar al registro k, se deben recorrer los k-1 registros anteriores. Los registros se insertan en el archivo en orden de llagada. Las operaciones bsicas permitidas son: escribir, aadir al final del archivo y consultar. A diferencia de los archivos de texto, en estos archivos se almacenan datos de todo tipo (char, long, float, int etc.).

Archivos de objetos
Java provee diferentes clases para el manejo de archivos, sin embargo se hace necesario la manipulacin de objetos completos. Para eso se utilizan las clase ObjectInputStream y ObjectOutputStream. Este tipo es muy til porque permite guardar toda la clase completa en lugar de estar guardando dato por dato y traerlo de vuelta. Como se usa el Stream se entiende que todo el objeto se pasa a bytes por lo que al traerlo de vuelta se hace necesario el uso de operadores cast. Escritura 1) ObjectOutputStream obj = new ObjectOutputStream(FileOutputStream(nombre")); // ObjectOutputStream permite escribir en un archivo cualquier objeto que sea serializable 2) obj.writeObject(grabar); //Escribe en el archivo el objeto grabar que es serializable 3) //Posibles excepciones a tratar IOException, ClassNotFoundException 4) obj.close();

Lectura 1) ObjectInputStream obj = new ObjectInputStream(FileInputStream(nombre")); 11

// ObjectInputStream permite leer desde un archivo cualquier objeto que haya sido serializado 2 ) clase grabar = (clase) obj.readObject(); //Lee desde el archivo un objeto y realiza un casting de la clase correspondiente. 3) //Posibles excepciones a tratar IOException, ClassNotFoundException 4) obj.close();

Archivos de acceso aleatorio

Se utilizan cuando se desea acceder al archivo como una base de datos, donde se salta de un registro a otro; cada uno en diferentes partes del archivo. Java proporciona una clase RandomAccessFile para este tipo de entrada/salida. Hay dos posibilidades para abrir un archivo de acceso aleatorio: Con el nombre del archivo: miRAFile = new RandomAccessFile( String nombre,String modo ); Con un objeto File: miRAFile = new RandomAccessFile( File archivo,String modo ); El argumento modo determina si se tiene acceso de slo lectura (r) o de lectura/escritura (r/w). Por ejemplo, se puede abrir un archivo de una base de datos para actualizacin:
RandomAccessFile miRAFile; miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" );

Acceso a la Informacin Los objetos RandomAccessFile esperan informacin de lectura/escritura de la misma manera que los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read() y write() de las clases DataInputStream y DataOutputStream.

Archivos de texto
Los archivos de texto plano son aquellos que estn compuestos nicamente por texto sin formato, solo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce tambin como archivos de texto llano o texto simple por carecer de informacin destinada a generar formatos y tipos de letra. Escritura 1) FileWriter obj = new FileWriter(nombre"); PrintWriter salida= new PrintWriter(obj); //PrintWriter permite escribir todo como texto 2) salida.println(lo que se quiera escribir"); //Escribe en el archivo como texto 3) //Posibles excepciones a tratar IOException 4) salida.close();

12

Lectura 1. FileReader obj = new FileReader(nombre"); BufferedReader salida= new BufferedReader (obj); // BufferedReader permite leer una linea entera de texto 2) String S=salida.readLine() //lectura una linea entera de texto 3) //Posibles excepciones a tratar IOException 4) salida.close();

13

Conclusin

En este trabajo he aprendido como el lenguaje de programacin Java trata y organiza el manejo de archivos, esto se realiza mediante flujos (stream) o canales, o tambin denominado secuencia. Los flujos pueden estar abiertos o cerrados, conducen los datos entre el programa y los dispositivos externos. Y que para este trabajo en especial se emplea el paquete de clases java.io de entrada y salida, con la jerarqua de clases dedicadas a la manipulacin de datos desde o hacia un archivo y los mtodos proporcionados se pueden tratar archivos secuenciales, de acceso directo y archivos de texto entre otros. Adems me queda claro que es un tema muy amplio y en cuanto a la programacin, el diferenciar el cdigo que el programador desea utilizar segn los diferentes streams y diferentes formas de manejo de archivos, es un trabajo minucioso que requiere de estudio y conocimiento sobre la forma en que se realiza la escritura y lectura de archivos. Esto de acuerdo al desarrollo que se est implementando como sockets, cliente servidor o desarrollo web. En cuanto al manejo de excepciones, puedo decir que ayuda al programador a remover el cdigo para manejo de errores de la lnea principal de ejecucin. Se agrupan los errores segn su naturaleza, de esta forma se puede lanzar o capturar un excepcin. Una de los aspectos ms potentes del lenguaje Java es la denominada serializacin, que permite convertir los objetos en un flujo de bytes, marcando tan solo la clase que describe dichos objetos como Serializable. A su vez, esta caracterstica del lenguaje nos permite reconstruir los objetos leyendo un flujo de datos que proviene de una fuente normalmente un archivo en disco o incluso de la propia Red. Para finalizar considero importante una situacin que encontr al desarrollar los ejemplos y especficamente con el uso de los objectstream. Me puse a la tarea de hacer pruebas con estas clases y al principio todo bien, me guardaba y lea correctamente. El problema lo tuve al cuando trat de leer todos los objetos que estaba agregando en sesiones de trabajo distintas. La lectura solo me mostraba el primer registro que haba incluido. Al
14

investigar me di cuenta que al parecer es una situacin natural de la clase pues esta incluye una cabecera de informacin cada vez que se cierra el archivo con el mtodo close(). As que investigu si poda haber una solucin a esto. Me encontr con una solucin factible ms no s si la mejor. Hice una clase propia extendida de la clase objectoutputstream y sobreescrib el mtodo writestreamHeader para que no agregara ninguna cabecera y as pude solucionar el problema. La otra situacin que encontr una vez hecha mi clase es que si borraba fsicamente el archivo de la ruta al crear el nuevo archivo con mi clase no creaba la primer cabecera y tena problemas la lectura. Para solucionar esto proced a validar en el botn agregar que antes de abrir el archivo validara si este ya estaba creado o no para as definir con cual clase se abra. O sea cuando no existe el archivo se usa la primera vez la clase objectoutstream y las dems veces la clase propia.

15

Bibliografa
Bobadilla, S. J & Sancho, H. (2003).JAVA A TRAVES DE EJEMPLOS. Ra-Ma, Madrid. http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/clases.htm, consultada el 22 de junio del 2012. http://es.wikipedia.org/wiki/Estructura_de_datos, consultada el 03 de julio del 2012. http://definicion.de/datos/, consultada el 03 de julio del 2012. http://www.emagister.com/curso-comunicacion-informatica-historia-computacion/concepto-160informacion-160-informatica, consultada el 03 de julio del 2012. http://lema.rae.es/drae/srv/search?id=ZUywCd3jZDXX2oYEJj5p|SZrU79n8CDXX2HlbL8FA, consultada el 03 de julio del 2012. http://jonaalvarez.blogspot.com/2009/12/entrada-y-salida-de-datos-inputoutput.html, consultada el 06 de julio del 2012. http://es.scribd.com/doc/17121620/Archivos-de-texto-y-punteros-en-java, consultada el 29 de julio del 2012. http://www.inf.utfsm.cl/~smoreno/documentos/E1_Tema.pdf, consultada el 29 de julio del 2012. http://archivosecuencial.blogspot.com/, consultada el 29 de julio del 2012.

16