Manej o de Archi vos aleatorios en JAVA

Eliana Isabel Rangel Ortega

Camilo Jos Amaya Pez




Prof. Folger Fonseca Velasco




Uni versi dad de Crdoba
Facul tad de Cienci as Bsicas e Ingeniera
Ingeniera Industrial
II Semestre
Montera Crdoba
Ao 2008

Tabla de Contenido


Introduccin
Objet ivos
1. Archi vos aleatorios o directos
1.1. Ejemplo
1.2. Creacin de un Ar chivo de Acceso Al eatorio
1.3. Grabar datos en archivos aleatorios
1.4. Leer datos en archivos aleatorios
1.5. Posicionarse en un registro determinado
1.6. Mtodos y constructor es de la clase RandomAccessFile.
2. Ejemplos en java
2.1. // Una cl ase que representa un registro de informacin.
2.2. // Esta clase decl ara mtodos par a manipular los registros de
una cuent a de banco en un ar chivo de acceso al eatorio.
2.3. // Una cl ase (RegistroCuentas) que representa un registro de
informacin.
2.3.1. // Subcl ase de Regi stroCuentas par a los programas que
usan archivos de acceso al eatorio.

Conclusin
Bibliografa






Introduccin


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. File miArchivo; miArchivo = new File( "path/mi_archivo" );
2. iArchivo = new File( "path","mi_archivo" );
3. ile miDirectorio = new File( "path" ); miArchivo = new File(
miDirectorio,"mi_archivo" );

Acceder directamente a la posicin donde se encuentra la informacin (acceso
aleatorio) permite mucha mayor rapidez en la recuperacin de la informacin
que acceder teniendo que leer toda la informacin hasta llegar al lugar donde
se encuentra lo que necesitamos (acceso secuencial), por lo que no puede
haber una librera de entrada/salida que no proporcione esta posibilidad: java.io
incluye la clase RandomAccessFile para este ti po de entrada/salida.




OBJETIVOS


Objet ivos General es
Aprender e identificar nuevos conceptos relaci onados con la temti ca
respectiva a nuestra asignatura.
Conocer y entender temas necesari os para aplicar de manera adecuada
los conceptos vi stos, investigados y desar rollados en la asignatura.
Diferenciar las distintas aplicaciones que podemos utilizar en el
desarrollo de nuestro aprendizaje relacionado a la pr ogramacin.
Desarrollar la conceptuali zacin, manejo y prctica de elementos
utilizados en la programacin para un mejor manejo y entendi miento del
mismo.

Objet ivos Especficos
Identificar la importancia del uso y manej o de archivos aleatorios en toda
su extensi n y especf icamente en j ava.

Aprender a crear correctamente ar chivos aleatorios en java.

Explorar y entender toda la temti ca concerniente a los archivos
aleatorios.

Aprender como es el funcionamiento de los archivos aleatorios.

Aplicar los conceptos y la temti ca aprendida de los archivos aleatorios
en el desarrollo de ejercicios relacionados con el tema.



1. Archivos aleat orios o directos

A diferencia de los archivos secuenci ales, 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.
Ejemplo:
open "elarchivo.dat" for random as #1 l en = len(mivariable)

Como podemos ver para abrir un archivo de acceso al eatorio se utiliza la
palabra Random (aleatorio). Luego debemos i ndicar el nmero de archivo para
identificarlo, y por ltimo una opci n nueva: Len.

Cada registro en el archivo, que es una estructura de datos Type, tiene que
tener una longitud fija. Medi ante la funcin Len de vi sual Basic debemos indicar
el tamao de l a estructura de datos que vamos a ut ilizar.
1.1. Ejemplo:

Primero definimos una estr uctura de datos:

Private Type t_clientes

nombre As String * 20
apellido As Stri ng * 15
direccin As Stri ng * 30
edad As Integer

End Type

Despus creamos una var iable llamada cli entes de tipo t_clientes

Dim clientes As t_cli entes

ahora abrimos nuestro archivo, y en el parmetro de la funci n Len le
pasamos l a variable para que visual basic calcul e el tamao de la
estructura t_clientes

Open "datos.dat" For Random As #1 Len = Len( clientes)

La estructura de datos debe tener un tamao fi jo, no datos vari ables
como en el caso de los ar chivos secuencial es, de ah que se indicara en
el Type en las variabl es mediante el asteri sco en el caso de los String.

En cada campo de l a estructura de datos debemos i ndicar el tamao de
la variable. En el caso del campo nombre de tipo string le hemos
asignado una longitud fija de 20 byt es, en el apelli do 15 y en la direccin
30 bytes. La vari able o el campo edad que es de tipo integer, no
debemos i ndicar el tamao de l a variable, ya que sabemos que un
nmero integer ocupa 2 byt es.

En total esta estr uctura t_clientes tiene una longitud de 67 bytes (30 + 20
+ 15 + 2).

Si no indicramos en l a sentenci a Open el tamao de l a estructur a,
visual basic, por defecto asumira la estructura de un t amao de 128
bytes, y si nuestra estructura tendra mayor tamao ocur rira un error en
tiempo de ejecucin, por lo cual siempre debemos uti lizar la funcin len
para calcular el tamao de la misma.

1.2. Creacin de un Archi vo de Acceso Aleat orio
Hay dos posibilidades para abrir un archivo de acceso al eatorio:
Con el nombr e del archivo: miRAFile = new RandomAccessF ile( String
nombre,String modo ).
Con un obj eto File: miRAFile = new RandomAccessFi le( File
archivo,String modo ).


1.3. Grabar datos en archivos aleatorios
Para grabar datos en un archivo de acceso aleatori o se utiliza la sentenci a Put.
Ejemplo:

primero declaramos una estructura de datos que contendr la informacin de
cada registro:

Private Type t_empleados
nombre As String * 15
apellido As Stri ng * 15
direccin As Stri ng * 30
edad As Integer
End Type

Luego creamos una vari able que sea de tipo t_empleados.

Dim empleados As t_empl eados

Ahora abrimos el archivo e indicamos en l a funcin Len el tamao de l a
estructura

Open "datos.dat" For Random As #1 Len = Len( clientes)
Ahora le asignamos un val or a cada campo de l a estructura de esta forma:

empleados.nombr e = "Carlos"
empleados.apelli do = "Martinez"
empleados.di reccin = "Avenida 9 de julio n 2054"
empleados.edad = 45

Ahora grabamos en el registro n1 del ar chivo los datos de esta f orma:

Put #1, 1, empl eados

Si queremos grabar ms datos, por ej emplo en el registro n 2 del archivo
hacemos l o siguiente:

empleados.nombr e = "Mara"
empleados.apelli do = "Gonzal es"
empleados.di reccin = "Avenida 13 n 1100"
empleados.edad = 35

Put #1, 2, empl eados
Close #1
Como vemos ver la sentencia Put lleva 3 parmetros. El primero indica el
nmero de archivo abierto en el cual estamos trabajando. En el segundo
debemos indicar el nmero de registro en el que se grabarn los datos. Si no
ponemos el nmero de registro, los datos se grabarn en el ltimo registro. Por
ltimo en el tercer parmetro le pasamos la variable asociada con la estructura
de datos.




1.4. Leer datos en archivos aleat orios

Para leer los registros o datos de un ar chivo aleatorio se utiliza la sentencia
Get. Esta sentenci a es exactamente i gual que Put, per o la diferencia es que en
vez de grabar los datos los recupera para poder utilizarlos luego en el
programa.

1.5. Posicionarse en un regist ro determinado

Supongamos que tenemos un ar chivo aleatorio que contiene 452 r egistros.
Ahora queremos recuperar los datos del registro 258. Para posicionarse en un
determinado registro hay una sentencia, hay una sentencia llamada Seek.
Ejemplo:

Seek #1, 258
Get #1, mivariable

si queremos posi cionarnos en un registro determinado, pero en vez de leer,
queremos grabar datos, hacemos l a misma operacin pero con la sentenci a
Put:

Seek #1, 258
Put #1, , mi variable

1.6. Mtodos y constructores de la clase RandomAccessFile.
public class java.io.RandomAccessFile
extends java.lang.Object
implements java.io.DataOutput,
java.io.DataInput
{
// Constructorrs
public RandomAccessFile(File archivo, String modo);
public RandomAccessFile(String nombre, String modo);

// Mtodos
public void seek(long pos);
public long length();
public long getFilePointer();
public int skipBytes(int n);

public void close();
public final FileDescriptor getFD();
public int read();
public int read(byte b[]);
public int read(byte b[], int off, int len);
public void write(byte b[]);
public void write(byte b[], int off, int len);
public void write(int b);
public final boolean readBoolean();
public final byte readByte();
public final char readChar();
public final double readDouble();
public final float readFloat();
public final void readFully(byte b[]);
public final void readFully(byte b[],
int off, int len);
public final int readInt();
public final String readLine();
public final long readLong();
public final short readShort();
public final int readUnsignedByte();
public final int readUnsignedShort();
public final String readUTF();
public final void writeBoolean(boolean v);
public final void writeByte(int v);
public final void writeBytes(String s);
public final void writeChar(int v);
public final void writeChars(String s);
public final void writeDouble(double v);
public final void writeFloat(float v);
public final void writeInt(int v);
public final void writeLong(long v);
public final void writeShort(int v);
public final void writeUTF(String str);
}
Como se pude ver, se puede indicar el archivo sobre el que vamos a
trabajar basndonos en un objeto File ya existente (primera versin del
constructor en el Listado anterior), o especificando directamente el
nombre del archivo (segunda versin del constructor). Adems, es
posible indicar si deseamos abrir el archivo para lectura, o bien para
lectura y escritura, lo que se hace pasando como segundo ar gumento de
ambos constructores la cadena "r" o "rw", respectivamente. Lo que
realmente distingue el acceso aleatorio es la posibilidad de movernos a
cualquier posicin dentro del archivo: para ello utilizamos el mtodo
seek, que nos lleva a la posicin que especifiquemos, length, que nos
devuelve la longitud del archivo, lo que nos permite saber hasta dnde
podemos llegar movindonos por l, y getFilePointer, que nos devuelve
la posicin donde nos hallamos en un momento dado. Como
conveni encia contamos tambin con el mtodo skipBytes, que nos
permite saltarnos un nmero determinado de bytes desde la posicin
donde nos hallemos. En cuanto al resto de los mtodos, son los que se
podran esperar: las diversas versiones de read y writ e permiten leer y
escribir uno o ms bytes, y funcionan del mismo modo que lo hacan
para las clases InputStream y OutputStr eam. Adems, tambin hay un
mtodo close para cerrar el archivo cuando terminemos de trabajar con
l. Tambin hay un gran nmero de mtodos con nombres como
readDouble, readInt, writ eDouble, writ eInt, etc., que sirven para leer y
escribir de forma portable los diversos tipos de datos predefinidos.
Recurdese que las clases InputDataStr eam y OutputDataStr eam tenan
mtodos con el mismo nombre y el mismo propsi to.
2. Ejemplos en java:
2.1. // Una clase q ue represent a un regist ro de informacin.
import java.io.Serializable;
public class Regi stroCuentas implements Serializable
{
private int cuenta;
private String primerNombre;
private String apelli doPaterno;
private double saldo;

// El constructor sin argumentos llama al otro constructor con
valores predeterminados
public RegistroCuentas()
{
this( 0, "", "", 0.0 );
}

// Inicializar un reg ist ro
public RegistroCuentas( int cta, Stri ng nombre, String apelli do, double sald
)
{
establecerCuenta( cta );
establecerPrimerNombre( nombre );
establecerApellidoPaterno( apelli do );
establecerSaldo( sald );
}
// Est ablecer nmero de cuent a
public void establecerCuenta( int cta )
{
cuenta = cta;
}
// Obtener nmero de cuent a
public int obtenerCuenta()
{
return cuenta;
}
// Est ablecer primer nombre
public void establecerPrimerNombre( String nombre )
{
primerNombre = nombre;
}
// Obt ener primer nombre
public String obtenerPrimerNombre()
{
return primerNombre;
}
// Est ablecer apelli do paterno
public void establecerApellidoPaterno( String apellido )
{
apellidoPaterno = apelli do;
}
// Obt ener apelli do paterno
public String obtenerApellidoPaterno()
{
return apellidoPaterno;
}
// Est ablecer sal do
public void establecerSaldo( double sald )
{
saldo = sal d;
}
// Obtener saldo
public double obtenerSaldo()
{
return saldo;
}
} // Fin de la cl ase Regist roCuent as

2.2. // Esta clase d eclara mt odos para manipular los regist ros de una
cuent a de banco en un archi vo de acceso aleatorio.
import java.io.*;
public class Editor Archivo {
RandomAccessFile archivo; // referencia al archiv
// Abrir el archi vo
public EditorArchivo( File nombreArchivo ) throws IOExcepti on
{
archivo = new RandomAccessFile( nombreArchivo, "rw" );
}
// Cerrar el archivo
public void cerrarArchivo() throws IOExcepti on
{
if ( archivo != null )
archivo.close();
}
// Obt ener un regist ro del archivo
public RegistroCuentasAccesoAl eatorio obtenerRegistro( int
numeroCuenta )
throws IllegalArgumentException, NumberFormatException, IOExcepti on
{
RegistroCuentasAccesoAl eatorio registro = new
RegistroCuentasAccesoAl eatorio();
if ( numeroCuenta < 1 | | numeroCuenta > 100 )
throw new Il legalArgumentExcepti on( "Fuera de rango" );
// Buscar regist ro apropiado en el archivo
archivo.seek( ( numeroCuenta - 1 ) *
RegistroCuentasAccesoAl eatorio.TAMANIO );
registro.leer( archivo );
return registro; }
// Fin del mt odo obtenerRegist ro
// Act ualizar regist ro en el archivo
public void actualizarRegistro( int numeroCuenta, Stri ng primerNombre,
String apellidoPaterno, doubl e saldo )
throws IllegalArgumentExcepti on, IOExcepti on
{
RegistroCuentasAccesoAl eatorio registro = obtener Registro(
numeroCuenta ) ;
if ( numeroCuenta == 0 )
throw new Il legalArgumentExcepti on( "La cuenta no existe" );
// Buscar regist ro apropiado en el archivo
archivo.seek( ( numeroCuenta - 1 ) *
RegistroCuentasAccesoAl eatorio.TAMANIO );

registro = new Regi stroCuentasAccesoAl eatorio( numeroCuenta,
primerNombre, apelli doPaterno, saldo );
registro.escribir( archivo ); // escribir registro act ualizado en el
archivo
} // Fin del mt odo act ualizarRegistro
// Agregar regist ro al archivo
public void nuevoRegi stro( int numeroCuenta, String primerNombre,
String apellidoPaterno, doubl e saldo )
throws IllegalArgumentExcepti on, IOException
{
RegistroCuentasAccesoAl eatorio registro = obtener Registro(
numeroCuenta ) ;
if ( registro.obtenerCuenta() != 0 )
throw new Il legalArgumentExcepti on( "La cuenta ya exi ste" );
// Buscar regist ro apropiado en el archivo
archivo.seek( ( numeroCuenta - 1 ) *
RegistroCuentasAccesoAl eatorio.TAMANIO );
registro = new Regi stroCuentasAccesoAl eatorio( numeroCuenta,
primerNombre, apelli doPaterno, saldo );
registro.escribir( archivo ); // escribir reg ist ro en el archivo
} // Fin del mtodo nuevoRegist ro
// Eliminar regist ro del archivo
public void eliminarRegistro( int numeroCuenta )
throws IllegalArgumentExcepti on, IOExcepti on
{
RegistroCuentasAccesoAl eatorio registro = obtener Registro(
numeroCuenta ) ;

if ( registro.obtenerCuenta() == 0 )
throw new Il legalArgumentExcepti on( "La cuenta no existe" );
// Buscar regist ro apropiado en el archi vo
archivo.seek( ( numeroCuenta - 1 ) *
RegistroCuentasAccesoAl eatorio.TAMANIO );
// crear un registro en blanco para escribir en el archivo
registro = new Regi stroCuentasAccesoAl eatorio();
registro.escribir( archivo );
} // Fin del mt odo eliminarRegist ro
} // Fin de la cl ase EditorArchi vo

2.3. // Una clase q ue represent a un regist ro de informacin.

import java.io.Serializable;
public class Regi stroCuentas implements Serializable
{
private int cuenta;
private String primerNombre;
private String apelli doPaterno;
private double saldo;

// el constructor sin argument os llama al otro constructor con valores
predeterminados
public RegistroCuentas()
{
this( 0, "", "", 0.0 );
}

// Inicializar un regist ro
public RegistroCuentas( int cta, String nombre, String apellido, doubl e sald )
{
establecerCuenta( cta );
establecerPrimerNombre( nombre );
establecerApellidoPaterno( apelli do );
establecerSaldo( sald );
}

// Establecer nmero de cuent a
public void establecerCuenta( int cta )
{
cuenta = cta;
}

// Obtener nmero de cuent a
public int obtenerCuenta()
{
return cuenta;
}

// Establecer primer nombre
public void establecerPrimerNombre( String nombre )
{
primerNombre = nombre;
}

// Obtener primer nombre
public String obtenerPrimerNombre()
{
return primerNombre;
}

// Establecer apelli do paterno
public void establecerApellidoPaterno( String apellido )
{
apellidoPaterno = apelli do;
}

// Obtener apelli do paterno
public String obtenerApellidoPaterno()
{
return apellidoPaterno;
}

// Establecer saldo
public void establecerSaldo( double sald )
{
saldo = sal d;
}

// obtener saldo
public double obtenerSaldo()
{
return saldo;
}

} // Fin de la cl ase RegistroCuent as

2.3.1. // Subclase de Regist roCuent as para los programas que usan
archivos de acceso aleat orio.
import java.io.*;
public class Regi stroCuentasAccesoAl eatorio extends Regi stroCuentas {
public static final int TAMANIO = 72;

// El constructor sin argument os llama al otro constructor con los valores
predeterminados
public RegistroCuentasAccesoAl eatorio()
{
this( 0, "", "", 0.0 );
}
// Inicializar un o bjet o Regist roCuent asAccesoAleat orio
public RegistroCuentasAccesoAl eatorio( int cuenta, String primerNombre,
String apellidoPaterno, doubl e saldo )
{
super( cuenta, pri merNombre, apelli doPaterno, saldo );
}
// Leer un regist ro del objeto RandomAccecssFile especificado
public void leer( RandomAccessFile archivo ) throws IOExcepti on
{
establecerCuenta( archivo.readInt() );
establecerPrimerNombre( leerNombre( archivo ) );
establecerApellidoPaterno( leerNombre( archivo ) );
establecerSaldo( archivo.readDoubl e() );
}
// Asegurarse que el nombre sea de la l ongitud apropiada
private String leerNombre( RandomAccessFile archivo ) throws IOExcepti on
{
char nombre[] = new char [ 15 ], temp;
for ( int cuenta = 0; cuenta < nombr e.length; cuenta++ ) {
temp = archivo.readChar();
nombre[ cuenta ] = temp;
}
return new String( nombre ).replace( '\0', ' ' );
}
// Escribir un regist ro en el objeto RandomAccessFile especificado
public void escribir( RandomAccessFile archivo ) throws IOExcepti on
{
archivo.writeInt( obtenerCuenta() );
escribirNombre( archivo, obtenerPrimerNombre() );
escribirNombre( archivo, obtenerApellidoPaterno() );
archivo.writeDouble( obtenerSaldo() );
}
// Escribir un nombre en el archi vo; mximo 15 caracteres
private void escri birNombre( RandomAccessFile archivo, String nombre )
throws IOException
{
StringBuffer bufer = null;
if ( nombre != null )
bufer = new StringBuffer( nombre );
else
bufer = new StringBuffer( 15 );
bufer.setLength( 15 );
archivo.writeChars( bufer.toString() );
}


Conclusin

En la anterior investigacin desarrollamos una temtica de gran importancia,
que nos permite hacer ms extenso nuestro conocimiento para el uso y
manejo de aplicaciones en java, establecimos que son los archivos aleatorios,
como su funcionan y algunos ejemplos. Esto nos permiti aprender una nueva
forma de utilizacin y aprovechamiento de java, al igual que resaltar algo
importante:
Lo que realmente distingue el acceso aleatorio es la posibilidad de
movernos a cualquier posicin dentro del archivo: para ello utilizamos el
mtodo seek, que nos lleva a la posicin que especifiquemos, length, que
nos devuelve la longitud del archivo, lo que nos permite saber hasta dnde
podemos llegar movindonos por l, y getFilePointer, que nos devuelve la
posicin donde nos hal lamos en un momento dado.
La clase File s es ms til: un detalle importante a tener en cuenta es que
esta clase no sol o representa archivos, sino tambin directorios.
Con la investigacin y consecuci n de este trabajo nuestro grupo resalta la
importancia que tiene en el desarrollo de la vida empresarial y vanguardista el
conocer el manejo y utilizacin de la programacin en java, ya que esta
herramienta nos permite ser ms eficaces y competitivos en un mundo tan
evolucionado como el de hoy, creando aplicaciones que mejoran nuestro estilo
de trabajo.



Bibliografa


http://www.mundote.info/Foro/manuales-y-libros/tutorial-vb6-(manejo-de-
archivos)/?PHPSESSID=a7ee26a74b3f32659865ea628057ca65
http://del fosis.uam.mx/~sgb/Archivos/Excepciones_y_ar chivos.html
http://www.soft warementors.com/arti/java_i o/java_io2.htm
C:\Documents and Setti ngs\Administrador\Escritorio\Manejo de Archivos en
Java.htm