Archivos

Archivos en Java
Conceptos bsicos
Estructura jerrquica de datos: Conceptos lgicos que se refieren al medio en que el usuario ve los datos y se organizan.
nombre

telefono

direccion

nombre

telefono

direccion

nombre

telefono

direccion

.......

Campo
Registro

Registro
Archivo

Otra forma de ver una estructura jerrquica de datos

Archivo: Coleccin de informacin que almacenamos en un soporte magntico para poderla manipular en cualquier momento.
Esta informacin se almacena como un conjunto de registros, conteniendo todos ellos, generalmente, los mismos campos. Cada
campo almacena un dato de un tipo predefinido o de un tipo definido por el usuario. El registro mas simple estara formado por un
carcter.
Archivo: Coleccin de informacin (datos relacionados entre s) localizada o almacenada como una unidad en alguna parte de la
memoria de la computadora, por lo general en una memoria secundaria. Esta coleccin de datos sirve para entrada y salida de datos
de datos a la computadora, y se manejan con un programa. En contraste con los arreglos y registros, el tamao de esta coleccin no
es fijo, est limitado solo por la cantidad de memoria secundaria disponible.
Un archivo es dinmico y un arreglo es esttico al igual que un registro o una cadena. Ya que hay que indicar a estos ltimos el
nmero de elementos que contendr, y en ocasiones una vez creados, ya no pueden cambiar de tamao.
Un archivo es una estructura de datos externa, a diferencia de los arreglos, cadenas, objetos, interfaces, que son internas. Ya que
su almacenamiento siempre es en una unidad de memoria secundaria (disco flexible, disco duro, memoria flash, memory stick,
cinta magntica, entre otros).
Cada archivo es referenciado por un identificador (su nombre).
Archivo de datos: coleccin de registros relacionados entre s con aspectos en comn y organizados para un propsito especifico.
Archivo de texto: Archivo con organizacin secuencial. Es una serie continua de caracteres que se pueden leer uno tras otros. Es
un archivo en que cada registro es del tipo cadena de caracteres.
Maria Eugenia Puga Nathal

Pgina 1

5/05/2015

Archivos

Base de datos: Coleccin de archivos a los que se puede acceder por un conjunto de programas y que contienen todos ellos datos
relacionados.
Tipos de archivos
Existen varias clasificaciones de los archivos, por su extensin, por su organizacin, por el tipo de acceso, por la estructura interna
de los datos, por mencionar algunas, por ejemplo:
Por la estructura de los datos
- archivos de texto
= con formato (contiene etiquetas especiales que indican algn formato del texto: tamao, fuente, estilo, color, salto de
lnea. Para su visualizacin correcta requieren de algn procesador de textos o interprete especial, por ejemplo: word, pdf,
navegador (html), works)
= sin formato (texto plano, no se agregan etiquetas de formato de datos, por lo general son caracteres del cdigo ascii, no
requieren de algn procesador de texto especializado)
- archivos de datos o binarios (requieren de un programa especial para poder visualizar su contenido)
Por su extensin
- de aplicacin: .exe
- datos: .dat
- de texto: .txt, .pdf, .doc, .rtf, .ps
- de imgenes: .jpg, .gif
- de video: .mpg, .avi
- de programas: .c, .java, .pas
- de audio: .wav, .mid, .mp3
Por su tipo de acceso
- secuencial
- aleatorio o directo
Por su tipo de organizacin
- secuencial
- aleatoria o directa
- indexada
Por su orientacin
- secuenciales (estndar)
- orientados al sistema (bajo nivel
Por su modo de apertura
- solo escritura
- solo lectura
- lectura/escritura
Acceso secuencial: exploracin de los elementos comenzando por el primero, y pasando elemento por elemento hasta llegar al
ltimo.
Acceso aleatorio o directo: permite procesar o acceder a un elemento determinado a travs de su posicin.
Organizacin secuencial: los elementos se almacenan uno tras otro, un nuevo elemento siempre se almacena hasta el final del
archivo.
Organizacin aleatoria o directa: permite seleccionar la posicin (direccin de memoria vlida) para almacenar el elemento, por
lo general se requiere de espacio de memoria homogneos para almacenar cada conjunto de datos (registro).
Organizacin indexada: permite ordenar contenidos poniendo ndices. La accin de ordenar registros mediante la utilizacin de
ndices. Las bases de datos, por ejemplo, suelen almacenar ndices de su contenido en funcin de unos parmetros previamente
definidos. La indexacin proporciona agilidad en las bsquedas, lo que se traduce en mayor rapidez a la hora de mostrar resultados.

Maria Eugenia Puga Nathal

Pgina 2

5/05/2015

Archivos

Operaciones bsicas
- crear archivo
- abrir archivo
- escribir datos en el archivo (guardar, grabar, salida de datos)
- lectura datos del archivo (leer, entrada de datos)
- cerrar archivo
Un archivo debe crearse antes de ser procesado. Un archivo secuencial puede crearse de dos maneras:
1. Crearlo directamente utilizando un procesador de texto o un editor
2. Escribir un programa que permita introducir la informacin a travs de la entrada estndar de la computadora (teclado) y la
escriba (grabe) en un archivo
Los archivos sin formato o de datos, solo pueden crearse con programas especializados (manejadores de bases de datos) o con
programas hechos por nosotros en algn lenguaje de programacin especifico que soporte el manejo de archivos de datos.
Otras operaciones
- consultar: individual (un elemento), grupo (varios elementos), general (todos los elementos)
- actualizar (altas (agregar elemento), bajas (eliminar elemento), modificar (datos de un elemento))
- clasificar (ordenar)
- reorganizar (optimizar)
- destruir (todo el archivo)
- fusionar (juntar, unir archivos)
- particionar (dividir archivos)
Datos de un archivo
- nombre
- extensin
- tipo de archivo
- fecha de creacin
- fecha de la ltima modificacin
- autor
- tamao
- estado del archivo (solo lectura, solo escritura, oculto) (o propiedades del archivo)
Para crear un archivo se requiere de la informacin siguiente
- nombre del dispositivo (lugar donde se va a crear)
- nombre del archivo
- organizacin del archivo
- tamao del bloque o registro fsico

Flujos
Un flujo en Java representa un objeto que se puede utilizar para realizar una entrada o salida de datos. Un flujo representa un canal
de informacin de donde se puede leer informacin o donde se puede escribir informacin. La lectura y salida se hace en forma
secuencial, dato por dato, uno tras otro.
Java y c# realizan operaciones en archivos a travs de flujos (secuencia de bytes o caracteres), manipulados por clases, que
conectan con el medio de almacenamiento. Para crear y abrir un archivo, se requiere utilizar una clase que defina la funcionalidad
del flujo. Los flujos determinan el sentido de la comunicacin (lectura, escritura, lectura/escritura), la posibilidad de
posicionamiento directo o no en un determinado registro y la forma de leer y/o escribir en el archivo. Cerrar el archivo implica
cerrar el flujo, ejemplo:
RandomAccessFile f=new RandomAccessFile (archivo.dat,rw); crea un archivo de acceso aleatorio de lectura/escritura.
Pueden utilizarse flujos de bytes, caracteres, cadenas o de tipos primitivos (numricos).
La clase FileInputStream permite crear un flujo para lectura secuencial de bytes desde un archivo.
La clase FileReader permite crear un flujo para la lectura secuencial de caracteres.

Maria Eugenia Puga Nathal

Pgina 3

5/05/2015

Archivos

Todas las entradas y salidas de datos estn dirigidas a travs de flujos, por lo que hay flujos de entrada (lectura) y flujos de salida
(escritura), a su vez solo son dos tipos de datos los que viajan; bytes (tipo base) y caracteres, por lo que tenemos nuevamente dos
tipos de flujos de acuerdo al tipo de datos que viajan: flujos de bytes y flujos de caracteres. Existen clases que permiten de modo
algn dar la entrada a diferentes tipos de datos primitivos e inclusive objetos, al igual que la salida, el medio de donde se obtienen
los flujos (fuente, origen) es indistinto ya que al ser transmitidos a la memoria principal son convertidos en flujos, al igual que el
medio que se tendr como destino (salida). Lo que hacen las clases es una transformacin bien sea de flujo de bytes a datos u
objetos (flujo de entrada), o de datos u objetos a un flujo de bytes (flujo de salida).
Resumen de tipos de Flujos (Stream)
- de entrada (secuencia de datos de un archivo o de algn otro dispositivo que son enviados al programa para que sean
procesados)
- de salida (secuencia de datos obtenidos como resultado de un programa y que son enviados para que se almacenen en un
archivo o enviado los datos a algn otro dispositivo)
- de bytes (unidad bsica, es una secuencia de bytes)
- de caracteres (secuencia de caracteres)
Las clases principales para el manejo de flujos tanto de entrada como de salida son:
bytes
caracteres

Entrada
InputStream
Reader

Salida
OutputStream
Writer

Estas clases heredan sus mtodos y atributos a otras clases que permitirn el manejo de los diferentes flujos tanto de datos como de
entrada/salida
Clases para el manejo de flujos de datos
Memoria

Archivo
Tuberia

bytes
ByteArrayInputStream
ByteArrayOutputStream
StringBufferedInputStream
FileInputStream
FileOutputStream
PipedInputStream
PipedOutputStream

caracteres
CharArrayReader
CharArrayWriter
StringReader
StringWriter
FileReader
FileWriter
PipedReader
PipedWriter

Clases para el manejo de flujos de datos de entrada/salida

Establecer buffer
Establecer filtro

bytes
BufferedInputStream
BufferedOutputStream
FilterInputStream
FilterOutputStream

Convertir bytes a caracteres

Concatenar
Serializar

Contar nmeros de lneas

Mirar anticipadamente
Escribir

SequenceInputStream
ObjectInputStream
ObjectOutputStream
DataInputStream
DataOutputStream
LineNumberInputStream
PushbackInputStream
PrintStream

Maria Eugenia Puga Nathal

Pgina 4

Convertir a datos primitivos

caracteres
BufferedReader
BufferedWriter
FilterReader
FilterWriter
InputStreamReader
OutputStreamReader

LineNumberReader
PushbackReader
PrintWriter

5/05/2015

Archivos

Tipos de flujos en general

Flujos de entrada de datos

Flujos de salida de datos

Flujos con bytes

InputStream
ByteArrayInputStream
FileInputStream
FilterInputStream
BufferedInputStream
DataInputStream
LineNumberInputStream
PushbackInputStream
ObjectInputStream
PipedInputStream
SequenceInputStream
StringBufferdInputStream
OutputStream
ByteArrayOutputStream
FileOutputStream
FilterOutputStream
BufferedOutputStream
DataOutputStream
PrintStream
ObjectOutputStream
PipedOutputStream

Flujos con caracteres

Reader
BufferedReader
LineNumberReader
CharArrayReader
FilterReader
PushbackReader
InputStreamReader
FileReader
PipedReader
StringReader
Writer
BufferedWriter
CharArrayWriter
FilterWriter
OutputStreamReader
FileWriter
PipedWriter
PrintWriter
StringWriter

Para el manejo de archivos existen diferentes clases, derivadas de las clases InputStream y OutputStream:
FileIntputStream Archivo secuencial para la entrada tanto de texto como de datos (modo de apertura, solo lectura)
FileOutputStream Archivo secuencial para la salida tanto de texto como de datos (modo de apertura, solo escritura)
Derivadas de las clases Reader y Writer:
FileReader Archivo secuencial para la entrada de texto (modo de apertura, solo lectura)
FileWriter Archivo secuencial para la salida de texto (modo de apertura, solo escritura)
Existen otras dos clases que permiten tambin hacer la manipulacin de los archivos:
La clase File que representa un archivo y las operaciones que se pueden hacer con el. No incluye operaciones de lectura o escritura
en archivo, solo permite hacer operaciones de manera externa con el archivo como por ejemplo: cambiarle el nombre, cambiarlo a
un estado de solo lectura, eliminarlo fsicamente, saber la ruta en la que se encuentra, saber a que directorio pertenece, saber si se
trata de un archivo o de un directorio, saber su tamao, la fecha de su ltima modificacin, entre otras operaciones.
La clase RandomAccessFile, que permite crear archivos de acceso aleatorio (o directo). Permite utilizar los archivos tanto en modo
de lectura como en modo lectura y escritura simultneamente, acceder a los elementos (registros) de forma aleatoria (o directa)
indicando la posicin en la que se quiere operar. Se usa el termino de cursor, indicador o puntero para hacer referencia a la
posicin en la que estemos ubicados dentro del archivo.
La clase StreamTokeneizer, permite leer un flujo en trozos seleccionados por marcas.

Clase File
Algunos de sus mtodos
Mtodos constructores
File f=new File(nombre_archivo);
File f=new File(ruta);
File f=new File(ruta, nombre_archivo);
File f=new File (objeto_File, nombre_archivo);
boolean x=obj_File.canRead();
boolean x=obj_File.canWriter();
boolean x=obj_File.exists();
Maria Eugenia Puga Nathal

true si es de lectura
true si es de escritura
true si el archivo existe
Pgina 5

5/05/2015

Archivos

boolean x=obj_File.isHidden();
true si el archivo est oculto
boolean x=obj_File.isDirectory(); true si es un directorio (caso Windows una carpeta)
boolean x=obj_File.delete();
true si se pudo borrar el archivo
boolean x=obj_File.mkdir();
true si se pudo crear el directorio
boolean x=obj_File.renameTo(archivo_nuevoNombre);
renombrar un archivo, regresa true si se pudo cambiar el nombre
String [] obj_File.list();
Regresa un arreglo con los nombres de los archivos y directorios que contiene un directorio
String n=obj_File.getName();
Regresa el nombre del archivo o directorio
String n=obj_File.getParent();
Regresa el nombre del directorio al que pertenece el archivo
String n=obj_File.getPath();
Regresa la ruta donde se localiza el archivo
String n=obj_File.getAbsolutePath();
Regresa la ruta absoluta (desde la raz) donde se localiza el archivo
String cad=obj_File.toString();
regresa el objeto File en cadena
long tam=obj_File.length()
Regresa el tamao del archivo, en bytes.
long fecha=obj_File.lastModified(); Regresa la fecha de la ltima modificacin del archivo, desde ------obj_File.createTemFile();
Permite crear un archivo temporal
obj_File.setReadOnly();
Cambia el estado del archivo a solo lectura
obj_File.deleteOnExit();
Solicita al sistema que elimine el archivo cuando finalice la mquina virtual. Esta solicitud slo
se aplica en una finalizacin normal de la mquina virtual, y no se puede revocar una vez
emitida.

Clase Reader
Algunos de sus mtodos
int y=obj.read()
regresa un valor entre 0 y 65535, un 1 para indicar final del flujo
int y=obj.read(char [] x, int posicionInicioArreglo, int cantidadCaracteres)
regresa el nmero de caracteres almacenados en el
arreglo x
int y= obj.read(char [] x);
regresa el nmero de caracteres almacenados en el arreglo, inicia desde la posicin 0, es
equivalente a: obj.read(char [] x, 0, x.length);
long z=obj.skip(long cantidadBytes); ignora bytes en el buffer, regresa la cantidad de bytes brincados
boolean c=obj.ready();
regresa true si el stream (flujo) est listo para ser ledo
obj.close(); cierra el flujo de entrada de datos

Clase InputStream
Algunos de sus mtodos
int y=obj.read()
regresa un valor entre 0 y 255, un 1 para indicar final del flujo
int y=obj.read(byte [] x, int posicionInicioArreglo, int cantidadDatos) regresa el nmero de datos almacenados en el arreglo x
int y= obj.read(byte [] x);
regresa el nmero de datos almacenados en el arreglo, inicia desde la posicin 0, es equivalente
a: obj.read(byte [] x, 0, x.length);
long z=obj.skip(long cantidadBytes); ignora bytes en el buffer, regresa la cantidad de bytes brincados, pero puede invocarse sin la
asignacin, es decir: obj.skip(cantidad); u obj.skip(obj.available());
boolean c=obj.ready();
regresa true si el stream (flujo) est listo para ser ledo
obj.close(); cierra el flujo de entrada de datos
int y=obj.available();
regresa la cantidad de bytes que se pueden leer (o saltar) sin bloquearse

Clase Writer
Algunos de sus mtodos
obj.write(int x);
obj.write(char [] x, int posicionInicioArreglo, int cantidadCaracteres); escribe una cantidad x de caracteres a partir de una posicin
dada en el arreglo
obj.write(char [] x); escribe (almacena) caracteres en un arreglo a partir de la posicin 0, es equivalente a: obj.write(char [] x, 0,
x.length);
obj.write(String cad);
obj.write(String cad, int posicionIncialCadena, int cantidadCaracteres);
escribe una cantidad x de caracteres a partir de una
posicin dada en la cadena
obj.flush();
obliga a vaciar el buffer enviando a los datos a su destino
obj.close();
cierra el flujo de salida de datos

Maria Eugenia Puga Nathal

Pgina 6

5/05/2015

Archivos

Clase OutputStream
Algunos de sus mtodos
obj.write(byte x);
obj.write(byte [] x, int posicionInicioArreglo, int cantidadElementos); escribe una cantidad x de datos de tipo byte a partir de una
posicin dada en el arreglo
obj.write(byte [] x); escribe (almacena) datos tipo byte en un arreglo a partir de la posicin 0, es equivalente a: obj.write(byte [] x,
0, x.length);
obj.flush();
obliga a vaciar el buffer enviando a los datos a su destino
obj.close();
cierra el flujo de salida de datos
Todos los mtodos presentados en las cuatro clases anteriores, son heredados a las clases que se derivan de estas y que fueron
presentadas en la ltima tabla, algunas de ellas vamos a estar utilizando para el manejo de archivos.
Es aconsejable que cuando se de la creacin de un objeto que se asociara con un archivo, primero se verifique la existencia de ste
a travs del mtodo exists() de la clase File, por ejemplo:

Clase FileReader
Clase que permite leer archivos de texto (secuenciales), si se quiere leer lnea por lnea, se auxilia de la clase BufferedReader.
Algunos de sus mtodos
Mtodo constructor
FileReader(String nombArchivo);
FileReader(File objFile);

Clase FileWriter
Clase que permite crear archivos de texto (secuenciales), en caso de que se quiera grabar lnea por lnea se auxilia de la clase
PrintWriter.
Algunos de sus mtodos
Mtodo constructor
FileWriter(String nombArchivo);
FileWriter(File objFile);
FileWriter(String nombArchivo, true); el valor true permite que se respeten los caracteres existente, y que los nuevos se agreguen
al final de la archivo.
FileWriter(File objFile, true);

Clase PrintWriter
Permite producir salida formateada, es decir se preocupa por la visualizacin. Si se utiliza en combinacin con la clase
FileOutputStream o FileWriter para escribir una cadena, le aade al final un salto de lnea si se utiliza el mtodo println.
Algunos de sus mtodos
Mtodos constructores
PrintWriter(destino)
PrintWriter(destino,true) el valor booleano indica que se vaca el espacio de almacenamiento intermedio con cada nueva lnea.
obj.println(cadena); visualiza una cadena y salta lnea, si el destino es un archivo, se agrega a la cadena un salto de lnea.
obj.print(); visualiza una cadena y el cursor se coloca enseguida de sta.
Si por ejemplo se declara el siguiente objeto, PrintWriter sal=new PrintWriter(System.out,true); se puede substituir la instruccin
siguiente para imprimir un dato System.out.println(cualquier cosa); por sal.println(cualquier cosa);

Clase InputStreamReader
Convierte un InputStream (flujo de bytes de entrada) en un Reader (flujo de caracteres de entrada).

Clase OutputStreamReader
Convierte un OutputStream (flujo de bytes de salida) en un Writer (flujo de caracteres de salida).

Maria Eugenia Puga Nathal

Pgina 7

5/05/2015

Archivos

Clase BufferedReader
Devuelve una lnea de texto en forma de cadena. Permite obtener (leer) una secuencia de caracteres como entrada de datos, en
lugar de caracter por carcter.
Algunos de sus mtodos
obj.readLine(); obtiene o lee una cadena de caracteres hasta encontrar un separador de lnea que puede ser un salto de lnea (\n), un
retorno de carro (\r (enter o return), o ambos ( \r \n en esta combinacin), no los incluye como parte de sta. Si se encuentra el final
del flujo (stream) antes del final de una lnea, regresa un valor null.

Clase LineNumberReader
Lleva la cuenta de los nmeros de lnea al leer el texto. Aade nmeros de lnea en la lectura de cadenas. Si se utiliza en
combinacin con la clase FileReader, permite obtener el nmero de lnea que se va leyendo en un archivo de texto. Hereda todos
los mtodos y atributos de la clase BufferedReader.
Algunos de sus mtodos
Utiliza los mismos mtodos que la clase BufferedReader
obj.setLineNumber (int n); // aade un nmero de lnea
int n=obj.getLineNumber (); // regresa el nmero de lnea ledo

Clase FileInputStream
Clase que permite abrir archivos secuenciales en modo lectura tanto de texto como de datos, para estos ltimos se auxilia de la
clase DataInputStream. Para el caso de los primeros, si se quiere leer lnea por lnea, se auxilia de la clase BufferedReader.
Algunos de sus mtodos
Mtodos constructores
FileInputStream f=new FileInputStream(archivo.extension);
FileInputStream f=new FileInputStream(objeto_File);
Hereda los mtodos de la clase InputStream

Clase FileOutputStream
Clase que permite crear archivos secuenciales tanto de texto como de datos, para estos ltimos se auxilia de la clase
DataOutputStream, para los primeros se puede auxiliar en un momento dado de la clase PrintStream, en caso de que se quiera
grabar lnea por lnea.
Algunos de sus mtodos
Mtodos constructores
FileOutputStream f=new FileOutputStream(archivo.extension);
FileOutputStream f=new FileOutputStream(objeto_File);
FileOutputStream f=new FileOutputStream(archivo.extension, true);
FileOutputStream f=new FileOutputStream(objeto_File, true);
El valor true significa que cuando se vuelva a ejecutar el programa que contiene esta clase, los datos del archivo permanecern en
ste, y que los nuevos se anexarn al final. Es decir los datos se conservarn, a diferencia de cuando no se pode este valor
booleano, cada vez que se ejecute el programa, los datos del archivo se borraran, y los nuevos se grabaran desde la primera
posicin.
Hereda los mtodos de la clase OutputStream

Clase PrintStream
Permite producir salida formateada, es decir se preocupa por la visualizacin. Si se utiliza en combinacin con la clase
FileOutputStream para escribir una cadena, le aade al final un salto de lnea si se utiliza el mtodo println.
Maria Eugenia Puga Nathal

Pgina 8

5/05/2015

Archivos

Algunos de sus mtodos

Mtodos constructores
PrintStream(destino);
PrintStream(destino, true); el valor booleano indica que se vaca el espacio de almacenamiento intermedio con cada nueva lnea.
obj.println(cadena); visualiza una cadena y salta lnea, si el destino es un archivo, se agrega a la cadena un salto de lnea.
obj.print(); visualiza una cadena y el cursor se coloca enseguida de sta.
Si por ejemplo se declara el siguiente objeto, PrintStream sal=System.out; se puede substituir la instruccin siguiente para
imprimir un dato System.out.println(cualquier cosa); por sal.println(cualquier cosa);

Clase DataInputStream
Esta clase permite transformar un flujo de bytes a un tipo de dato primitivo. Es muy utilizada en combinacin con la clase
FileInputStream para la creacin de un archivo de lectura de datos.
Algunos de sus mtodos
Mtodo constructor
DataInputStream ent=new DataInputStream(fuente);
La fuente para el caso que nos interesa ser la clase FileInputStream, por lo que el objeto ent lo podemos crear de dos maneras:
Primera
FileInputStream archivo=new FileInputStream(archivo.dat);
DataInputStream ent=new DataInputStream(archivo);
Segunda
DataInputStream ent=new DataInputStream(new FileInputStream(archivo.dat));
byte b=ent.readByte(); // lee un valor de tipo byte
byte b=ent.readUnsignedByte(); // lee un valor de tipo byte sin signo
short s=ent.readShort(); // lee un valor de tipo short
short s=ent.readUnsignedShort(); // lee un valor de tipo short sin signo
int i=ent.readInt();// lee un valor de tipo int
long l=ent.readLong();// lee un valor de tipo long
float f=ent.readFloat();// lee un valor de tipo float
double d=ent.readDouble();// lee un valor de tipo double
char car=ent.readChar();// lee un valor de tipo char
String cad=ent.readUTF();// lee un valor de tipo String en formato UTF
String cad=ent.readLine();// lee un valor de tipo String, obtiene toda la lnea de texto incluyendo el enter y salto de lnea
boolean bol=ent.readBoolean();// lee un valor de tipo boolean
ent.readFully();
ent.skipBytes(numeroBytes); //brinca un numero x de bytes

Clase DataOutputStream
Esta clase permite transformar un tipo de dato primitivo a un flujo de bytes. Es muy utilizada en combinacin con la clase
FileOutputStream para la creacin de un archivo de escritura de datos.
Algunos de sus mtodos
Mtodo constructor
DataOutputStream sal=new DataOutputStream(fuente);
La fuente para el caso que nos interesa ser la clase FileOutputStream, por lo que el objeto sal lo podemos crear de dos maneras:
Primera
FileOutputStream archivo=new FileOutputStream(archivo.dat);
DataOutputStream sal=new DataOutputStream(archivo);
Segunda
DataOutputStream sal=new DataOutputStream(new FileOutputStream(archivo.dat));

Maria Eugenia Puga Nathal

Pgina 9

5/05/2015

Archivos

sal.write(byte n); // escribe un valor de tipo byte

sal.write(byte [] n); // escribe un arreglo de datos de tipo byte
sal.writeByte(byte b); // escribe un valor de tipo byte
sal.writeShort(short s); // escribe un valor de tipo short
sal.writeInt(int i);// escribe un valor de tipo int
sal.writeLong(long l);// escribe un valor de tipo long
sal.writeFloat(float f);// escribe un valor de tipo float
sal.writeDouble(double d);// escribe un valor de tipo double
sal.writeChar(char car);// escribe un valor de tipo char
sal.writeChars(String cad);// escribe un valor de tipo String como un arreglo de caracteres
sal.writeUTF(String cad);// escribe un valor de tipo String en formato UTF
sal.writeBoolean(boolean bol);// escribe un valor de tipo boolean
Para el caso del formato UTF, cuando se tenga que contabilizar la cantidad de bytes necesario para el almacenamiento de la cadena
en el archivo (caso archivos aleatorios) agregar dos bytes mas, que utiliza la clase para guardar el tamao de la cadena.

Serializacin
La serializacin de objetos en Java permite tomar cualquier objeto que implemente la interfaz Serializable y convertirlo en una
secuencia (flujo) de bits que puede ser posteriormente restaurada para regenerar el objeto original. La serializacin de un objeto
permite darle mas persistencia al objeto (la vida del objeto se alargara), ya que ste seguir existiendo aun cuando termine la
ejecucin del programa, solo que ahora lo har en memoria secundaria y no en la memoria principal y cuando sea nuevamente
ledo cobrar ese efecto de persistencia.
Cabe mencionar que la interfaz Serializable es una simple bandera, y no contiene mtodos, es un indicador de que un objeto puede
o no serializarse, es decir, convertirse o no a un flujo de bits.
Para serializar objetos es necesario hacer uso de la clase ObjetcOutputStream a travs del mtodo writeObject(objetoSerializable),
y para invertir este proceso, es decir obtener el objeto nuevamente en su forma original (deserializar) es necesario utilizar la clase
ObjectInputStream a travs del mtodo readObject(), pero en este caso se regresa una referencia a un objeto Object por lo que es
necesario hacer una conversin explcita al momento de la lectura al tipo de objeto en particular. Por ejemplo:
Obj.writeObject(objeto cadena); // serializa
String cad=(String) obj.readObject(); // deserializa
Cuando se est controlando la serializacin, puede ocurrir que haya un subobjeto (o atributo) en particular para el que no se desee
que se produzca un salvado y recuperacin automticos por parte del mecanismo de serializacin de Java. Como por ejemplo una
contrasea. Una forma de cmo evitar que partes sensibles de un objeto sean serializables es anteponer el modificador de tipo
transient. Cabe mencionar que cuando se tienen datos u objetos con el modificador de tipo static, tampoco sern serializados.

Clase ObjectInputStream
Permite obtener una secuencia de bytes (o de bits) y convertirla a un objeto en particular. Lee un objeto (convertido en una
secuencia de bytes (o de bits)) de alguna fuente de entrada en particular (red, archivo).
Algunos de sus mtodos
Mtodo constructor
ObjectInputStream objeto=new ObjectInputStream(fuente de entrada);
ClaseObjetoSerializable obj=( ClaseObjetoSerializable) objeto.readObject(); // transforma el objeto en una secuencia de bits y los
// enva a su destino
Para poder hacer la lectura de cualquier tipo de dato primitivo, hace uso de los mismos mtodos que la clase DataInputStream.

Clase ObjectOutputStream
Permite convertir un objeto en particular (serializable) a una secuencia de bytes (o de bits) y enviarla a un destino especfico (red,
archivo).
Algunos de sus mtodos
Mtodo constructor
Maria Eugenia Puga Nathal

Pgina 10

5/05/2015

Archivos

ObjectOutputStream objeto=new ObjectOutputStream(fuente de salida);

objeto.writeObject(objetoSerializable); // transforma el objeto en una secuencia de bits y los enva a su destino
Para poder hacer la escritura de cualquier tipo de dato primitivo, hace uso de los mismos mtodos que la clase DataOutputStream.

Clase RandomAccessFile
Permite crear archivos con una organizacin aleatorio o directa y su acceso puede ser de manera secuencial o directa. Ofrece dos
modos de apertura: solo lectura, o lectura/escritura. Si se requiere, en un momento dado pueden crearse tambin archivos de una
organizacin secuencial. Por lo general va orientado al manejo de archivos de datos.
Algunos de sus mtodos
Mtodos constructores
RandomAccessFile f=new RandomAccessFile(nombreArchivo.ext, modoApertura);
RandomAccessFile f=new RandomAccessFile(objetoFile, modoApertura);
Modo apertura: r solo lectura
rw lectura/escritura
long x=f.getFilePointer(); regresa la posicin actual del puntero del archivo, que es desde el inicio hasta la posicin actual
f.seek(posicion);
desplaza el puntero n bytes tomando como origen el del archivo (byte 0)
long x=.f.length();
regresa el tamao actual del archivo, nmero de bytes que ocupa o longitud que tiene
f.setLength(n);
permite establecer de antemano el tamao del archivo, n es el nmero de bytes que se requiere que se
reserve para los datos del archivo, cuando ya sabemos de antemano la cantidad mxima de elementos que contendr nuestra
aplicacin, hacemos uso de este mtodo, por ejemplo, si se va a utilizar el archivo para guardar los datos de algn control de
reservacin de habitaciones de un hotel, de un teatro, de un restauran, asientos de un avin, reservar una computadora en algn
cyber o en el laboratorio de cmputo, por mencionar algunas aplicaciones
f.seek(f.length());
nos coloca al final del archivo
f.seek(i*tamao);
nos va colocando en cada bloque de memoria definido para un registro de datos, el tamao nosotros lo
definimos a travs de la sumatoria de la cantidad de bytes que va a ser necesario para almacenar cada dato que compondr nuestro
registro (objeto), i es una variable en este caso de tipo contador, que se ira incrementando en 1, para accesar al primer elemento del
archivo, i = 0.
Para obtener el numero de elementos (registros) se hace la operacin siguiente:
Nregs= (int) Math.ceil ( (double)f.length() / (double)tamao);
Para el manejo de los datos, es decir para la escritura o lectura, tiene los mismos mtodos que las clases DataInputStream y
DataOutputStream.

Ejemplos
Clase File
import java.util.*; // se necesita para la clase Date, que convierte un valor numrico a un formato de fecha en este caso
import java.io.*;
class EjemFile2
{public static void main (String arg[])
{String directorio;
if (arg.length>0)
{directorio=arg[0];} // el nombre del directorio se introduce al momento de ejecutar el programa
else {directorio=".";} // directorio actual
File actual=new File(directorio);// creo objeto que se enlaza con el directorio
if (actual.exists()) // se verifica la existencia del archivo o del directorio
{if (actual.isFile()) // se verifica si es archivo, si se regresa true si lo es, en caso contrario se trata de un directorio
{System.out.println("Es un archivo");}
else
{ System.out.println("El directorio es:");
try {System.out.println(actual.getCanonicalPath());}
Maria Eugenia Puga Nathal

Pgina 11

5/05/2015

Archivos

catch(IOException e){}
System.out.println("Su contenido es:");
File archivos[]=actual.listFiles(); // obtienen el contenido del directorio
for (int i=0;i<archivos.length && archivos!=null;i++) // presenta el contenido del directorio
{System.out.print(archivos[i].getName());
if (archivos[i].isFile())
{System.out.print("\t"+archivos[i].length());
System.out.print("\t"+(new Date(archivos[i].lastModified())));
}
System.out.println();
}
}
}
else {System.out.println("no existe el directorio o el archivo");}
}
}

Archivos secuenciales
Archivos de texto
LECTURA

Clase FileReader
Ejemplo de la lectura de un archivo de texto, caracter por caracter:
import java.io.*;
class lectura_archivo_car
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String archivo=arg[0];
String cad="";
int car=0;
// se crea un objeto de la clase FileReader, lo que significa que el archivo
//esta abierto en modo lectura
FileReader ent=new FileReader(archivo);
try { car=ent.read(); // se lee el primer caracter del archivo
while(car!=-1) // se verifica que no sea fin de archivo
{cad=cad+(char)car; //opcional, formo una cadena con los caracteres ledos del archivo
System.out.print((char)car); // se imprime el caracter ledo
car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de ste
}
System.out.println("\n\n\nSe imprime la cadena formada por los caracteres ledos del");
System.out.println("archivo lo anterior se imprimi caracter por caracter.");
System.out.println(cad); //opcional, imprimo la cadena formada con los caracteres leidos del archivo
ent.close(); // Se cierra el archivo
}
catch (IOException e)
{// por si se genera algn problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Ejemplo de la lectura de un archivo de texto donde lectura de ste es cadena (lnea) por cadena(lnea):
import java.io.*;
class lectura_archivo
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
Maria Eugenia Puga Nathal

Pgina 12

5/05/2015

Archivos

// el programa, es capturado por el parmetro arg del mtodo main

String archivo=arg[0];
String cad=null;
// creo un objeto de la clase BufferedReader para obtener la cadena
// completa del archivo, lnea por lnea, es decir al momento de encontrar
// los carcateres \r\n (enter+salto de lnea) se forma una primera cadena
// (lnea de texto), se enva como parmetro un objeto annimo de la clase
// FileReader, la cual es utilizada como fuente de donde se obtendrn las
// cadenas, al momento de crear este objeto annimo, se est dando la
// apertura al archivo en modo de lectura
BufferedReader ent=new BufferedReader(new FileReader(archivo));
try { cad=ent.readLine(); // se lee la primera cadena (o lnea de texto) del archivo
while(cad!=null) // se verifica que no sea fin de archivo
{System.out.println(cad); // se imprime la cadena leda desde del archivo
cad=ent.readLine(); // se lee la siguiente lnea del archivo
}
ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (EOFException e)
{// por si se genera algn problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Si la aplicacin que se est desarrollando requiere la lectura de un archivo de texto, pero que a su vez vaya listando el nmero de
lnea, se puede utilizar la clase LineNumberReader, la cual es una extensin de la clase BufferedReader, es decir hereda los
mtodos y atributos de la clase, agregando otros como getLineNumber(), el cual permite obtener el nmero de una lnea,
setLineNumber(int NumeroLinea).
Ejemplo de la lectura de un archivo de texto lnea por lnea, adems de enumerar cada lnea leda:
import java.io.*;
class lectura_archivo_linea
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String archivo=arg[0];
String cad=null;
int nl=0;
// creo un objeto de la clase LineNumberReader para obtener la cadena (lnea) y nmero de lnea
// completa del archivo, lnea por lnea, se enva como parmetro un objeto
// annimo de la clase FileReader, la cual es utilizada como fuente de donde
// se obtendrn las cadenas, al momento de crear este objeto annimo, se est dando la
// apertura al archivo en modo de lectura
LineNumberReader ent=new LineNumberReader(new FileReader(archivo));
try { cad=ent.readLine(); // se lee el primera lnea de texto del archivo
while(cad!=null) // se verifica fin de archivo
{nl=ent.getLineNumber(); // se obtiene el numero de lnea
System.out.println(nl+" "+cad); //se imprime numero de lnea y contenido de la lnea
cad=ent.readLine(); // se lee la siguiente lnea de texto
}
ent.close();// se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (IOException e)
{// por si se genera algn problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Maria Eugenia Puga Nathal

Pgina 13

5/05/2015

Archivos

Clase FileInputStream
Ejemplo de la lectura de un archivo de texto, caracter por caracter:
import java.io.*;
class lectura_archivo_car_2
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String archivo=arg[0];
String cad="";
int car=0;
// se crea un objeto de la clase FileReader, lo que significa que el archivo
//esta abierto en modo lectura
FileInputStream ent=new FileInputStream(archivo);
try { car=ent.read(); // se lee el primer caracter del archivo
while(car!=-1) // se verifica que no sea fin de archivo
{cad=cad+(char)car; //opcional, formo una cadena con los caracteres ledos del archivo
System.out.print((char)car); // se imprime el caracter ledo
car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de ste
}
System.out.println("\n\n\nSe imprime la cadena formada por los caracteres ledos del");
System.out.println("archivo lo anterior se imprimi caracter por caracter.");
System.out.println(cad); //opcional, imprimo la cadena formada con los caracteres ledos del archivo
ent.close(); // Se cierra el archivo
}
catch (IOException e)
{// por si se genera algn problema en la lectura del archivo
// por el momento la dejo en blanco
}
}
}
Ejemplo de la lectura de un archivo de texto lnea por lnea:
import java.io.*;
class lectura_archivo_2
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String archivo=arg[0];
String cad=null;
// creo un objeto de la clase BufferedReader para obtener la cadena
// completa del archivo, lnea por lnea, es decir al momento de encontrar
// los carcateres \r\n (enter+salto de lnea) se forma una primera cadena
// (lnea de texto), se enva como parmetro un objeto annimo de la clase
// FileInputStream para convertir el flujo de bytes a caracteres, a su vez,
// ste tendr como parmetro un objeto annimo de la clase FileInputStream,
// la cual es utilizada como fuente de donde se obtendrn las cadenas, al
// momento de crear este objeto annimo, se est dando la apertura al archivo en modo de lectura
BufferedReader ent=new BufferedReader(new InputStreamReader(new FileInputStream(archivo)));
try { cad=ent.readLine(); // se lee la primera cadena (o lnea de texto) del archivo
while(cad!=null) // se verifica que no sea fin de archivo
{System.out.println(cad); // se imprime la cadena leda desde del archivo
cad=ent.readLine(); // se lee la siguiente lnea del archivo
}
ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (EOFException e)
Maria Eugenia Puga Nathal

Pgina 14

5/05/2015

Archivos

{// por si se genera algn problema en la lectura del archivo

// por el momento la dejo en blanco
}
}
}

Clase RandomAccessFile
Ejemplo de la lectura de un archivo de texto cadena por cadena (para que funcione de manera correcta, el archivo se debi de
haber creado con la clase RandomAccessFile):
import java.io.*;
class aleatorio_texto_lect
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String archivo=arg[0];
String cad="";
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile(archivo,"r");
try {// se genera un ciclo infinito donde se estarn leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepcin EOFException
while(true)
{cad=arch.readUTF(); // se lee la cadena en formato UTF
System.out.println(cad); // se imprime la cadena leda
}
}
catch(EOFException fin)
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close();
}
}
}
ESCRITURA

Clase FileWriter
Ejemplo de la generacin de un archivo de texto, caracter por caracter
import java.io.*;
class escritura_archivo_car
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String arch=arg[0];
// se crea un objeto de la clase FileWriter, lo que significa que el archivo
// est abierto en modo escritura, el valor de true indica, que tantas veces ejecute
// el programa podr agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos ste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
FileWriter escribe=new FileWriter(arch,true);
char car=' ';
try {System.out.println("dar * para terminar");
while(car!='*')
{ car=(char)System.in.read();
if (car!='*')
{escribe.write(car);} // se escribe o graba el caracter en el archivo
System.in.skip(System.in.available());
}
Maria Eugenia Puga Nathal

Pgina 15

5/05/2015

Archivos

escribe.close(); // se cierra el archivo

}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepcin
}
}
Ejemplo de la generacin de un archivo de texto, cadena por cadena
import java.io.*;
class escritura_archivo_cad
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String arch=arg[0];
BufferedReader ent=new BufferedReader(new InputStreamReader(System.in));
// se crea un objeto de la clase FileWriter, lo que significa que el archivo
// est abierto en modo escritura, el valor de true indica, que tantas veces ejecute
// el programa podr agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos ste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
FileWriter escribe=new FileWriter(arch,true);
String cad="";
try {System.out.println("dar fin para terminar");
while(cad.equalsIgnoreCase("fin")!=true)
{ cad=ent.readLine();
if (cad.equalsIgnoreCase("fin")!=true)
{escribe.write(cad);} // se escribe o graba la cadena en el archivo
}
escribe.close(); // se cierra el archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepcin
}
}
Ejemplo de la generacin de un archivo de texto, lnea por lnea
import java.io.*;
class escritura_archivo
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String arch=arg[0];
BufferedReader ent=new BufferedReader(new InputStreamReader(System.in));
// se crea un objeto de la clase PrintWriter para que me permita grabar
// una cadena e incorpore el salto de lnea, esto a travs del mtodo println,
// cuando se crea el objeto se manda como parmetro el objeto annimo de la clase
// FileWriter, el cual se tomar como destino, adems con la creacin de este objeto
// annimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute
// el programa podr agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos ste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
PrintWriter escribe=new PrintWriter(new FileWriter(arch,true));
String cad="";
try {System.out.println("dar fin para terminar");
while(cad.equalsIgnoreCase("fin")!=true)
{ cad=ent.readLine();
if (cad.equalsIgnoreCase("fin")!=true)
Maria Eugenia Puga Nathal

Pgina 16

5/05/2015

Archivos

{escribe.println(cad);} // se escribe o graba la lnea de texto (cadena) en el archivo

}
escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, sta se realiza se produzca o no una excepcin
}
}

Clase FileOutputStream
Ejemplo de la generacin de un archivo de texto, caracter por caracter
import java.io.*;
class escritura_archivo_car_2
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parametro arg del metodo main
String arch=arg[0];
// se crea un objeto de la clase FileOutputStream, lo que significa que el archivo
// est abierto en modo escritura, el valor de true indica, que tantas veces ejecute
// el programa podr agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos ste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
FileOutputStream escribe=new FileOutputStream(arch,true);
char car=' ';
try {System.out.println("dar * para terminar");
while(car!='*')
{ car=(char)System.in.read();
if (car!='*')
{escribe.write((byte)car);} // se escribe o graba el caracter en el archivo, con un valor explixito de tipo byte
System.in.skip(System.in.available());
}
escribe.close(); // se cierra el archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepcin
}
}
Ejemplo de la generacin de un archivo de texto, lnea por lnea
import java.io.*;
class escritura_archivo_2
{public static void main(String arg[]) throws IOException
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parmetro arg del mtodo main
String arch=arg[0];
BufferedReader ent=new BufferedReader(new InputStreamReader(System.in));
// se crea un objeto de la clase PrintStream para que me permita grabar
// una cadena e incorpore el salto de lnea, esto a travs del mtodo println,
// cuando se crea el objeto se manda como parmetro el objeto annimo de la clase
// FileOutputStream, el cual se tomar como destino, adems con la creacin de este objeto
// annimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute
// el programa podr agregar datos al mismo archivo, si en un momento dado, quiero
// que cada vez que ejecute el programa y sea el mismo archivo, tenga nuevos datos ste,
// se elimina el valor booleano y la coma, dejando solo el nombre (o variable) del archivo
PrintStream escribe=new PrintStream(new FileOutputStream(arch,true));
Maria Eugenia Puga Nathal

Pgina 17

5/05/2015

Archivos

String cad="";
try {System.out.println("dar fin para terminar");
while(cad.equalsIgnoreCase("fin")!=true)
{ cad=ent.readLine();
if (cad.equalsIgnoreCase("fin")!=true)
{escribe.println(cad);} // se escribe o graba la lnea de texto (cadena) en el archivo
}
escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo
}
catch(IOException e)
{}
finally {escribe.close();} // es otra parte del try, esta se realiza se produzca o no una excepcin
}
}

Clase RandomAccessFile
Ejemplo de la generacin de una archivo de texto, cadena por cadena:
import java.io.*;
class aleatorio_texto_escr
{public static void main(String arg[]) throws IOException
{ // introduzco el nombre del archivo desde el teclado al momento de ejecutar
// el programa, es capturado por el parametro arg del metodo main
String archivo=arg[0];
long tam;
String cad;
// se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo
// est abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en
// el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura,
// si en un momento dado se necesitar modificar algn dato del archivo, bajo este
// modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura
// y despus en modo escritura para hacer ste cambio.
RandomAccessFile arch=new RandomAccessFile(archivo,"rw");
tam=arch.length(); // obtiene el tamao del archivo, en bytes
arch.seek(tam); // coloca el puntero del archivo en la ltima posicin, esto es por
// si ya existen datos en el archivo no se pierdan, y que los nuevos
// datos queden hasta el final de ste, en caso contrario los encimara
for (int i=1;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parmetro arg del mtodo main
cad=arg[i];
// se graban los datos en el archivo
arch.writeUTF(cad); // una cadena, en formato UTF
}
arch.close();
}
}

Archivo de datos
LECTURA

Clase FileInputStream
Ejemplo de un archivo de lectura de datos:
import java.io.*;
class lectura_datos_1
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
Maria Eugenia Puga Nathal

Pgina 18

5/05/2015

Archivos

double oper=0;
char car=' ';
// se crea un objeto de la clase DataInputStream con la finalidad de que me
// permita leer del archivo datos de diferentes tipos, toma como parmetro
// el objeto annimo de la clase FileInputStream, que es la fuente de donde
// se tomarn los datos, este objeto indica la apertura del archivo en modo lectura.
DataInputStream arch=new DataInputStream(new FileInputStream("datos1.dat"));
try {// se genera un ciclo infinito donde se estarn leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepcin EOFException
while(true)
{// se leen los datos del archivo
cad=arch.readUTF(); // se lee una cadena en formato UTF
len=arch.readInt(); // se lee un valor tipo int
oper=arch.readDouble(); // se lee un valor tipo double
car=arch.readChar(); // se lee un caracter
// se imprimen los datos que se leyeron del archivo
System.out.println(cad+" "+len+" "+oper+" "+car);
}
}
catch(EOFException fin) // capta excepcin fin de archivo
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close(); // cierra el flujo que est relacionado con el archivo
}
}
}

Clase RandomAccessFile
Ejemplo de un archivo de lectura de datos:
import java.io.*;
class lectura_datos_2
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
double oper=0;
char car=' ';
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile("datos2.dat","r");
try {// se genera un ciclo infinito donde se estarn leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepcin EOFException
while(true)
{ // se leen los datos del archivo
cad=arch.readUTF(); // se lee una cadena en formato UTF
len=arch.readInt(); // se lee un valor de tipo int
oper=arch.readDouble(); // se lee un valor de tipo double
car=arch.readChar(); // se lee un caracter
// se imprimen los datos ledos del archivo
System.out.println(cad+" "+len+" "+oper+" "+car);
}
}
catch(EOFException fin)
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close(); // se cierra el flujo de entrada del archivo
}
}
}
Maria Eugenia Puga Nathal

Pgina 19

5/05/2015

Archivos

ESCRITURA

Clase FileOutputStream
Ejemplo de un archivo de escritura de datos:
import java.io.*;
class escritura_datos_1
{public static void main(String arg[]) throws IOException
{ String archivo="datos1.dat";
long tam;
String cad;
int len;
double oper;
char car;
// se crea un objeto de la clase DataOutputStream con la finalidad de que me
// permita escribir en el archivo datos de diferentes tipos, toma como parmetro
// el objeto annimo de la clase FileOutputStream, que es la destino en donde
// se escribirn los datos, este objeto indica la apertura del archivo en modo
//escritura, el valor booleano indica que cada vez que se ejecute el programa,
// los nuevos datos se agregaran al final del archivo, si se quita este valor,
// indica que cada vez que se ejecute el programa se borraran los datos y se
// escribir de nueva cuenta en el archivo.
DataOutputStream arch=new DataOutputStream(new FileOutputStream(archivo,true));
for (int i=0;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parmetro arg del mtodo main
cad=arg[i];
len=cad.length();
oper=Math.random()*len;
car=cad.charAt(0);
// se graban los datos en el archivo
arch.writeUTF(cad); // una cadena, en formato UTF
arch.writeInt(len); // un valor de tipo int
arch.writeDouble(oper); // un valor de tipo double
arch.writeChar(car); // un caracter
}
arch.close(); // se cierra el flujo que depende del archivo
}
}

Clase RandomAccessFile
Ejemplo de un archivo de escritura de datos:
import java.io.*;
class escritura_datos_2
{public static void main(String arg[]) throws IOException
{ String archivo="datos2.dat";
long tam;
String cad;
int len;
double oper;
char car;
// se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo
// est abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en
// el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura,
// si en un momento dado se necesitar modificar algn dato del archivo, bajo este
// modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura
// y despues en modo escritura para hacer ste cambio.
Maria Eugenia Puga Nathal

Pgina 20

5/05/2015

Archivos

RandomAccessFile arch=new RandomAccessFile(archivo,"rw");

tam=arch.length(); // obtiene el tamao del archivo, en bytes
arch.seek(tam); // coloca el puntero del archivo en la ltima posicin, esto es por
// si ya existen datos en el archivo no se pierdan, y que los nuevos
// datos queden hasta el final de ste, en caso contrario los encimara
for (int i=0;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parmetro arg del mtodo main
cad=arg[i];
len=cad.length();
oper=Math.random()*len;
car=cad.charAt(0);
// se graban los datos en el archivo
arch.writeUTF(cad); // una cadena, en formato UTF
arch.writeInt(len); // un valor de tipo int
arch.writeDouble(oper); // un valor de tipo double
arch.writeChar(car); // un caracter
}
arch.close(); // se cierra el flujo de salida del archivo
}
}

Almacenar Objetos en un archivo

Clase del objeto que implementa la interface Serializable
// datos que conformaran el objeto, debe de implementar la interface Serializable
// la cual es una interface vacia, es decir no contiene mtodos, pero es un requisito
// para que un objeto se pueda serializar (convertir a un flujo de bytes (o bits) o deserializar
// (convertir un flujo de bytes (o bits) a un objeto en particular), los atributos y mtodos que
// tengan los modificadores de tipo static o transient no sern serializados, el resto
// del objeto si
import java.io.*;
public class Datos implements Serializable
{String cad;
int len;
double oper;
char car;
}

Clase ObjectInputStream (entrada(lectura)

import java.io.*;
class fileobjetos1_1
{public static void main(String arg[]) throws IOException
{// se crea un objeto de la clase ObjectInputStream con la finalidad de que me
// permita leer del archivo datos un objeto completo en lugar de cada uno de sus atributos,
// adems de permitir leer tipos de datos primitivos (los mismos que DataInputStream), toma
// como parmetro para este caso, el objeto annimo de la clase FileInputStream, que es la
// fuente de donde se tomarn los datos, este objeto indica la apertura del archivo en modo lectura.
ObjectInputStream objeto=new ObjectInputStream(new FileInputStream("objetos.dat"));
Datos datos=new Datos(); // se crea un objeto de la clase datos
try
{while(true) // ciclo para la lectura de los datos del archivo
{ // se lee el objeto del archivo, y el flujo obtenido se convierte a travs de
// un cast (conversin explcita) al tipo de objeto en particular a obtener, es decir se
// deserializa (conversin de un flujo de bytes (o bits) a un objeto en particular)
datos=(Datos) objeto.readObject();
Maria Eugenia Puga Nathal

Pgina 21

5/05/2015

Archivos

// se imprimien los datos del objeto

System.out.println(datos.cad+" "+datos.len+" "+datos.oper+" "+datos.car);
}
}
catch(EOFException fin) // se captura la excepcin de fin de archivo
{System.out.println(fin.getMessage()+" fin de archivo");
objeto.close(); // se cierra flujo de entrada del archivo
}
catch(Exception e) // captura algn problema (excepcin) con el objeto
{System.out.println("error al leer el objeto");}
}
}

Clase ObjectOutputStream (salida/escritura)

import java.io.*;
class fileobjetos1
{public static void main(String arg[]) throws IOException
{ // se crea un objeto de la clase ObjectOutputStream con la finalidad de que me
// permita escribir en el archivo un objeto completo en lugar de ir grabando
// atributo por atributo, tambin me permite escribir (grabar) datos de diferentes
// tipos como lo hace la clase DataOutputStream, toma como par metro el objeto
// annimo de la clase FileOutputStream, que es la destino en donde se escribir n
// los datos, este objeto indica la apertura del archivo en modo escritura, el valor
// booleano indica que cada vez que se ejecute el programa, los nuevos datos se agregaran
// al final del archivo, si se quita este valor, indica que cada vez que se ejecute el
// programa se borraran los datos y se escribir de nueva cuenta en el archivo.
ObjectOutputStream objeto=new ObjectOutputStream(new FileOutputStream("objetos.dat",true));
Datos datos=new Datos(); // se crea un objeto de la clase Datos
for (int i=0;i<arg.length;i++) // de acuerdo a las cadenas que se proporcionaron al ejecutar
// el programa, sern los objetos a almacenar en el archivo
{datos=new Datos();
datos.cad=arg[i];
datos.len=datos.cad.length();
datos.oper=Math.random()*datos.len;
datos.car=datos.cad.charAt(0);
// se graba (escribe) el objeto en el archivo, pero para esto lo serializar, es decir lo
// convierte en un flujo de bytes (o bits)
objeto.writeObject(datos);
}
objeto.close(); // se cierra el flujo de salida del archivo
}
}

Archivos aleatorios
Clase RandomAccessFile
ESCRITURA
import java.io.*;
class escritura_aleatorio
{public static void main(String arg[]) throws IOException
{ String cad;
int len;
double oper;
char car;
StringBuffer cadmod;
int tam=22+4+8+2; // se calcula el tamao del registro de datos
Maria Eugenia Puga Nathal

Pgina 22

5/05/2015

Archivos

// se crea un objeto de la clase RandomAccessFile, lo que significa que el archivo

// est abierto en modo lectura/escritura (rw), esto permite tanto escribir datos en
// el archivo como leerlo, para este caso solo lo voy a utilizar para la escritura,
// si en un momento dado se necesitar modificar algn dato del archivo, bajo este
// modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura
// y despues en modo escritura para hacer ste cambio.
RandomAccessFile arch=new RandomAccessFile("datos3.dat","rw");
// se calcula el total de los elementos almacenados en el archivo con la finalidad de
// colocarnos en la siguiente posicin vlida para almacenar el nuevo elemento del archivo,
// una posicin mas adelante de la ltima
long total=arch.length()/tam;
if (total!=0)
{total+=1;}
System.out.println("tamao "+tam+" total "+total);
for (int i=0;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parmetro arg del mtodo main
cad=arg[i];
// debido a que un archivo de acceso aleatorio requiere de registros de tamao uniforme,
// obligo a que la cadena tenga una longitud fija, en este caso de 10 caracteres, para esto
// me auxilio de la clase StringBuffer y su mtodo setLength() que permite fijar una
// longitud a la cadena, para esto creo un objeto de la clase StringBuffer pasando como
// parmetro la cadena a modificar, se establece el nuevo tamao, una vez que se tiene esto,
// se hace una conversin a travs del mtodo toString() de un objeto StringBuffer a un objeto String
cadmod=new StringBuffer(cad); // se crea el objeto
cadmod.setLength(10); // se establece la longitud
cad=cadmod.toString(); // se convierte a objeto String
len=cad.length();
oper=Math.random()*len;
car=cad.charAt(0);
arch.seek(tam*(i+total)); // posicin donde se grabara el nuevo registro de datos
// se graban los datos
arch.writeUTF(cad); // una cadena en formato UTF
arch.writeInt(len); // un valor de tipo int
arch.writeDouble(oper); // un valor de tipo double
arch.writeChar(car); // un caracter
}
arch.close(); // se cierra el flujo de salida del archivo
}
}
LECTURA
Ejemplo 1
import java.io.*;
class lectura_aleatorio_1
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
double oper=0;
char car=' ';
int tam=22+4+8+2;// se calcula el tamao del registro de datos
int cont=0;
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile("datos3.dat","r");
try {// se genera un ciclo infinito donde se estarn leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepcin EOFException
while(true)
Maria Eugenia Puga Nathal

Pgina 23

5/05/2015

Archivos

{arch.seek(tam*cont); // se posiciona el puntero en el byte donde se

// localiza el registro de los datos que se comenzarn a leer
// se leen los datos del archivo, en este ejemplo los leo e imprimo directamente,
// pero pueden primero asignarse los valores a las varianles que estn declaradas
// al inicio del mtodo y despus imprimirlas
System.out.println(arch.readUTF()); // una cadena en formato UTF
System.out.println(arch.readInt()); // un valor int
System.out.println(arch.readDouble()); // un valor double
System.out.println(arch.readChar()); // un caracter
cont++;
// esto lo puse con la finalidad de poder visualizar los datos leidos
System.in.read();
System.in.skip(System.in.available());
}
}
catch(EOFException fin) // se capura la excepcin de fin de archivo (EOFException)
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close(); // se cierra el flujo de entrada del archivo
}
catch(IOException e)
{System.out.println("fin de archivo "+ e.getMessage());
}
}
}
Ejemplo 2
import java.io.*;
class lectura_aleatorio_2
{public static void main(String arg[]) throws IOException
{ String cad="";
int len=0;
double oper=0;
char car=' ';
int tam=22+4+8+2; // se calcula el tamao del registro de datos
long cont=0;
// se crea un objeto de la clase RandomAccessFile, en modo lectura (r)
RandomAccessFile arch=new RandomAccessFile("datos3.dat","r");
// se calcula el total de los elementos almacenados en el archivo
long total=arch.length()/tam;
if (total!=0)
{total+=1;}
try {
for (cont=0;cont<total;cont++)
{// posicin donde se grabara el nuevo registro de datos se graban los datos
arch.seek(tam*cont);
// se leen los datos del archivo, en este ejemplo los leo e imprimo directamente,
// pero pueden primero asignarse los valores a las varianles que estn declaradas
// al inicio del mtodo y despus imprimirlas
System.out.println(arch.readUTF()); // una cadena en formato UTF
System.out.println(arch.readInt()); // un valor tipo int
System.out.println(arch.readDouble()); // un valor tipo double
System.out.println(arch.readChar()); // un caracter
// esto lo puse con la finalidad de poder visualizar los datos ledos
System.in.read();
System.in.skip(System.in.available());
}
arch.close(); // se cierra el flujo de entrada del archivo
}
catch(EOFException fin) // se capura la excepcin de fin de archivo (EOFException)
Maria Eugenia Puga Nathal

Pgina 24

5/05/2015

Archivos

{System.out.println("fin de archivo "+ fin.getMessage());

arch.close(); // se cierra el flujo de entrada del archivo
}
catch(IOException e)
{System.out.println("fin de archivo "+ e.getMessage());
}
}
}

Maria Eugenia Puga Nathal

Pgina 25

5/05/2015