Documentos de Académico
Documentos de Profesional
Documentos de Cultura
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
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.
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.
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
bytes
BufferedInputStream
BufferedOutputStream
FilterInputStream
FilterOutputStream
SequenceInputStream
ObjectInputStream
ObjectOutputStream
DataInputStream
DataOutputStream
LineNumberInputStream
PushbackInputStream
PrintStream
Pgina 4
caracteres
BufferedReader
BufferedWriter
FilterReader
FilterWriter
InputStreamReader
OutputStreamReader
LineNumberReader
PushbackReader
PrintWriter
5/05/2015
Archivos
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
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).
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
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));
Pgina 9
5/05/2015
Archivos
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
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
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
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
Pgina 16
5/05/2015
Archivos
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
Pgina 21
5/05/2015
Archivos
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
Pgina 23
5/05/2015
Archivos
Pgina 24
5/05/2015
Archivos
Pgina 25
5/05/2015