Indice

Pag
Introduccion 2
Archivos 3
Archivos Secuenciales 7
Archivos Aleatorios 14
Conclusion 19
Bibliografia 20




















Introduccion

El almacenamiento de datos en variables y arreglos es temporal; los datos
se pierden cuando una variable local "sale de su alcance" o cuando el programa
termina, por ejemplo. Se usan archivos para conservar a largo plazo grandes
cantidades de datos, incluso despus de que el programa que cre los datos ha
terminado.
Los datos mantenidos en archivos se conocen como datos persistentes. Las
computadoras guardan los archivos en dispositivos de almacenamiento
secundario como discos magnticos, discos pticos y cintas magnticas.
En este trabajo explicaremos cmo se crean, actualizan y procesan
archivos mediante programas en Java. Veremos los archivos tanto de "acceso
secuencial" como de "acceso aleatorio" e indicaremos los tipos de aplicaciones
para las que es apropiado cada tipo.
El procesamiento de archivos es una de las capacidades ms importantes
que un lenguaje debe tener para apoyar aplicaciones comerciales que suelen
procesar enormes cantidades de datos persistentes.












Archivos
Los archivos tambin denominados ficheros son una coleccin de
informacin (datos relacionados entre s), localizada o almacenada como una
unidad en alguna parte de la computadora. Los archivos son el conjunto
organizado de informaciones del mismo tipo, que pueden utilizarse en un mismo
tratamiento; como soporte material de estas informaciones.
La clase File se usa para obtener informacin sobre archivos y
directorios. Adems la clase File permite crear y eliminar archivos y directorios. Un
objeto de la clase Java File representa un archivo o directorio.

La forma de interactuar con los sistemas de archivos locales se realiza a
travs de la clase File, esta clase proporciona muchas utilidades relacionadas con
archivos y con la obtenci n de informacin bsica sobre esos archivos.
Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres
constructores siguientes:
1) Public File(String nombreFichero|path);
2) Public File (String path, String nombreFichero|path);
3) Public File (File path, String nombreFichero|path);
La ruta o path puede ser absoluta o relativa.
Ejemplos utilizando el primer constructor:
1. Crea un Objeto File asociado al fichero personas.dat que se encuentra en el
directorio de trabajo:
File f = new File("personas.dat");
En este caso no se indica path. Se supone que el fichero se encuentra en el
directorio actual de trabajo.
2. Crea un Objeto File asociado al fichero personas.dat que se encuentra en el
directorio ficheros dentro del directorio actual.
File f = new File("ficheros/personas.dat");
En este caso se indica la ruta relativa tomando como base el directorio
actual de trabajo. Se supone que el fichero personas.dat se encuentra en el
directorio ficheros. A su vez el directorio ficheros se encuentra dentro del directorio
actual de trabajo.
3. Crea un Objeto File asociado al fichero personas.dat dando la ruta absoluta:
File f = new File("c:/ficheros/personas.dat");
El fichero se encuentra en el directorio ficheros. A su vez el directorio
ficheros se encuentra en la raz de la unidad C:
Si se omite la letra de la unidad, por defecto se asume la letra de la unidad
en la que se encuentra el proyecto:
File f = new File("/ficheros/personas.dat");
Ejemplos utilizando el segundo constructor:
En este caso se crea un objeto File cuya ruta (absoluta o relativa) se indica
en el primer String.
1. Crea un Objeto File asociado al fichero personas.dat que se encuentra en el
directorio ficheros dentro del directorio actual.
File f = new File("ficheros", "personas.dat" );
En este caso se indica la ruta relativa tomando como base el directorio
actual de trabajo.
2. Crea un Objeto File asociado al fichero personas.dat dando la ruta absoluta:
File f = new File("/ficheros", "personas.dat" );
En este caso se indica la ruta absoluta, indicada por la barra del principio.
Ejemplos utilizando el tercer constructor:
Este constructor permite crear un objeto File cuya ruta se indica a travs de
otro objeto File.
1. Crea un Objeto File asociado al fichero personas.dat que se encuentra en el
directorio ficheros dentro del directorio actual.
File ruta = new File("ficheros");
File f = new File(ruta, "personas.dat" );
2. Crea un Objeto File asociado al fichero personas.dat dando la ruta absoluta:
File ruta = new File("/ficheros");
File f = new File(ruta, "personas.dat" );
Debemos tener en cuenta que crear un objeto File no significa que deba
existir el fichero o el directorio o que el path sea correcto. Si no existen no se
lanzar ningn tipo de excepcin ni tampoco sern creados.
MTODOS
Algunos mtodos de la clase File son los siguientes:
MTODO DESCRIPCIN
boolean canRead() Devuelve true si se puede leer el fichero
boolean canWrite() Devuelve true si se puede escribir en el fichero
boolean createNewFile() Crea el fichero asociado al objeto File. Devuelve true si se ha
podido crear. Para poder crearlo el fichero no debe existir.
Lanza una excepcin del tipo IOException.
boolean delete() Elimina el fichero o directorio. Si es un directorio debe estar
vaco. Devuelve true si se ha podido eliminar.
boolean exists() Devuelve true si el fichero o directorio existe
String getName() Devuelve el nombre del fichero o directorio
String getAbsolutePath() Devuelve la ruta absoluta asociada al objeto File.
String getCanonicalPath() Devuelve la ruta nica absoluta asociada al objeto File.
Puede haber varias rutas absolutas asociadas a un File pero
solo una nica ruta cannica. Lanza una excepcin del tipo
IOException.
String getPath() Devuelve la ruta con la que se cre el objeto File. Puede ser
relativa o no.
String getParent()

Devuelve un String conteniendo el directorio padre del File.
Devuelve null si no tiene directorio padre.
File getParentFile() Devuelve un objeto File conteniendo el directorio padre del
File. Devuelve null si no tiene directorio padre.
boolean isAbsolute() Devuelve true si es una ruta absoluta
boolean isDirectory() Devuelve true si es un directorio vlido
boolean isFile() Devuelve true si es un fichero vlido
long lastModified() Devuelve un valor en milisegundos que representa la ltima
vez que se ha modificado (medido desde las 00:00:00 GMT,
del 1 de Enero de 1970). Devuelve 0 si el fichero no existe o
ha ocurrido un error.
long length() Devuelve el tamao en bytes del fichero. Devuelve 0 si no
existe. Devuelve un valor indeterminado si es un directorio.
String[] list() Devuelve un array de String con el nombre de los archivos y
directorios que contiene el directorio indicado en el objeto
File. Si no es un directorio devuelve null. Si el directorio est
vaco devuelve un array vaco.
String[] list(FilenameFilter
filtro)
Similar al anterior. Devuelve un array de String con el nombre
de los archivos y directorios que contiene el directorio
indicado en el objeto File que cumplen con el filtro indicado.
boolean mkdir() Crea el directorio. Devuelve true si se ha podido crear.
boolean mkdirs() Crea el directorio incluyendo los directorios no existentes
especificados en la ruta padre del directorio a crear.
Devuelve true si se ha creado el directorio y los directorios no
existentes de la ruta padre.
boolean renameTo(File dest)

Cambia el nombre del fichero por el indicado en el parmetro
dest. Devuelve true si se ha realizado el cambio.

Ejemplo: El siguiente programa muestra el uso de algunos mtodos de la clase
File. Se crea un objeto File ruta asociado al directorio c:/ficheros y un objeto
File f asociado al ficherodatos.txt que se encuentra en ese directorio. Si el fichero
no existe se crea y si el directorio no existe se crea y a continuacin se crea el
fichero. Si el fichero existe se muestra el tamao del mismo.

import java.io.File;
import java.io.IOException;
public class File2 {

public static void main(String[] args) throws IOException {
File ruta = new File("c:/ficheros");
File f = new File(ruta, "datos.txt");
System.out.println(f.getAbsolutePath());
System.out.println(f.getParent());
System.out.println(ruta.getAbsolutePath());
System.out.println(ruta.getParent());
if (!f.exists()) { //se comprueba si el fichero existe o no
System.out.println("Fichero " + f.getName() + " no existe");
if (!ruta.exists()) { //se comprueba si la ruta existe o no
System.out.println("El directorio " + ruta.getName() + " no existe");
if (ruta.mkdir()) { //se crea la ruta. Si se ha creado correctamente
System.out.println("Directorio creado");
if (f.createNewFile()) { //se crea el fichero. Si se ha creado
correctamente
System.out.println("Fichero " + f.getName() + " creado");
} else {
System.out.println("No se ha podido crear " + f.getName());
}
} else {
System.out.println("No se ha podido crear " + ruta.getName());
}
} else { //si la ruta existe creamos el fichero
if (f.createNewFile()) {
System.out.println("Fichero " + f.getName() + " creado");
} else {
System.out.println("No se ha podido crear " + f.getName());
}
}
} else { //el fichero existe. Mostramos el tamao
System.out.println("Fichero " + f.getName() + " existe");
System.out.println("Tamao " + f.length() + " bytes");
}
}
}

Archivos Secuenciales

Es la forma bsica de organizar un conjunto de registros, que forman un
archivo, utilizando una organizacin secuencial. En un archivo organizado
secuencialmente, lo registros quedan grabados consecutivamente cuando el
archivo se utiliza como entrada. En la mayora de los casos, los registros de un
archivo secuencial quedan ordenados de acuerdo con el valor de algn campo de
cada registro. Semejante archivo se dice que es un archivo ordenado; el campo, o
los campos, cuyo valor se utiliza para determinar el ordenamiento es conocido
como la llave del ordenamiento. Un archivo puede ordenarse ascendente o
descendentemente con base en su llave de ordenamiento.

La forma ms comn de estructura de archivo es el archivo secuencial. En
este tipo de archivo, un formato fijo es usado para los registros. Todos los
registros tienen el mismo tamao, constan del mismo nmero de campos de
tamao fijo en un orden particular. Como se conocen la longitud y la posicin de
cada campo, solamente los valores de los campos se necesitan almacenarse; el
nombre del campo y longitud de cada campo son atributos de la estructura de
archivos.

Los archivos se abren creando objetos de las clases de flujos FileInputStream y
FileOutputStream. Se pasa un argumento al constructor del objeto: el nombre del
archivo. Los archivos existentes que se abren para salida se truncan, es decir, se
desechan todos los datos del archivo. Si el archivo especificado todava no existe,
se crea un archivo con ese nombre.
Como un ejemplo, enviaremos datos a la salida usando un DataOutputStream
conectado a un FileOutputStream mediante una tcnica denominada
encadenamiento de objetos de flujo. Por ejemplo, cuando se cree el objeto output
de la clase DataOutputStream, se proporcionar a su constructor un objeto
FileOutputStream como argumento, como se muestra a continuacin:
salida = new DataOutputStream(new FileOutputStream("clientes.dat") );
El enunciado anterior crea un objeto DataOutputStream llamado salida
asociado al archivo clientes.dat. El argumento "clientes.dat" se pasa al constructor
FileOutputStream que abre el archivo. Esto establece una "lnea de comunicacin"
con el archivo.
Al crear un objeto FileOutputStream e intentar abrir un archivo, se puede definir en
un programa un mtodo que pruebe si la operacin de apertura tuvo o no xito. Si
la operacin falla, se genera una excepcin de E/S (IOException) que debe ser
atrapada por el programa, como se muestra a continuacin:
try {
salida = new DataOutputStream(new FileOutputStream( "clientes.dat" ) );
}
catch ( IOException e ) {
System.err.println( "No abri bien el archivo\n" +
e.toString( ) );
System.exit( 1 );
}
Si se genera un IOException es porque el intento de abrir el archivo no tuvo xito,
se exhibe el mensaje de error "No se abri bien el archivo" seguido del mensaje
de error contenido en el objeto de excepcin, y se invoca el mtodo exit (salir) de
la clase System para terminar el programa. El argumento de exit se devuelve al
entorno desde el cual se invoc el programa. Un argumento de 0 indica que el
programa termin normalmente; cualquier otro valor indica que el programa
termin a causa de error. El valor utilizado por exit es utilizado por el entorno
invocador (con toda probabilidad el sistema operativo) para responder de forma
apropiada al error. Algunas razones de que se lance un IOException al abrir
archivos son intentar abrir para lectura un archivo que no existe, intentar abrir un
archivo para lectura sin tener permiso y abrir un archivo para escritura cuando no
hay espacio en disco.
A continuacin mostramos la ventana principal de un programa que captura la
siguiente informacin:
El programa supone que los datos se introducen correctamente y en el orden
correcto por nmero de registro. Cada vez que se completa un registro, el usuario
hace clic en el botn Guardar para escribir el registro en el archivo. Esto invoca al
mtodo agregarRegistro para que efecte la operacin de escritura. En este
mtodo, cada campo del registro se escribe individualmente con llamadas a los
mtodos writeInt (escribir un valor entero), writeUTF (escribir una cadena) y
writeDouble (escribir un valor de doble precisin) de la clase DataOutputStream. El
usuario hace clic en el botn Terminar para informar al programa que no hay ms
datos que procesar.
Una vez que el usuario hace clic en el botn Terminar, el programa termina. Sin
embargo, antes de terminar el programa determina si hay algn registro que
escribir en disco, vaca el flujo de salida para asegurarse de que todos se hayan
enviado al archivo y cierra el flujo de salida. El programador puede cerrar
explcitamente un objeto FileOutputStream empleando el mtodo close (cerrar)
como sigue:
salida.close( );
o bien, el archivo se cerrar implcitamente cuando Java recolecte el objeto como
basura.
2.2 LECTURA DE DATOS DE UN ARCHIVO DE ACCESO SECUENCIAL
Los datos se almacenan en archivos con el fin de poderlos recuperar para
procesarlos cuando sea necesario.
Los archivos se abren para entrada creando un objeto FileInputStream. El nombre
del archivo que se desea abrir se pasa como argumento al constructor
FileInputStream. Los datos deben leerse del archivo en el mismo formato en que
se escribieron en l. Por tanto, se usa un DataInputStream encadenado a un
FileInputStream como se muestra a continuacin:
entrada = new DataInputStream(
new FileInputStream("clientes.dat") );
El enunciado anterior crea un objeto DataInputStream llamado entrada asociado el
archivo clientes.dat. El argumento "clientes.dat" se pasa al constructor
FileInputStream que abre el archivo. Esto establece una "lnea de comunicacin"
con el archivo.
Cuando se crea un objeto FileInputStream y se intenta abrir un archivo, es
conveniente manejar la operacin de apertura para controlar si se tuvo xito o no.
Si la operacin falla, se genera un IOException que debe ser atrapado como se
muestra a continuacin:
try {
entrada = new DataInputStream(
new FileInputStream("clientes.dat"));
}
catch (IOException e) {
System.err.println("No se abri bien el archivo\n" +
e.toString() );
System.exit(1);
}
El programa leer un registro cada vez que el usuario haga clic en el botn
"Siguiente". Esta accin har que se invoque el mtodo leerRegistro. Las lneas:
codigo = input.readInt( );
nombre = input.readUTF( );
apellido = input.readUTF( );
saldo = input.readDouble( );
leen un registro de informacin del archivo. Si se llega a la marca de fin de
archivo durante la lectura, se lanza una excepcin de fin de archivo
(EndOfFileException), y sta hace que se asigne false al indicador masRegistros.
Si el usuario intenta leer otro registro haciendo clic en el botn "Siguiente", el
programa terminar.
Despus de ejecutarse por primera vez el cdigo anterior, codigo tiene el
valor 100, nombre (nombre de pila) tiene el valor "Bruno", apellido tiene el valor
"Jara" y saldo tiene el valor 29.48. Cada vez que se ejecuta el cdigo anterior, se
lee otro registro del archivo y se coloca en las variables codigo, nombre, apellido y
saldo. Los registros se exhiben en campos de texto con las siguientes lneas:
cod.setText( String.valueOf (codigo) );
fnombre.setText(String.valueOf(nombre) );
fapellido.setText(StringvalueOf(apellido) ) ;
sal.setText(StringvalueOf(saldo) );
Si el usuario hace clic en el botn "Terminar" (o el indicador masRegistros
es false y el usuario hace clic en "Siguiente"), el archivo se cierra invocando el
mtodo aseo que llama al mtodo close para el objeto DataInputStream entrada.
El programa termina con una llamada al mtodo exit de la clase System.
Para recuperar datos secuencialmente de un archivo, los programas
normalmente comienzan a leer desde el principio del archivo, y leen todos los
datos consecutivamente hasta hallar los datos deseados. Puede ser necesario
procesar el archivo secuencialmente varias veces (desde el principio del archivo)
durante la ejecucin de un programa. Actualmente, Java no cuenta con un mtodo
para reubicar el apuntador a la posicin en el archivo (el nmero de byte del
siguiente byte del archivo que se leer o escribir) en un FileInputStream o un
FileOutputStream para la siguiente operacin de entrada o salida. Por tanto, un
objeto FileOutputStream slo puede reubicarse al principio del archivo cerrando el
archivo y volvindolo a abrir.
Con este programa, se creara un archivo con registros de numero de
matricula, nombre y pedir 3 calificaciones para despus calcular el promedio.
import java.io.*;
import java.util.Scanner;
public class Archivos {
public static void main( String args[] )throws IOException{
Scanner leer = new Scanner(System.in);
DataOutputStream Archi = null;
int i;
int matricula=0;
String nombre=new String();
int calif1;
int calif2;
int calif3;
double promedio;
try{
for (i=0; i<5; i++){
Archi = new DataOutputStream( new FileOutputStream(../Archivo.dat,true)
);
System.out.println(Escribe la matricula: );
matricula = leer.nextInt();
System.out.println(Escribe Nombre: );
nombre = leer.next();
System.out.println(Ingrese Calificacion 1: );
calif1 = leer.nextInt();
System.out.println(Ingrese Califiacin 2);
calif2 = leer.nextInt();
System.out.println(Ingrese Calificacion 3);
calif3 = leer.nextInt();
Archi.writeInt(matricula);
Archi.writeUTF(nombre);
Archi.writeInt(calif1);
Archi.writeInt(calif2);
Archi.writeInt(calif3);
Archi.close();
}
}
catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}
}
}
Este otro mostrara lo que hay en el archivo:
import java.io.*;
public class LeerArchivos{
public static void main( String args[] )throws IOException{
DataInputStream Archi = null;
int matricula=0;
String nombre=new String();
int calif1;
int calif2;
int calif3;
double promedio;
try{
Archi = new DataInputStream( new FileInputStream(../Archivo.dat) );
while (true){
matricula = Archi.readInt();
System.out.println(Matricula: +matricula+ );
nombre = Archi.readUTF();
System.out.println(Nombre: +nombre+ );
calif1= Archi.readInt();
System.out.println(Calificacion 1: +calif1+ );
calif2= Archi.readInt();
System.out.println(Calificacion 2: +calif2+ );
calif3= Archi.readInt();
System.out.println(Calificacion 3: +calif3+ );
System.out.println(n);
int suma = calif1 + calif2 + calif3;
promedio = suma/3;
System.out.println(El promedio es: +promedio+n);
}
}
catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}
Archi.close();
}
}
Archivos Aleatorios
A diferencia de los archivos secuenciales, los archivos aleatorios
almacenan datos en forma de registros. Para leer datos de un archivo aleatorio,
tambin llamados archivos directos, los cuales almacenan los datos con una
estructura diferente. Los datos se guardan en registros mediante una estructura
definida de tipo Type (estructura definida por nosotros) tambin llamada UDT. Por
ejemplo si tuvisemos 25 registros, cada uno con datos (apellido, email, telfono,
etc...), y quisiera acceder al registro 17, puedo leer los datos del registro 17 sin
tener que leer los 16 registros anteriores, ganando con ello ms velocidad y
teniendo una estructura de datos definida. Para abrir un archivo aleatorio para
trabajar con l, se utiliza la sentencia Open con algunos cambios en lo que se
refiere a los archivos secuenciales.
La clase Java RandomAccessFile se utiliza para acceder a un fichero de forma
aleatoria. Los constructores de la clase son:

RandomAccessFile(String path, String modo);
RandomAccessFile(File objetoFile, String modo);

Lanzan una excepcin FileNotFoundException. El argumento modo indica el modo
de acceso en el que se abre el fichero. Los valores permitidos para este parmetro
son:

modo Significado
"r"
Abre el fichero en modo solo lectura.
El fichero debe existir.
Una operacin de escritura en este fichero lanzar una excepcin IOException.
"rw" Abre el fichero en modo lectura y escritura. Si el fichero no existe se crea.

Ejemplo: abrir un fichero aleatorio para lectura
Se abre el fichero clientes.dat para lectura usando el primer constructor.
RandomAccessFile fichero = new RandomAccessFile("/ficheros/clientes.dat", "r");
Ejemplo: abrir un fichero aleatorio para lectura/escritura
Se abre el fichero personas.dat para lectura/escritura usando el segundo
constructor. Si el fichero no existe se crea.
File f = new File ("/ficheros/personas.dat");
RandomAccessFile fichero = new RandomAccessFile(f, "rw");
ACCESO A LOS DATOS EN FICHEROS ALEATORIOS
Para acceder de forma aleatoria a los datos contenidos en el fichero, la
clase RandomAccessFile dispone de varios mtodos. Entre ellos:
long getFilePointer();
Devuelve la posicin actual del puntero del fichero. Indica la posicin (en
bytes) donde se va a leer o escribir.
long length();
Devuelve la longitud del fichero en bytes.
void seek(long pos);
Coloca el puntero del fichero en una posicin pos determinada. La posicin
se da como un desplazamiento en bytes desde el comienzo del fichero. La
posicin 0 indica el principio del fichero. La posicin length() indica el final del
fichero.

Adems dispone de mtodos de lectura/escritura:
public int read()
Devuelve el byte ledo en la posicin marcada por el puntero. Devuelve -1 si
alcanza el final del fichero. Se debe utilizar este mtodo para leer los caracteres
de un fichero de texto.
public final String readLine()
Devuelve la cadena de caracteres que se lee, desde la posicin marcada
por el puntero, hasta el siguiente salto de lnea que se encuentre.
public xxx readXxx()
Hay un mtodo read para cada tipo de dato bsico: readChar, readInt,
readDouble, readBoolean, etc.
public void write(int b)
Escribe en el fichero el byte indicado por parmetro. Se debe utilizar este
mtodo para escribir caracteres en un fichero de texto.
public final void writeBytes(String s)
Escribe en el fichero la cadena de caracteres indicada por parmetro.
public final void writeXxx(argumento)
Tambin existe un mtodo write para cada tipo de dato bsico: writeChar,
writeInt, writeDouble, writeBoolean, etc.
Ejemplo: Programa Java que pide un nmero entero por teclado y lo aade al final
de un fichero binario enteros.dat que contiene nmeros enteros. El programa
utiliza un mtodo mostrarFichero() que se llama dos veces. La primera muestra el
contenido del fichero antes de aadir el nuevo nmero y la segunda llamada
muestra el fichero despus de aadirlo.
package random1;
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Scanner;
public class Random1 {
static Scanner sc = new Scanner(System.in);
static RandomAccessFile fichero = null;
public static void main(String[] args) {
int numero;
try {
//se abre el fichero para lectura y escritura
fichero = new RandomAccessFile("/ficheros/enteros.dat", "rw");
mostrarFichero(); //muestra el contenido original del fichero
System.out.print("Introduce un nmero entero para aadir al final del
fichero: ");
numero = sc.nextInt(); //se lee el entero a aadir en el fichero
fichero.seek(fichero.length()); //nos situamos al final del fichero
fichero.writeInt(numero); //se escribe el entero
mostrarFichero();//muestra el contenido del fichero despus de
aadir el nmero
} catch (FileNotFoundException ex) {
System.out.println(ex.getMessage());
} catch (IOException ex) {
System.out.println(ex.getMessage());
} finally {
try {
if (fichero != null) {
fichero.close();
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
public static void mostrarFichero() {
int n;
try {
fichero.seek(0); //nos situamos al principio
while (true) {
n = fichero.readInt(); //se lee un entero del fichero
System.out.println(n); //se muestra en pantalla
}
} catch (EOFException e) {
System.out.println("Fin de fichero");
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
}










Conclusiones

1) El manejo de archivos (persistencia), es un tema fundamental en
cualquier lenguaje de programacin. Pues nos permite interactuar con
los dispositivos de almacenamiento externo para poder mantener la
informacin en el tiempo.
2) La clase File proporciona muchas utilidades relacionadas con ficheros y
con la obtencin de informacin bsica sobre esos ficheros.
3) Los archivos tambin denominados ficheros son una coleccin de
informacin (datos relacionados entre s), localizada o almacenada
como una unidad en alguna parte de la computadora.
4) Un archivo secuencial es la forma bsica de organizar un conjunto de
registros, que forman un archivo, utilizando una organizacin secuencial.
5) En la mayora de los casos, los registros de un archivo secuencial
quedan ordenados de acuerdo con el valor de algn campo de cada
registro. Puede ordenarse ascendente o descendentemente con base en
su llave de ordenamiento.
6) La forma ms comn de estructura de archivo es el archivo secuencial.
7) Los archivos aleatorios almacenan datos en forma de registros.
8) Para leer datos de un archivo aleatorio, tambin llamados archivos
directos, los cuales almacenan los datos con una estructura diferente.











Bibliografia

http://www.mundote.info/Foro/manuales-y-libros/tutorial-vb6-(manejo-
de-archivos)/?PHPSESSID=a7ee26a74b3f32659865ea628057ca65
http://delfosis.uam.mx/~sgb/Archivos/Excepciones_y_archivos.html
http://www.softwarementors.com/arti/java_io/java_io2.htm
http://www.austral.edu.ar/aplic/webSIA/webSIA2004.nsf/6905fd7e3ce
10eca03256e0b0056c5b9/219ade0b084833860325712000501595/$
FILE/Introducci%C3%B3n%20manejo%20de%20archivos%20en%20
java.htm