Para el próximo ejemplo, en el que aprenderemos a leer archivos secuencialmente en Java, usando la clase ObjectInputStream, es necesario haber leído y ejecutado el programa del ejemplo pasado (en donde aprendimos a crear archivos secuenciales con la clase ObjectOutputStream).

El resultado...

El código...

Utilizamos la clase UIBanco.java, que es la misma del ejemplo anterior:

import java.awt.*;
import javax.swing.*;
public class IUBanco extends JPanel
{
	// texto de las etiquetas para la GUI
	protected final static String nombres[] = { "Número de cuenta",
      "Primer nombre", "Apellido", "Saldo", "Monto de la transacción" };

   // componentes de GUI; protegidos para el acceso futuro de las subclases
   protected JLabel etiquetas[];
   protected JTextField campos[];
   protected JButton hacerTarea1, hacerTarea2;
   protected JPanel panelInternoCentro, panelInternoSur;

   protected int tamanio; // número de campos de texto en la GUI

   // constantes que representan a los campos de texto en la GUI
   public static final int CUENTA = 0, PRIMERNOMBRE = 1, APELLIDO = 2,
      SALDO = 3, TRANSACCION = 4;

   // Configurar GUI. El argumento miTamanio del constructor determina el número de
   // filas de componentes de GUI.
   public IUBanco( int miTamanio )
   {
      tamanio = miTamanio;
      etiquetas = new JLabel[ tamanio ];
      campos = new JTextField[ tamanio ];

      // crear etiquetas
      for ( int cuenta = 0; cuenta < etiquetas.length; cuenta++ )
         etiquetas[ cuenta ] = new JLabel( nombres[ cuenta ] );

      // crear campos de texto
      for ( int cuenta = 0; cuenta < campos.length; cuenta++ )
         campos[ cuenta ] = new JTextField();

      // crear panel para distribuir etiquetas y campos
      panelInternoCentro = new JPanel();
      panelInternoCentro.setLayout( new GridLayout( tamanio, 2 ) );

      // adjuntar etiquetas y campos a panelInternoCentro
      for ( int cuenta = 0; cuenta < tamanio; cuenta++ ) {
         panelInternoCentro.add( etiquetas[ cuenta ] );
         panelInternoCentro.add( campos[ cuenta ] );
      }

      // crear botones genéricos; sin etiquetas ni manejadores de eventos
      hacerTarea1 = new JButton();
      hacerTarea2 = new JButton(); 

      // crear panel para distribuir los botones y adjuntarlos
      panelInternoSur = new JPanel();
      panelInternoSur.add( hacerTarea1 );
      panelInternoSur.add( hacerTarea2 );

      // establecer esquema de este contenedor y adjuntarle los paneles
      setLayout( new BorderLayout() );
      add( panelInternoCentro, BorderLayout.CENTER );
      add( panelInternoSur, BorderLayout.SOUTH );

      validate(); // validar esquema 

   } // fin del constructor

   // devolver referencia al botón de tarea genérico hacerTarea1
   public JButton obtenerBotonHacerTarea1()
   {
      return hacerTarea1;
   }

   // devolver referencia al botón de tarea genérico hacerTarea2
   public JButton obtenerBotonHacerTarea2()
   {
      return hacerTarea2;
   }

   // devolver referencia al arreglo campos de objetos JTextField
   public JTextField[] obtenerCampos()
   {
      return campos;
   }

   // borrar el contenido de los campos de texto
   public void borrarCampos()
   {
      for ( int cuenta = 0; cuenta < tamanio; cuenta++ )
         campos[ cuenta ].setText( "" );
   }

   // establecer valores de los campos de texto; lanzar IllegalArgumentException si
   // hay un número incorrecto de objetos String en el argumento
   public void establecerValoresCampos( String cadenas[] )
      throws IllegalArgumentException
   {
      if ( cadenas.length != tamanio )
         throw new IllegalArgumentException( "Debe haber " +
            tamanio + " objetos String en el arreglo" );

      for ( int cuenta = 0; cuenta < tamanio; cuenta++ )
         campos[ cuenta ].setText( cadenas[ cuenta ] );
   }

   // obtener arreglo de objetos String con el contenido actual de los campos de texto
   public String[] obtenerValoresCampos()
   {
      String valores[] = new String[ tamanio ];

      for ( int cuenta = 0; cuenta < tamanio; cuenta++ )
         valores[ cuenta ] = campos[ cuenta ].getText();

      return valores;
   }

} // fin de la clase IUBanco

También la clase RegistroCuentas.java, que es la misma del ejemplo anterior:

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

Y la clase que contiene el método main que es LeerArchivoSecuencial.java, en donde se hace uso de la clase ObjectInputStream, para leer de un archivo objetos en forma secuencial.

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class LeerArchivoSecuencial extends JFrame
{
   private ObjectInputStream entrada;
   private IUBanco interfazUsuario;
   private JButton botonSiguiente, botonAbrir;

   // Constructor -- inicializar el marco
   public LeerArchivoSecuencial()
   {
      super( "Leer un archivo secuencial de objetos" );

      // crear instancia de la interfaz de usuario reutilizable
      interfazUsuario = new IUBanco( 4 );  // cuatro campos de texto
      getContentPane().add( interfazUsuario, BorderLayout.CENTER );

      // obtener referencia al botón de tarea genérico hacerTarea1 de IUBanco
      botonAbrir = interfazUsuario.obtenerBotonHacerTarea1();
      botonAbrir.setText( "Abrir archivo" );

      // registrar componente de escucha para llamar a abrirArchivo cuando se oprima el botón
      botonAbrir.addActionListener(

         // clase interna anónima para manejar evento de botonAbrir
         new ActionListener() {

            // cerrar archivo y terminar la aplicación
            public void actionPerformed( ActionEvent evento )
            {
               abrirArchivo();
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addActionListener

      // registrar componente de escucha de ventana para evento de cierre de ventana
      addWindowListener(

         // clase interna anónima para manejar evento windowClosing
         new WindowAdapter() {

            // cerrar el archivo y terminar la aplicación
            public void windowClosing( WindowEvent evento )
            {
               if ( entrada != null )
                  cerrarArchivo();

               System.exit( 0 );
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addWindowListener

      // obtener referencia al botón de tarea genérico hacerTarea2 de IUBanco
      botonSiguiente = interfazUsuario.obtenerBotonHacerTarea2();
      botonSiguiente.setText( "Siguiente registro" );
      botonSiguiente.setEnabled( false );  

      // registrar componente de escucha para llamar a leerRegistro cuando se oprima el botón
      botonSiguiente.addActionListener(

         // clase interna anónima para manejar evento de siguienteRegistro
         new ActionListener() {

            // llamar a leerRegistro cuando el usuario haga clic en siguienteRegistro
            public void actionPerformed( ActionEvent evento )
            {
               leerRegistro();
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addActionListener

      pack();
      setSize( 350, 170 );
      setVisible( true );

   } // fin del constructor de LeerArchivoSecuencial

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

      int resultado = selectorArchivo.showOpenDialog( this );

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

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

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

      else {

         // abrir archivo
         try {
            entrada = new ObjectInputStream(
               new FileInputStream( nombreArchivo ) );

            botonAbrir.setEnabled( false );
            botonSiguiente.setEnabled( true );
         }

         // procesar excepciones que pueden ocurrir al abrir el archivo
         catch ( IOException excepcionES ) {
            JOptionPane.showMessageDialog( this, "Error al abrir el archivo",
               "Error", JOptionPane.ERROR_MESSAGE );
         }      

      } // fin de instrucción else

   } // fin del método abrirArchivo

   // leer registro del archivo
   public void leerRegistro()
   {
      RegistroCuentas registro;

      // leer los valores del archivo
      try {
         registro = ( RegistroCuentas ) entrada.readObject();

         // crear arreglo de objetos String a mostrar en la GUI
         String valores[] = { String.valueOf( registro.obtenerCuenta() ),
            registro.obtenerPrimerNombre(), registro.obtenerApellidoPaterno(),
            String.valueOf( registro.obtenerSaldo() ) };

         // mostrar contenido del registro
         interfazUsuario.establecerValoresCampos( valores );
      }

      // mostrar mensaje al llegar al fin del archivo
      catch ( EOFException excepcionFinDeArchivo ) {
         botonSiguiente.setEnabled( false );

         JOptionPane.showMessageDialog( this, "No hay más registros en el archivo",
            "Fin del archivo", JOptionPane.ERROR_MESSAGE );
      }

      // mostrar mensaje de error si no se encuentra la clase
      catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
         JOptionPane.showMessageDialog( this, "No se pudo crear el objeto",
            "Clase no encontrada", JOptionPane.ERROR_MESSAGE );
      }

      // mostrar mensaje de error si no se puede leer debido a un problema con el archivo
      catch ( IOException excepcionES ) {
         JOptionPane.showMessageDialog( this,
            "Error al leer del archivo",
            "Error de lectura", JOptionPane.ERROR_MESSAGE );
      }

   } // fin del método leerRegistro

   // cerrar archivo y terminar la aplicación
   private void cerrarArchivo()
   {
      // cerrar archivo y salir
      try {
         entrada.close();
         System.exit( 0 );
      }

      // procesar excepción que puede ocurrir mientras se cierra el archivo
      catch ( IOException excepcionES ) {
         JOptionPane.showMessageDialog( this, "Error al cerrar el archivo",
            "Error", JOptionPane.ERROR_MESSAGE );

         System.exit( 1 );
      }

   } // fin del método cerrarArchivo

   public static void main( String args[] )
   {
      JFrame.setDefaultLookAndFeelDecorated(true);
      JDialog.setDefaultLookAndFeelDecorated(true);
      new LeerArchivoSecuencial();
   }

} // fin de la clase LeerArchivoSecuencial

Descargar código fuente