[código] Crear un archivo secuencial en Java

Continuando con los ejercicios correspondientes a la manipulación de archivos en Java, vamos a ver un ejemplo en el que crearemos un archivo secuencial, usando la clase ObjectOutputStream.

El resultado…

El código…

Tenemos la clase UIBanco.java, la cual contiene una GUI reutilizable para los ejemplos que vamos a ver más adelante:

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

La clase RegistroCuentas.java 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

Por último, la clase CrearArchivoSecuencial.java, que contiene el método main, es donde hacemos el proceso de escritura de objetos secuencialmente en un archivo, mediante la clase ObjectOutputStream.

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class CrearArchivoSecuencial extends JFrame {
   private ObjectOutputStream salida;
   private IUBanco interfazUsuario;
   private JButton botonIntro, botonAbrir;

   // configurar GUI
   public CrearArchivoSecuencial()
   {
      super( "Creación de un archivo secuencial de objetos" );

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

      // configurar botón hacerTarea1 para usarlo en este programa
      botonAbrir = interfazUsuario.obtenerBotonHacerTarea1();
      botonAbrir.setText( "Guardar en 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() {

            // llamar a abrirArchivo cuando se oprima el botón
            public void actionPerformed( ActionEvent evento )
            {
               abrirArchivo();
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addActionListener

      // configurar botón hacerTarea2 para usarlo en este programa
      botonIntro = interfazUsuario.obtenerBotonHacerTarea2();
      botonIntro.setText( "Introducir" );
      botonIntro.setEnabled( false );  // deshabilitar botón

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

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

            // llamar a agregarRegistro cuando se oprima el botón
            public void actionPerformed( ActionEvent evento )
            {
               agregarRegistro();
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addActionListener

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

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

            // agregar registro actual en la GUI al archivo, después cerrar el archivo
            public void windowClosing( WindowEvent evento )
            {
               if ( salida != null )
                  agregarRegistro();

               cerrarArchivo();
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addWindowListener

      setSize( 350, 180 );
      setVisible( true );

   } // fin del constructor de CrearArchivoSecuencial

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

      int resultado = selectorArchivo.showSaveDialog( this );

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

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

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

      else {

         // abrir archivo
         try {
            salida = new ObjectOutputStream(
               new FileOutputStream( nombreArchivo ) );

            botonAbrir.setEnabled( false );
            botonIntro.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

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

      // procesar excepciones que pueden ocurrir al cerrar 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

   // agregar registro al archivo
   public void agregarRegistro()
   {
      int numeroCuenta = 0;
      RegistroCuentas registro;
      String valoresCampos[] = interfazUsuario.obtenerValoresCampos();

      // si el valor del campo cuenta no está vacío
      if ( ! valoresCampos[ IUBanco.CUENTA ].equals( "" ) ) {

         // escribir valores en el archivo
         try {
            numeroCuenta = Integer.parseInt(
               valoresCampos[ IUBanco.CUENTA ] );

            if ( numeroCuenta > 0 ) {

               // crear nuevo registro
               registro = new RegistroCuentas( numeroCuenta,
                  valoresCampos[ IUBanco.PRIMERNOMBRE ],
                  valoresCampos[ IUBanco.APELLIDO ],
                  Double.parseDouble( valoresCampos[ IUBanco.SALDO ] ) );

               // escribir el registro y vaciar el búfer
               salida.writeObject( registro );
               salida.flush();
            }
            else
            {
                JOptionPane.showMessageDialog( this,
                   "El número de cuenta debe ser mayor que 0",
                   "Número de cuenta incorrecto", JOptionPane.ERROR_MESSAGE );
            }

            // borrar campos de texto
            interfazUsuario.borrarCampos();

         } // fin de bloque try

         // procesar formato inválido de número de cuenta o saldo
         catch ( NumberFormatException excepcionFormato ) {
            JOptionPane.showMessageDialog( this,
               "Número de cuenta o saldo incorrecto", "Formato de número incorrecto",
               JOptionPane.ERROR_MESSAGE );
         }

         // procesar excepciones que pueden ocurrir al escribir en el archivo
         catch ( IOException excepcionES ) {
             JOptionPane.showMessageDialog( this, "Error al escribir en el archivo",
                "Excepción de ES", JOptionPane.ERROR_MESSAGE );
            cerrarArchivo();
         }

      } // fin de instrucción if

   } // fin del método agregarRegistro

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

} // fin de la clase CrearArchivoSecuencial

Descargar código fuente

31 Comentarios | deja el tuyo