Archivos 15

Archivos
Archivos en Java
Conceptos básicos
Estructura jerárquica de datos: Conceptos lógicos 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 jerárquica de datos
Archivo: Colección de información que almacenamos en un soporte magnético para poderla manipular en cualquier momento.
Esta información 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 estaría formado por un
carácter.
Archivo: Colección de información (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 colección 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 tamaño de esta colección no
es fijo, está limitado solo por la cantidad de memoria secundaria disponible.
Un archivo es dinámico y un arreglo es estático al igual que un registro o una cadena. Ya que hay que indicar a estos últimos el
número de elementos que contendrá, y en ocasiones una vez creados, ya no pueden cambiar de tamaño.
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 magnética, entre otros).
Cada archivo es referenciado por un identificador (su nombre).
Archivo de datos: colección de registros relacionados entre sí con aspectos en común y organizados para un propósito especifico.
Archivo de texto: Archivo con organización 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 Página 1 17/09/2015

Archivos
Base de datos: Colección 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 extensión, por su organización, 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 algún formato del texto: tamaño, fuente, estilo, color, salto de
línea. Para su visualización correcta requieren de algún 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 código ascii, no
requieren de algún procesador de texto especializado)
- archivos de datos o binarios (requieren de un programa especial para poder visualizar su contenido)
Por su extensión
- de aplicación: .exe
- datos: .dat
- de texto: .txt, .pdf, .doc, .rtf, .ps
- de imágenes: .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 organización
- secuencial
- aleatoria o directa
- indexada
Por su orientación
- secuenciales (estándar)
- orientados al sistema (bajo nivel
Por su modo de apertura
- solo escritura
- solo lectura
- lectura/escritura
Acceso secuencial: exploración 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 través de su posición.
Organización secuencial: los elementos se almacenan uno tras otro, un nuevo elemento siempre se almacena hasta el final del
archivo.
Organización aleatoria o directa: permite seleccionar la posición (dirección de memoria válida) para almacenar el elemento, por
lo general se requiere de espacio de memoria homogéneos para almacenar cada conjunto de datos (registro).

Archivos
Organización indexada: permite ordenar contenidos poniendo índices. La acción de ordenar registros mediante la utilización de
índices. Las bases de datos, por ejemplo, suelen almacenar índices de su contenido en función de unos parámetros previamente
definidos. La indexación proporciona agilidad en las búsquedas, lo que se traduce en mayor rapidez a la hora de mostrar resultados.
Operaciones básicas
- 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 información a través de la entrada estándar 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 algún lenguaje de programación 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
- extensión
- tipo de archivo
- fecha de creación
- fecha de la última modificación
- autor
- tamaño
- estado del archivo (solo lectura, solo escritura, oculto) (o propiedades del archivo)
Para crear un archivo se requiere de la información siguiente
- nombre del dispositivo (lugar donde se va a crear)
- nombre del archivo
- organización del archivo
- tamaño del bloque o registro físico
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 información de donde se puede leer información o donde se puede escribir información. La lectura y salida se hace en forma
secuencial, dato por dato, uno tras otro.
Java y c# realizan operaciones en archivos a través 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 comunicación (lectura, escritura, lectura/escritura), la posibilidad de

Archivos
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 (numéricos).
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.
Todas las entradas y salidas de datos están dirigidas a través 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
algún 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 transformación 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 algún 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 algún otro dispositivo)
- de bytes (unidad básica, 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:
Entrada Salida
bytes InputStream OutputStream
caracteres Reader Writer
Estas clases heredan sus métodos y atributos a otras clases que permitirán el manejo de los diferentes flujos tanto de datos como de
entrada/salida
Clases para el manejo de flujos de datos
bytes caracteres
Memoria ByteArrayInputStream
ByteArrayOutputStream
StringBufferedInputStream
CharArrayReader
CharArrayWriter
StringReader
StringWriter
Archivo FileInputStream
FileOutputStream
FileReader
FileWriter
Tuberia PipedInputStream
PipedOutputStream
PipedReader
PipedWriter
Clases para el manejo de flujos de datos de entrada/salida
bytes caracteres
Establecer buffer BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
Establecer filtro FilterInputStream
FilterOutputStream
FilterReader
FilterWriter
Convertir bytes a caracteres InputStreamReader
OutputStreamReader
Concatenar SequenceInputStream
Serializar ObjectInputStream

Archivos
ObjectOutputStream
Convertir a datos primitivos DataInputStream
DataOutputStream
Contar números de líneas LineNumberInputStream LineNumberReader
Mirar anticipadamente PushbackInputStream PushbackReader
Escribir PrintStream PrintWriter
Tipos de flujos en general
Flujos con bytes Flujos con caracteres
Flujos de entrada de datos InputStream
ByteArrayInputStream
FileInputStream
FilterInputStream
BufferedInputStream
DataInputStream
LineNumberInputStream
PushbackInputStream
ObjectInputStream
PipedInputStream
SequenceInputStream
StringBufferdInputStream
Reader
BufferedReader
LineNumberReader
CharArrayReader
FilterReader
PushbackReader
InputStreamReader
FileReader
PipedReader
StringReader
Flujos de salida de datos OutputStream
ByteArrayOutputStream
FileOutputStream
FilterOutputStream
BufferedOutputStream
DataOutputStream
PrintStream
ObjectOutputStream
PipedOutputStream
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 también hacer la manipulación 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 físicamente, 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 tamaño, la fecha de su última modificación, 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 simultáneamente, acceder a los elementos (registros) de forma aleatoria (o directa)
indicando la posición en la que se quiere operar. Se usa el termino de cursor, indicador o puntero para hacer referencia a la
posición 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 métodos

Archivos
Métodos 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(); true si es de lectura
boolean x=obj_File.canWriter(); true si es de escritura
boolean x=obj_File.exists(); true si el archivo existe
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 raíz) donde se localiza el archivo
String cad=obj_File.toString(); regresa el objeto File en cadena
long tam=obj_File.length() Regresa el tamaño del archivo, en bytes.
long fecha=obj_File.lastModified(); Regresa la fecha de la última modificación 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 máquina virtual. Esta solicitud sólo
se aplica en una finalización normal de la máquina virtual, y no se puede revocar una vez
emitida.
Clase Reader
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 número de caracteres almacenados en el
arreglo x
int y= obj.read(char [] x); regresa el número de caracteres almacenados en el arreglo, inicia desde la posición 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 leído
obj.close(); cierra el flujo de entrada de datos
Clase InputStream
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 número de datos almacenados en el arreglo x
int y= obj.read(byte [] x); regresa el número de datos almacenados en el arreglo, inicia desde la posición 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 asignación, es decir: obj.skip(cantidad); u obj.skip(obj.available());
boolean c=obj.ready(); regresa true si el stream (flujo) está listo para ser leído
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
obj.write(int x);

Archivos
obj.write(char [] x, int posicionInicioArreglo, int cantidadCaracteres); escribe una cantidad x de caracteres a partir de una posición
dada en el arreglo
obj.write(char [] x); escribe (almacena) caracteres en un arreglo a partir de la posición 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
posición 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
Clase OutputStream
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
posición dada en el arreglo
obj.write(byte [] x); escribe (almacena) datos tipo byte en un arreglo a partir de la posición 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 métodos 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 creación de un objeto que se asociara con un archivo, primero se verifique la existencia de éste
a través del método exists() de la clase File, por ejemplo:
Clase FileReader
Clase que permite leer archivos de texto (secuenciales), si se quiere leer línea por línea, se auxilia de la clase BufferedReader.
Método constructor
FileReader(String nombArchivo);
FileReader(File objFile);
Clase FileWriter
Clase que permite crear archivos de texto (secuenciales), en caso de que se quiera grabar línea por línea se auxilia de la clase
PrintWriter.
Método 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 visualización. Si se utiliza en combinación con la clase
FileOutputStream o FileWriter para escribir una cadena, le añade al final un salto de línea si se utiliza el método println.
PrintWriter(destino)
PrintWriter(destino,true) el valor booleano indica que se vacía el espacio de almacenamiento intermedio con cada nueva línea.

Archivos
obj.println(cadena); visualiza una cadena y salta línea, si el destino es un archivo, se agrega a la cadena un salto de línea.
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 instrucción
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).
Clase BufferedReader
Devuelve una línea de texto en forma de cadena. Permite obtener (leer) una secuencia de caracteres como entrada de datos, en
lugar de caracter por carácter.
obj.readLine(); obtiene o lee una cadena de caracteres hasta encontrar un separador de línea que puede ser un salto de línea (n), un
retorno de carro (r (enter o return), o ambos ( r n en esta combinación), no los incluye como parte de ésta. Si se encuentra el final
del flujo (stream) antes del final de una línea, regresa un valor null.
Clase LineNumberReader
Lleva la cuenta de los números de línea al leer el texto. Añade números de línea en la lectura de cadenas. Si se utiliza en
combinación con la clase FileReader, permite obtener el número de línea que se va leyendo en un archivo de texto. Hereda todos
los métodos y atributos de la clase BufferedReader.
Utiliza los mismos métodos que la clase BufferedReader
obj.setLineNumber (int n); // añade un número de línea
int n=obj.getLineNumber (); // regresa el número de línea leído
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 línea por línea, se auxilia de la clase BufferedReader.
FileInputStream f=new FileInputStream(“archivo.extension”);
FileInputStream f=new FileInputStream(objeto_File);
Hereda los métodos 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 línea por línea.
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);

Archivos
El valor true significa que cuando se vuelva a ejecutar el programa que contiene esta clase, los datos del archivo permanecerán en
éste, y que los nuevos se anexarán al final. Es decir los datos se conservarán, 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
posición.
Hereda los métodos de la clase OutputStream
Clase PrintStream
Permite producir salida formateada, es decir se preocupa por la visualización. Si se utiliza en combinación con la clase
FileOutputStream para escribir una cadena, le añade al final un salto de línea si se utiliza el método println.
PrintStream(destino);
PrintStream(destino, true); el valor booleano indica que se vacía el espacio de almacenamiento intermedio con cada nueva línea.
obj.println(cadena); visualiza una cadena y salta línea, si el destino es un archivo, se agrega a la cadena un salto de línea.
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 instrucción 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 combinación con la clase
FileInputStream para la creación de un archivo de lectura de datos.
Método 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 línea de texto incluyendo el enter y salto de línea
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 combinación con la clase
FileOutputStream para la creación de un archivo de escritura de datos.

Archivos
Método 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”));
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 tamaño de la cadena.
Serialización
La serialización 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 serialización de un objeto
permite darle mas persistencia al objeto (la vida del objeto se alargara), ya que éste seguirá existiendo aun cuando termine la
ejecución del programa, solo que ahora lo hará en memoria secundaria y no en la memoria principal y cuando sea nuevamente
leído cobrará ese efecto de persistencia.
Cabe mencionar que la interfaz Serializable es una simple bandera, y no contiene métodos, 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 través del método 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 través del método readObject(), pero en este caso se regresa una referencia a un objeto Object por lo que es
necesario hacer una conversión explícita 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 serialización, puede ocurrir que haya un subobjeto (o atributo) en particular para el que no se desee
que se produzca un salvado y recuperación automáticos por parte del mecanismo de serialización de Java. Como por ejemplo una
contraseña. Una forma de cómo 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 serán 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).
Método constructor

Archivos
ObjectInputStream objeto=new ObjectInputStream(fuente de entrada);
ClaseObjetoSerializable obj=( ClaseObjetoSerializable) objeto.readObject(); // transforma el objeto en una secuencia de bits y los
// envía a su destino
Para poder hacer la lectura de cualquier tipo de dato primitivo, hace uso de los mismos métodos 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 específico (red,
archivo).
Método constructor
ObjectOutputStream objeto=new ObjectOutputStream(fuente de salida);
objeto.writeObject(objetoSerializable); // transforma el objeto en una secuencia de bits y los envía a su destino
Para poder hacer la escritura de cualquier tipo de dato primitivo, hace uso de los mismos métodos que la clase DataOutputStream.
Clase RandomAccessFile
Permite crear archivos con una organización 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 también archivos de una
organización secuencial. Por lo general va orientado al manejo de archivos de datos.
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 posición actual del puntero del archivo, que es desde el inicio hasta la posición actual
f.seek(posicion); desplaza el puntero n bytes tomando como origen el del archivo (byte 0)
long x=.f.length(); regresa el tamaño actual del archivo, número de bytes que ocupa o longitud que tiene
f.setLength(n); permite establecer de antemano el tamaño del archivo, n es el número de bytes que se requiere que se
reserve para los datos del archivo, cuando ya sabemos de antemano la cantidad máxima de elementos que contendrá nuestra
aplicación, hacemos uso de este método, por ejemplo, si se va a utilizar el archivo para guardar los datos de algún control de
reservación de habitaciones de un hotel, de un teatro, de un restauran, asientos de un avión, reservar una computadora en algún
cyber o en el laboratorio de cómputo, por mencionar algunas aplicaciones
f.seek(f.length()); nos coloca al final del archivo
f.seek(i*tamaño); nos va colocando en cada bloque de memoria definido para un registro de datos, el tamaño nosotros lo
definimos a través 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 operación siguiente:
Nregs= (int) Math.ceil ( (double)f.length() / (double)tamaño);
Para el manejo de los datos, es decir para la escritura o lectura, tiene los mismos métodos que las clases DataInputStream y
DataOutputStream.
Ejemplos
Clase File
import java.util.*; // se necesita para la clase Date, que convierte un valor numérico a un formato de fecha en este caso
import java.io.*;

Archivos
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());}
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 parámetro arg del método 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 leídos del archivo
System.out.print((char)car); // se imprime el caracter leído
car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de éste
}
System.out.println("nnnSe imprime la cadena formada por los caracteres leídos 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

Archivos
}
catch (IOException e)
{// por si se genera algún 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 (línea) por cadena(línea):
import java.io.*;
class lectura_archivo
String cad=null;
// creo un objeto de la clase BufferedReader para obtener la cadena
// completa del archivo, línea por línea, es decir al momento de encontrar
// los carcateres rn (enter+salto de línea) se forma una primera cadena
// (línea de texto), se envía como parámetro un objeto anónimo de la clase
// FileReader, la cual es utilizada como fuente de donde se obtendrán las
// cadenas, al momento de crear este objeto anónimo, 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 línea de texto) del archivo
while(cad!=null) // se verifica que no sea fin de archivo
{System.out.println(cad); // se imprime la cadena leída desde del archivo
cad=ent.readLine(); // se lee la siguiente línea del archivo
}
ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (EOFException e)
}
}
}
Si la aplicación que se está desarrollando requiere la lectura de un archivo de texto, pero que a su vez vaya listando el número de
línea, se puede utilizar la clase LineNumberReader, la cual es una extensión de la clase BufferedReader, es decir hereda los
métodos y atributos de la clase, agregando otros como getLineNumber(), el cual permite obtener el número de una línea,
setLineNumber(int NumeroLinea).
Ejemplo de la lectura de un archivo de texto línea por línea, además de enumerar cada línea leída:
import java.io.*;
class lectura_archivo_linea
String cad=null;
int nl=0;
// creo un objeto de la clase LineNumberReader para obtener la cadena (línea) y número de línea
// completa del archivo, línea por línea, se envía como parámetro un objeto
// anónimo de la clase FileReader, la cual es utilizada como fuente de donde
// se obtendrán las cadenas, al momento de crear este objeto anónimo, se está dando la
// apertura al archivo en modo de lectura
LineNumberReader ent=new LineNumberReader(new FileReader(archivo));

Archivos
try { cad=ent.readLine(); // se lee el primera línea de texto del archivo
while(cad!=null) // se verifica fin de archivo
{nl=ent.getLineNumber(); // se obtiene el numero de línea
System.out.println(nl+" "+cad); //se imprime numero de línea y contenido de la línea
cad=ent.readLine(); // se lee la siguiente línea de texto
}
ent.close();// se cierra el flujo del objeto que contiene el control del flujo del archivo
}
}
}
}
Ejemplo de la lectura de un archivo de texto, caracter por caracter:
import java.io.*;
class lectura_archivo_car_2
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 leídos del archivo
System.out.print((char)car); // se imprime el caracter leído
car=ent.read(); // se lee el siguiente caracter del archivo, se almacena -1 cuando se haya llegado al final de éste
}
System.out.println("nnnSe imprime la cadena formada por los caracteres leídos del");
System.out.println("archivo lo anterior se imprimió caracter por caracter.");
System.out.println(cad); //opcional, imprimo la cadena formada con los caracteres leídos del archivo
ent.close(); // Se cierra el archivo
}
}
}
}
Ejemplo de la lectura de un archivo de texto línea por línea:
import java.io.*;
class lectura_archivo_2
String cad=null;
// creo un objeto de la clase BufferedReader para obtener la cadena
// completa del archivo, línea por línea, es decir al momento de encontrar
// los carcateres rn (enter+salto de línea) se forma una primera cadena

Archivos
// (línea de texto), se envía como parámetro un objeto anónimo de la clase
// FileInputStream para convertir el flujo de bytes a caracteres, a su vez,
// éste tendrá como parámetro un objeto anónimo de la clase FileInputStream,
// la cual es utilizada como fuente de donde se obtendrán las cadenas, al
// momento de crear este objeto anónimo, 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 línea de texto) del archivo
while(cad!=null) // se verifica que no sea fin de archivo
{System.out.println(cad); // se imprime la cadena leída desde del archivo
cad=ent.readLine(); // se lee la siguiente línea del archivo
}
ent.close(); // se cierra el flujo del objeto que contiene el control del flujo del archivo
}
catch (EOFException e)
}
}
}
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
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 estarán leyendo los datos del
// archivo, el ciclo se rompe al momento en que no hay elementos en el
// archivo, y se lanza la excepción EOFException
while(true)
{cad=arch.readUTF(); // se lee la cadena en formato UTF
System.out.println(cad); // se imprime la cadena leída
}
}
catch(EOFException fin)
{System.out.println("fin de archivo "+ fin.getMessage());
arch.close();
}
}
}
ESCRITURA
Clase FileWriter
Ejemplo de la generación de un archivo de texto, caracter por caracter
import java.io.*;
class escritura_archivo_car
{// introduzco el nombre del archivo desde el teclado al momento de ejecutar
String arch=arg[0];

Archivos
// 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());
}
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 excepción
}
}
Ejemplo de la generación de un archivo de texto, cadena por cadena
import java.io.*;
class escritura_archivo_cad
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
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
}
}
{}
}
}
Ejemplo de la generación de un archivo de texto, línea por línea
import java.io.*;
class escritura_archivo
String arch=arg[0];

Archivos
// se crea un objeto de la clase PrintWriter para que me permita grabar
// una cadena e incorpore el salto de línea, esto a través del método println,
// cuando se crea el objeto se manda como parámetro el objeto anónimo de la clase
// FileWriter, el cual se tomará como destino, además con la creación de este objeto
// anónimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute
PrintWriter escribe=new PrintWriter(new FileWriter(arch,true));
String cad="";
{escribe.println(cad);} // se escribe o graba la línea de texto (cadena) en el archivo
}
escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo
}
{}
finally {escribe.close();} // es otra parte del try, ésta se realiza se produzca o no una excepción
}
}
Ejemplo de la generación de un archivo de texto, caracter por caracter
import java.io.*;
class escritura_archivo_car_2
// 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
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
}
}
{}
}
}
Ejemplo de la generación de un archivo de texto, línea por línea
import java.io.*;

Archivos
class escritura_archivo_2
String arch=arg[0];
// se crea un objeto de la clase PrintStream para que me permita grabar
// una cadena e incorpore el salto de línea, esto a través del método println,
// cuando se crea el objeto se manda como parámetro el objeto anónimo de la clase
// FileOutputStream, el cual se tomará como destino, además con la creación de este objeto
// anónimo se da la apertura al archivo, el valor de true indica, que tantas veces ejecute
PrintStream escribe=new PrintStream(new FileOutputStream(arch,true));
String cad="";
{escribe.println(cad);} // se escribe o graba la línea de texto (cadena) en el archivo
}
escribe.close(); // se cierra el flujo del objeto que contiene el flujo del archivo
}
{}
}
}
Ejemplo de la generación de una archivo de texto, cadena por cadena:
import java.io.*;
class aleatorio_texto_escr
// el programa, es capturado por el parametro arg del metodo main
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 algún dato del archivo, bajo este
// modo se puede hacer, sin necesidad de primer abrir el archivo en modo de lectura
// y después en modo escritura para hacer éste cambio.
RandomAccessFile arch=new RandomAccessFile(archivo,"rw");
tam=arch.length(); // obtiene el tamaño del archivo, en bytes
arch.seek(tam); // coloca el puntero del archivo en la última posición, 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 encimaría
for (int i=1;i<arg.length;i++)
{// introduzco las cadenas desde el teclado al momento de ejecutar
// el programa, son capturadas por el parámetro arg del método main
cad=arg[i];
// se graban los datos en el archivo
arch.writeUTF(cad); // una cadena, en formato UTF

Archivos
}
arch.close();
}
}
Archivo de datos
LECTURA
Ejemplo de un archivo de lectura de datos:
import java.io.*;
class lectura_datos_1
{ String cad="";
int len=0;
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 parámetro
// el objeto anónimo de la clase FileInputStream, que es la fuente de donde
// se tomarán los datos, este objeto indica la apertura del archivo en modo lectura.
DataInputStream arch=new DataInputStream(new FileInputStream("datos1.dat"));
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 excepción fin de archivo
arch.close(); // cierra el flujo que está relacionado con el archivo
}
}
}
Ejemplo de un archivo de lectura de datos:
import java.io.*;
class lectura_datos_2
{ String cad="";
int len=0;
double oper=0;
char car=' ';
RandomAccessFile arch=new RandomAccessFile("datos2.dat","r");
while(true)

Archivos
{ // 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 leídos del archivo
System.out.println(cad+" "+len+" "+oper+" "+car);
}
}
catch(EOFException fin)
arch.close(); // se cierra el flujo de entrada del archivo
}
}
}
ESCRITURA
Ejemplo de un archivo de escritura de datos:
import java.io.*;
class escritura_datos_1
{ 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 parámetro
// el objeto anónimo 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.
DataOutputStream arch=new DataOutputStream(new FileOutputStream(archivo,true));
cad=arg[i];
len=cad.length();
oper=Math.random()*len;
car=cad.charAt(0);
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
}
}
Ejemplo de un archivo de escritura de datos:

Archivos
import java.io.*;
class escritura_datos_2
{ String archivo="datos2.dat";
long tam;
String cad;
int len;
double oper;
char car;
// y despues en modo escritura para hacer éste cambio.
RandomAccessFile arch=new RandomAccessFile(archivo,"rw");
tam=arch.length(); // obtiene el tamaño del archivo, en bytes
arch.seek(tam); // coloca el puntero del archivo en la última posición, 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 encimaría
cad=arg[i];
len=cad.length();
car=cad.charAt(0);
}
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 métodos, 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 métodos que
// tengan los modificadores de tipo static o transient no serán 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.*;

Archivos
class fileobjetos1_1
{// 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,
// además de permitir leer tipos de datos primitivos (los mismos que DataInputStream), toma
// como parámetro para este caso, el objeto anónimo de la clase FileInputStream, que es la
// fuente de donde se tomarán 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 través de
// un cast (conversión explícita) al tipo de objeto en particular a obtener, es decir se
// deserializa (conversión de un flujo de bytes (o bits) a un objeto en particular)
datos=(Datos) objeto.readObject();
// se imprimien los datos del objeto
System.out.println(datos.cad+" "+datos.len+" "+datos.oper+" "+datos.car);
}
}
catch(EOFException fin) // se captura la excepción 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 algún problema (excepción) con el objeto
{System.out.println("error al leer el objeto");}
}
}
Clase ObjectOutputStream (salida/escritura)
import java.io.*;
class fileobjetos1
{ // 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, también me permite escribir (grabar) datos de diferentes
// tipos como lo hace la clase DataOutputStream, toma como par metro el objeto
// anónimo 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, serán 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
Archivos aleatorios
ESCRITURA
import java.io.*;
class escritura_aleatorio
{ String cad;
int len;
double oper;
char car;
StringBuffer cadmod;
int tam=22+4+8+2; // se calcula el tamaño del registro de datos
// 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 posición válida para almacenar el nuevo elemento del archivo,
// una posición mas adelante de la última
long total=arch.length()/tam;
if (total!=0)
{total+=1;}
System.out.println("tamaño "+tam+" total "+total);
cad=arg[i];
// debido a que un archivo de acceso aleatorio requiere de registros de tamaño 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 método setLength() que permite fijar una
// longitud a la cadena, para esto creo un objeto de la clase StringBuffer pasando como
// parámetro la cadena a modificar, se establece el nuevo tamaño, una vez que se tiene esto,
// se hace una conversión a través del método 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();
car=cad.charAt(0);
arch.seek(tam*(i+total)); // posición donde se grabara el nuevo registro de datos
// se graban los datos
arch.writeUTF(cad); // una cadena en formato UTF
}
arch.close(); // se cierra el flujo de salida del archivo
}
}
LECTURA

Archivos
Ejemplo 1
import java.io.*;
class lectura_aleatorio_1
{ String cad="";
int len=0;
double oper=0;
char car=' ';
int tam=22+4+8+2;// se calcula el tamaño del registro de datos
int cont=0;
while(true)
{arch.seek(tam*cont); // se posiciona el puntero en el byte donde se
// localiza el registro de los datos que se comenzarán 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 están declaradas
// al inicio del método y después 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();
}
}
catch(EOFException fin) // se capura la excepción de fin de archivo (EOFException)
}
{System.out.println("fin de archivo "+ e.getMessage());
}
}
}
Ejemplo 2
import java.io.*;
class lectura_aleatorio_2
{ String cad="";
int len=0;
double oper=0;
char car=' ';
int tam=22+4+8+2; // se calcula el tamaño del registro de datos
long cont=0;
// se calcula el total de los elementos almacenados en el archivo
long total=arch.length()/tam;
if (total!=0)
{total+=1;}

Archivos
try {
for (cont=0;cont<total;cont++)
{// posición 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 están declaradas
// al inicio del método y después 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 leídos
System.in.read();
}
}
catch(EOFException fin) // se capura la excepción de fin de archivo (EOFException)
}
{System.out.println("fin de archivo "+ e.getMessage());
}
}
}

Archivos 15

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Similar a Archivos 15

Similar a Archivos 15 (20)

Último

Último (7)

Archivos 15