- Archivos de acceso aleatorio:

Qu son Archivos?
Los archivos tambin denominados ficheros (file); 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

Archivos Aleatorios
Es aquel en donde los datos se guardan en registros mediante una estructura definida de tipo Type
(estructura definida por nosotros) tambin llamada UDT. Estos permiten acceder a cualquier parte
del fichero en cualquier momento, como si fueran arrays en memoria. Las operaciones de lectura
y/o escritura pueden hacerse en cualquier punto del archivo.

- Creacin (EN JAVA):

Comencemos por crear el fichero, pero primero debemos hacer uso de la clase File, que es la que
nos proporciona informacin acerca del archivo:

/*Creo un objeto File. Recibe como parmetro la ruta completa con el

*nombre del fichero Para los usuarios de Windows la ruta seria
*mas o menos as:"c:\\MiFichero.txt"*/
File Ffichero=new File("/home/luis/Documentos/MiFichero.txt");

La siguiente funcin crea un fichero si no existe y escribe en l una cadena que recibe
como parmetro.
public static void EcribirFichero(File Ffichero,String SCadena){
try {
//Si no Existe el fichero lo crea
if(!Ffichero.exists()){
Ffichero.createNewFile();
}
/*Abre un Flujo de escritura,sobre el fichero con codificacion utf-8.
*Adems en el pedazo de sentencia "FileOutputStream(Ffichero,true)",
*true es por si existe el fichero seguir aadiendo texto y no borrar
lo que tenia*/
BufferedWriter Fescribe=new BufferedWriter(new OutputStreamWriter(new
FileOutputStream(Ffichero,true), "utf-8"));
/*Escribe en el fichero la cadena que recibe la funcin.
*el string "\r\n" significa salto de linea*/
Fescribe.write(SCadena + "\r\n");
//Cierra el flujo de escritura
Fescribe.close();
} catch (Exception ex) {
//Captura un posible error le imprime en pantalla
System.out.println(ex.getMessage());
}
}
Acceso a la Informacin
Los objetos RandomAccessFile esperan informacin de lectura/escritura de la misma manera que
los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read() y write() de las
clases DataInputStream y DataOutputStream .

Tambin se tienen muchos mtodos para moverse dentro de un fichero:

- long getFilePointer();
Devuelve la posicin actual del puntero del fichero

- void seek( long pos );

Coloca el puntero del fichero en una posicin determinada. La posicin se da como un
desplazamiento en bytes desde el comienzo del fichero. La posicin 0 marca el comienzo de ese
fichero.

- long length();
Devuelve la longitud del fichero. La posicin length() marca el final de ese fichero.

- Lectura (EN JAVA)

La siguiente funcin permite leer el contenido de un fichero de texto linea a linea

/*Funcin que lee el contenido de un fichero de texto

*Parmetro:Ffichero. Objeto de la clase file donde se va a leer*/
public static void LeerFichero(File Ffichero){
try {
/*Si existe el fichero*/
if(Ffichero.exists()){
/*Abre un flujo de lectura a el fichero*/
BufferedReader Flee= new BufferedReader(new FileReader(Ffichero));
String Slinea;
System.out.println("**********Leyendo Fichero***********");
/*Lee el fichero linea a linea hasta llegar a la ultima*/
while((Slinea=Flee.readLine())!=null) {
/*Imprime la linea leida*/
System.out.println(Slinea);
}
System.out.println("*********Fin Leer Fichero**********");
/*Cierra el flujo*/
Flee.close();
}else{
System.out.println("Fichero No Existe");
}
} catch (Exception ex) {
/*Captura un posible error y le imprime en pantalla*/
System.out.println(ex.getMessage());
}
}

Escritura de Informacin
Se pueden utilizar ficheros de acceso aleatorio para aadir informacin a ficheros existentes:
 miRAFile = new RandomAccessFile( "/tmp/kk.log","rw" );

miRAFile.seek( miRAFile.length() );

// Cualquier write() que hagamos a partir de este punto del

// cdigo aadir informacin al fichero

Vamos a ver un pequeo ejemplo, Log.java , que aade una cadena a un fichero existente:

import java.io.*;
// Cada vez que ejecutemos este programita,

// se incorporara una nueva

// linea al fichero de log que se crea la primera vez

// que se ejecuta
//
class Log {
public static void main( String args[] ) throws IOException {
RandomAccessFile miRAFile;
String s = "Informacion a incorporarnTutorial de Javan";
// Abrimos el fichero de acceso aleatorio
miRAFile = new RandomAccessFile( "/tmp/java.log","rw" );
// Nos vamos al final del fichero
miRAFile.seek( miRAFile.length() );
// Incorporamos la cadena al fichero
miRAFile.writeBytes( s );
// Cerramos el fichero
miRAFile.close();
}
}

CLAUSURA (EN JABA)

En la forma de detectar que ha llegado al final del archivo. Los mtodos de la
clase RandomAccessFile generan una excepcin, EOFException, para indicar que se ha intentado
llegar fuera del archivo. Por eso, para detectar que se ha terminado de leer se utiliza una variable
finArchivo, que vale false mientras se siga leyendo el archivo. Cuando se genere la
excepcin EOFException, se captura, se cierra el archivo y se pone el valor true en la variable
finArchivo. Al cambiar este valor, termina el bucle de lectura.

Linkcografia:
http://unefaarchivosaleatorios.blogspot.pe/
http://todoelmed.blogspot.pe/2012/05/manejo-de-archivos-o-ficheros-en.html
https://javaparajavatos.wordpress.com/2016/06/08/archivos-de-acceso-aleatorio/