Fig. 14.11: LeerArchivoTexto.java

// Este programa lee un archivo de texto y muestra cada registro.
import java.io.File;
import java.io.FileNotFoundException;
import java.lang.IllegalStateException;
import java.util.NoSuchElementException;
import java.util.Scanner;

import com.deitel.jhtp7.cap14.RegistroCuenta;

public class LeerArchivoTexto
{
private Scanner entrada;

// permite al usuario abrir el archivo
public void abrirArchivo()
{
try
{
entrada = new Scanner( new File( "clientes.txt" ) );
} // fin de try
catch ( FileNotFoundException fileNotFoundException )
{
System.err.println( "Error al abrir el archivo." );
System.exit( 1 );
} // fin de catch
} // fin del método abrirArchivo

// lee registro del archivo
public void leerRegistros()
{
// objeto que se va a escribir en la pantalla
RegistroCuenta registro = new RegistroCuenta();

System.out.printf( "%-9s%-15s%-18s%10s\n", "Cuenta",
"Primer nombre", "Apellido paterno", "Saldo" );

try // lee registros del archivo, usando el objeto Scanner
{
while ( entrada.hasNext() )
{
registro.establecerCuenta( entrada.nextInt() ); // lee el número de cuenta
registro.establecerPrimerNombre( entrada.next() ); // lee el primer nombre
registro.establecerApellidoPaterno( entrada.next() ); // lee el apellido paterno
registro.establecerSaldo( entrada.nextDouble() ); // lee el saldo

// muestra el contenido del registro
System.out.printf( "%-9d%-15s%-18s%10.2f\n",
registro.obtenerCuenta(), registro.obtenerPrimerNombre(),
registro.obtenerApellidoPaterno(), registro.obtenerSaldo() );
} // fin de while
} // fin de try
catch ( NoSuchElementException elementException )
{
System.err.println( "El archivo no esta bien formado." );
entrada.close();
System.exit( 1 );
} // fin de catch
catch ( IllegalStateException stateException )
{
System.err.println( "Error al leer del archivo." );
System.exit( 1 );
} // fin de catch
} // fin del método leerRegistros

// cierra el archivo y termina la aplicación
public void cerrarArchivo()
{
if ( entrada != null )
entrada.close(); // cierra el archivo
} // fin del método cerrarArchivo
} // fin de la clase LeerArchivoTexto

Fig. 14.12: PruebaLeerArchivoTexto.java

// Este programa prueba la clase LeerArchivoTexto.

public class PruebaLeerArchivoTexto
{
public static void main( String args[] )
{
LeerArchivoTexto aplicacion = new LeerArchivoTexto();

aplicacion.abrirArchivo();
aplicacion.leerRegistros();
aplicacion.cerrarArchivo();
} // fin de main
} // fin de la clase PruebaLeerArchivoTexto

Cuenta---Primer nombre----Apellido paterno---Saldo

100------------Bob-----------------Jones----------------24.98

200----------Steve-----------------Doe-----------------345.67

300-----------Pam-----------------White----------------0.00

400-----------Sam-----------------Stone----------------46.16

500-----------Sue------------------Rich----------------224.62

Fig. 14.13: OpcionMenu.java

// Define un tipo enum para las opciones del programa de consulta de crédito.

public enum OpcionMenu
{
// declara el contenido del tipo enum
SALDO_CERO( 1 ),
SALDO_CREDITO( 2 ),
SALDO_DEBITO( 3 ),
FIN( 4 );

private final int valor; // opción actual del menú

OpcionMenu( int valorOpcion )
{
valor = valorOpcion;
} // fin del constructor del tipo enum OpcionMenu

public int obtenerValor()
{
return valor;
} // fin del método obtenerValor
} // fin del tipo enum OpcionMenu

Fig. 14.14: ConsultaCredito.java

// Este programa lee un archivo secuencialmente y muestra su
// contenido con base en el tipo de cuenta que solicita el usuario
// (saldo con crédito, saldo con débito o saldo de cero).
import java.io.File;
import java.io.FileNotFoundException;
import java.lang.IllegalStateException;
import java.util.NoSuchElementException;
import java.util.Scanner;

import com.deitel.jhtp7.cap14.RegistroCuenta;

public class ConsultaCredito
{
private OpcionMenu tipoCuenta;
private Scanner entrada;
private OpcionMenu opciones[] = { OpcionMenu.SALDO_CERO,
OpcionMenu.SALDO_CREDITO, OpcionMenu.SALDO_DEBITO,
OpcionMenu.FIN };

// lee los registros del archivo y muestra sólo los registros del tipo apropiado
private void leerRegistros()
{
// objeto que se va a escribir en el archivo
RegistroCuenta registro = new RegistroCuenta();

try // lee registros
{
// abre el archivo para leer desde el principio
entrada = new Scanner( new File( "clientes.txt" ) );

while ( entrada.hasNext() ) // recibe los valores del archivo
{
registro.establecerCuenta( entrada.nextInt() ); // lee número de cuenta
registro.establecerPrimerNombre( entrada.next() ); // lee primer nombre
registro.establecerApellidoPaterno( entrada.next() ); // lee apellido paterno
registro.establecerSaldo( entrada.nextDouble() ); // lee saldo

// si el tipo de cuenta es apropiado, muestra el registro
if ( debeMostrar( registro.obtenerSaldo() ) )
System.out.printf( "%-10d%-12s%-12s%10.2f\n",
registro.obtenerCuenta(), registro.obtenerPrimerNombre(),
registro.obtenerApellidoPaterno(), registro.obtenerSaldo() );
} // fin de while
} // fin de try
catch ( NoSuchElementException elementException )
{
System.err.println( "El archivo no esta bien formado." );
entrada.close();
System.exit( 1 );
} // fin de catch
catch ( IllegalStateException stateException )
{
System.err.println( "Error al leer del archivo." );
System.exit( 1 );
} // fin de catch
catch ( FileNotFoundException fileNotFoundException )
{
System.err.println( "No se puede encontrar el archivo." );
System.exit( 1 );
} // fin de catch
finally
{
if ( entrada != null )
entrada.close(); // cierra el objeto Scanner y el archivo
} // fin de finally
} // fin del método leerRegistros

// usa el tipo de registro para determinar si el registro debe mostrarse
private boolean debeMostrar( double saldo )
{
if ( ( tipoCuenta == OpcionMenu.SALDO_CREDITO )
&& ( saldo < 0 ) )
return true;

else if ( ( tipoCuenta == OpcionMenu.SALDO_DEBITO )
&& ( saldo > 0 ) )
return true;

else if ( ( tipoCuenta == OpcionMenu.SALDO_CERO )
&& ( saldo == 0 ) )
return true;

return false;
} // fin del método debeMostrar

// obtiene solicitud del usuario
private OpcionMenu obtenerSolicitud()
{
Scanner textoEnt = new Scanner( System.in );
int solicitud = 1;

// muestra opciones de solicitud
System.out.printf( "\n%s\n%s\n%s\n%s\n%s\n",
"Escriba solicitud", " 1 - Lista de cuentas con saldos de cero",
" 2 - Lista de cuentas con saldos con credito",
" 3 - Lista de cuentas con saldos con debito", " 4 - Finalizar ejecucion" );

try // trata de recibir la opción del menú
{
do // recibe solicitud del usuario
{
System.out.print( "\n? " );
solicitud = textoEnt.nextInt();
} while ( ( solicitud < 1 ) || ( solicitud > 4 ) );
} // fin de try
catch ( NoSuchElementException elementException )
{
System.err.println( "Entrada invalida." );
System.exit( 1 );
} // fin de catch

return opciones[ solicitud - 1 ]; // devuelve valor de enum para la opción
} // fin del método obtenerSolicitud

public void procesarSolicitudes()
{
// obtiene la solicitud del usuario (saldo de cero, con crédito o con débito)
tipoCuenta = obtenerSolicitud();

while ( tipoCuenta != OpcionMenu.FIN )
{
switch ( tipoCuenta )
{
case SALDO_CERO:
System.out.println( "\nCuentas con saldos de cero:\n" );
break;
case SALDO_CREDITO:
System.out.println( "\nCuentas con saldos con credito:\n" );
break;
case SALDO_DEBITO:
System.out.println( "\nCuentas con saldos con debito:\n" );
break;
} // fin de switch

leerRegistros();
tipoCuenta = obtenerSolicitud();
} // fin de while
} // fin del método procesarSolicitudes
} // fin de la clase ConsultaCredito

Fig. 14.15: PruebaConsultaCredito.java

// Este programa prueba la clase ConsultaCredito.

public class PruebaConsultaCredito
{
public static void main( String args[] )
{
ConsultaCredito aplicacion = new ConsultaCredito();
aplicacion.procesarSolicitudes();
} // fin de main
} // fin de la clase PruebaConsultaCredito

Fig. 14.17: RegistroCuentaSerializable.java

// Fig. 14.17: RegistroCuentaSerializable.java

// Una clase que representa un registro de información.

package com.deitel.jhtp7.cap14; // empaquetada para reutilizarla

import java.io.Serializable;

public class RegistroCuentaSerializable 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 RegistroCuentaSerializable()
{
this( 0, "", "", 0.0 );
} // fin del constructor de RegistroCuentaSerializable sin argumentos

// el constructor con cuatro argumentos inicializa un registro
public RegistroCuentaSerializable(
int cta, String nombre, String apellido, double sal )
{
establecerCuenta( cta );
establecerPrimerNombre( nombre );
establecerApellidoPaterno( apellido );
establecerSaldo( sal );
} // fin del constructor de RegistroCuentaSerializable con cuatro argumentos

// establece el número de cuenta
public void establecerCuenta( int cta )
{
cuenta = cta;
} // fin del método establecerCuenta

// obtiene el número de cuenta
public int obtenerCuenta()
{
return cuenta;
} // fin del método obtenerCuenta

// establece el primer nombre
public void establecerPrimerNombre( String nombre )
{
primerNombre = nombre;
} // fin del método establecerPrimerNombre

// obtiene el primer nombre
public String obtenerPrimerNombre()
{
return primerNombre;
} // fin del método obtenerPrimerNombre

// establece el apellido paterno
public void establecerApellidoPaterno( String apellido )
{
apellidoPaterno = apellido;
} // fin del método establecerApellidoPaterno

// obtiene el apellido paterno
public String obtenerApellidoPaterno()
{
return apellidoPaterno;
} // fin del método obtenerApellidoPaterno

// establece el saldo
public void establecerSaldo( double sal )
{
saldo = sal;
} // fin del método establecerSaldo

// obtiene el saldo
public double obtenerSaldo()
{
return saldo;
} // fin del método obtenerSaldo
} // fin de la clase RegistroCuentaSerializable

Fig. 14.18: CrearArchivoSecuencial.java

// Escritura de objetos en forma secuencial a un archivo, con la clase ObjectOutputStream.
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.NoSuchElementException;
import java.util.Scanner;

import com.deitel.jhtp7.cap14.RegistroCuentaSerializable;

public class CrearArchivoSecuencial
{
private ObjectOutputStream salida; // envía los datos a un archivo

// permite al usuario especificar el nombre del archivo
public void abrirArchivo()
{
try // abre el archivo
{
salida = new ObjectOutputStream(
new FileOutputStream( "clientes.ser" ) );
} // fin de try
catch ( IOException ioException )
{
System.err.println( "Error al abrir el archivo." );
} // fin de catch
} // fin del método abrirArchivo

// agrega registros al archivo
public void agregarRegistros()
{
RegistroCuentaSerializable registro; // objeto que se va a escribir al archivo
int numeroCuenta = 0; // número de cuenta para el objeto registro
String primerNombre; // primer nombre para el objeto registro
String apellidoPaterno; // apellido paterno para el objeto registro
double saldo; // saldo para el objeto registro

Scanner entrada = new Scanner( System.in );

System.out.printf( "%s\n%s\n%s\n%s\n\n",
"Para terminar de introducir datos, escriba el indicador de fin de archivo ",
"Cuando se le pida que introduzca los datos.",
"En UNIX/Linux/Mac OS X escriba d y oprima Intro",
"En Windows escriba z y oprima Intro" );

System.out.printf( "%s\n%s",
"Escriba el numero de cuenta (> 0), primer nombre, apellido y saldo.",
"? " );

while ( entrada.hasNext() ) // itera hasta el indicador de fin de archivo
{
try // envía los valores al archivo
{
numeroCuenta = entrada.nextInt(); // lee el número de cuenta
primerNombre = entrada.next(); // lee el primer nombre
apellidoPaterno = entrada.next(); // lee el apellido paterno
saldo = entrada.nextDouble(); // lee el saldo

if ( numeroCuenta > 0 )
{
// crea un registro nuevo
registro = new RegistroCuentaSerializable( numeroCuenta,
primerNombre, apellidoPaterno, saldo );
salida.writeObject( registro ); // envía el registro como salida
} // fin de if
else
{
System.out.println(
"El numero de cuenta debe ser mayor de 0." );
} // fin de else
} // fin de try
catch ( IOException ioException )
{
System.err.println( "Error al escribir en el archivo." );
return;
} // fin de catch
catch ( NoSuchElementException elementException )
{
System.err.println( "Entrada invalida. Intente de nuevo." );
entrada.nextLine(); // descarta la entrada para que el usuario intente de nuevo
} // fin de catch

System.out.printf( "%s %s\n%s", "Escriba el numero de cuenta (>0),",
"primer nombre, apellido y saldo.", "? " );
} // fin de while
} // fin del método agregarRegistros

// cierra el archivo y termina la aplicación
public void cerrarArchivo()
{
try // cierra el archivo
{
if ( salida != null )
salida.close();
} // fin de try
catch ( IOException ioException )
{
System.err.println( "Error al cerrar el archivo." );
System.exit( 1 );
} // fin de catch
} // fin del método cerrarArchivo
} // fin de la clase CrearArchivoSecuencial