Continuando con el tema de Archivos en Java, en esta entrada veremos un ejemplo simple en el que crearemos un archivo aleatorio. Para tal objetivo, utilizaremos la clase RandomAccessFile.

Los archivos aleatorios son especialmente más útiles que los archivos secuenciales que explicabamos en los ejercicios anteriores, puesto que en los secuenciales, como su nombre lo indica, tanto la lectura como la escritura se hace de manera SECUENCIAL. Por tanto, para buscar un registro en especial, es necesario (si estamos buscando de forma simple, o sea secuencial) buscar registro por registro. Este problema es solucionado con el uso de archivos aleatorios, puesto que tanto la lectura como la escritura de archivos es "directa".

El siguiente ejemplo únicamente crea el archivo secuencial. En otras entradas del blog pondré ejemplos de escritura y lectura (eso si el tiempo me deja). Por el momento, vamos con el programa:

El resultado...

El código...

Tenemos la clase RegistroCuentas.java, es una clase que representa un registro de información:

import java.io.Serializable;
public class RegistroCuentas implements Serializable
{
   private int cuenta;
   private String primerNombre;
   private String apellidoPaterno;
   private double saldo;

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

   // inicializar un registro
   public RegistroCuentas( int cta, String nombre, String apellido, double sald )
   {
      establecerCuenta( cta );
      establecerPrimerNombre( nombre );
      establecerApellidoPaterno( apellido );
      establecerSaldo( sald );
   }

   // establecer número de cuenta
   public void establecerCuenta( int cta )
   {
      cuenta = cta;
   }

   // obtener número de cuenta
   public int obtenerCuenta()
   {
      return cuenta;
   }

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

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

   // establecer apellido paterno
   public void establecerApellidoPaterno( String apellido )
   {
      apellidoPaterno = apellido;
   }

   // obtener apellido paterno
   public String obtenerApellidoPaterno()
   {
      return apellidoPaterno;
   }

   // establecer saldo
   public void establecerSaldo( double sald )
   {
      saldo = sald;
   }

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

} // fin de la clase RegistroCuentas

La clase RegistroCuentasAccesoAleatorio.java hereda de RegistroCuentas.java y proporciona los métodos necesarios para escribir sobre un archivo:

import java.io.*;
public class RegistroCuentasAccesoAleatorio extends RegistroCuentas {

    public static final int TAMANIO = 72;

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

   // inicializar un objeto RegistroCuentasAccesoAleatorio
   public RegistroCuentasAccesoAleatorio( int cuenta, String primerNombre,
      String apellidoPaterno, double saldo )
   {
      super( cuenta, primerNombre, apellidoPaterno, saldo );
   }

   // leer un registro del objeto RandomAccecssFile especificado
   public void leer( RandomAccessFile archivo ) throws IOException
   {
      establecerCuenta( archivo.readInt() );
      establecerPrimerNombre( leerNombre( archivo ) );
      establecerApellidoPaterno( leerNombre( archivo ) );
      establecerSaldo( archivo.readDouble() );
   }

   // asegurarse que el nombre sea de la longitud apropiada
   private String leerNombre( RandomAccessFile archivo ) throws IOException
   {
      char nombre[] = new char[ 15 ], temp;

      for ( int cuenta = 0; cuenta < nombre.length; cuenta++ ) {
         temp = archivo.readChar();
         nombre[ cuenta ] = temp;
      }     

      return new String( nombre ).replace( '\0', ' ' );
   }

   // escribir un registro en el objeto RandomAccessFile especificado
   public void escribir( RandomAccessFile archivo ) throws IOException
   {
      archivo.writeInt( obtenerCuenta() );
      escribirNombre( archivo, obtenerPrimerNombre() );
      escribirNombre( archivo, obtenerApellidoPaterno() );
      archivo.writeDouble( obtenerSaldo() );
   }

   // escribir un nombre en el archivo; máximo 15 caracteres
   private void escribirNombre( 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() );
   }

} // fin de la clase RegistroCuentasAccesoAleatorio

La clase CrearArchivoAleatorio.java, que posee el método main, muestra un cuadro de dialogo que permite al usuario crear el archivo:

import java.io.*;
import javax.swing.*;

public class CrearArchivoAleatorio {

    private static final int NUMERO_REGISTROS = 100;

   // permitir al usuario seleccionar el archivo a abrir
   private void crearArchivo()
   {
      // mostrar cuadro de diálogo para que el usuario pueda seleccionar el archivo
      JFileChooser selectorArchivo = new JFileChooser();
      selectorArchivo.setFileSelectionMode( JFileChooser.FILES_ONLY );

      int resultado = selectorArchivo.showSaveDialog( null );

      // si el usuario hizo clic en el botón Cancelar del cuadro de diálogo, regresar
      if ( resultado == JFileChooser.CANCEL_OPTION )
         return;

      // obtener el archivo seleccionado
      File nombreArchivo = selectorArchivo.getSelectedFile(); 

      // mostrar error si el nombre del archivo es inválido
      if ( nombreArchivo == null || nombreArchivo.getName().equals( "" ) )
         JOptionPane.showMessageDialog( null, "Nombre de archivo incorrecto",
            "Nombre de archivo incorrecto", JOptionPane.ERROR_MESSAGE );

      else {

         // abrir el archivo
         try {
            RandomAccessFile archivo =
               new RandomAccessFile( nombreArchivo, "rw" );

            RegistroCuentasAccesoAleatorio registroEnBlanco =
               new RegistroCuentasAccesoAleatorio();

            // escribir 100 registros en blanco
            for ( int cuenta = 0; cuenta < NUMERO_REGISTROS; cuenta++ )
               registroEnBlanco.escribir( archivo );

            archivo.close(); // cerrar el archivo

            // mostrar mensaje indicando que el archivo se creó
            JOptionPane.showMessageDialog( null, "Se creó el archivo " +
               nombreArchivo, "Estado", JOptionPane.INFORMATION_MESSAGE );

            System.exit( 0 );  // terminar el programa

         } // fin del bloque try

         // procesar excepciones durante operaciones de apertura, escritura o cierre del archivo
         catch ( IOException excepcionES ) {
            JOptionPane.showMessageDialog( null, "Error al procesar el archivo",
               "Error al procesar el archivo", JOptionPane.ERROR_MESSAGE );

            System.exit( 1 );
         }

      } // fin de instrucción else

   } // fin del método crearArchivo

   public static void main( String args[] )
   {
      JDialog.setDefaultLookAndFeelDecorated(true);
      CrearArchivoAleatorio aplicacion = new CrearArchivoAleatorio();
      aplicacion.crearArchivo();
   }   

} // fin de la clase CrearArchivoAleatorio

Descargar código fuente