You are on page 1of 29

Curso de programacin en .NET - Tema 1.40.2 - Archivos secuenciales, Java.

1. Archivos secuenciales, Java.


1.1 Objetivos del tema.
Visto el acceso a un archivo, vamos a ver el acceso a un archivo secuencial utilizando
un formato en ASCII delimitado como formato de grabacin, que es el ms estndar de
todos.

1.2 Introduccin.
Son archivos que se generan con una estructura que puede o no ser fija y que su lectura
no puede ser direccionada.
Otro aspecto, es que por la estructura de datos generada en el archivo, la misma permita
que se direccionen los registros, y que dicho archivo pueda ser abierto bajo otro formato
distinto, de acceso aleatorio, pero eso es una particularidad, o una excepcin, y tambin
podramos enfocarlo al revs, es decir es un archivo random, que se usa como archivo
secuencial, para gustos los colores.

Otro aspecto sobre los archivos secuenciales, es que la estructura de datos que albergan
no tiene porque ser una estructura fija, pueden ser registros con una estructura distinta
de unos a otros, y adems la longitud puede ser variable, siempre y cuando se este
utilizando el formato de ASCII delimitado, que incorpora la delimitacin de campos y
de final de registro.

1.3 Previo.
Para la utilizacin de los ejemplos siguientes es necesario la importacin de las
siguientes clases.
Cdigo:
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;

Con estas clases se puede gestionar los archivos, tanto en su enlace con el Sistema
Operativo, con en la entrada, salida de datos, y la captura de errores.
Sin la importacin de estas clases los ejemplos generaran error.

1.4 Abrir un archivo.
El primer paso para acceder a un archivo es siempre enlazarlo con el programa, abrirlo.
En Java la operacin de apertura de un archivo ser realiza asignando dicho archivo a
una variable de tipo archivo.
Cdigo:
File Archivo;
Archivo = new File(Ruta + Nombre);

En este paso lo que se consigue es asociar un nombre de archivo a esa variable.
Pero con eso lo que se consigue es enlazar el archivo, an no est definido si se usar
para leer o para grabar.

El siguiente paso es realizar la apertura, en el modo que nos interese.
Para grabacin se define una variable del tipo FileWriter.
Cdigo:
FileWriter Salida;
Salida = null;
Salida = new FileWriter(Archivo);

Ahora lo que se consigue es asociar el archivo que hemos definido anteriormente, a un
objeto que ya indicar si es de lectura o de escritura, o entrada o salida, como se
prefiera.

Para lectura se define una variable del tipo FileReader.
Cdigo:
FileReader Entrada;
Entrada = new FileReader(Archivo);

Estos objetos definidos harn referencia al archivo declarado anteriormente.

1.5 Grabar una estructura de datos.
Bueno visto como efectuar la lectura y escritura en un archivo secuencial, conviene
ampliar el tema para un archivo con una estructura algo ms amplia.

Para la estructura de datos podemos utilizar un array o una coleccin, con el fin de
almacenar los datos a utilizar en la misma.
La grabacin de los datos no es nada ms que la generacin de un registro de datos con
un formato en concreto, uno de los ms extendidos es el ASCII delimitado.
En este formato se graban los datos numricos separados por comas y los alfanumricos
encerrados entre comillas dobles.

La estructura se graba como una variable definida con una estructura de usuario.
Cdigo:
public class TipoRegistro
{
public char[] Exped = new char[2];
public char[] Nomb = new char[12];
public char[] Ape1 = new char[12];
public char[] Ape2 = new char[12];
public char[] Domic = new char[20];
public TipoRegistro()
{
}
}

Y grabar
Cdigo:
static void Grabar(FileWriter Salida, TipoRegistro Registro)
throws IOException
{
Salida.write("01");
Salida.write("Nombre 1 ");
Salida.write("Apellido 1 1");
Salida.write("Apellido 2 1");
Salida.write("Domicilio uno ");
}


Si tuviramos que realizar la captura de datos por teclado podramos realizar lo
siguiente.
Cdigo:
BufferedReader Campo = new BufferedReader(new InputStreamReader(System.in));
String Dato;
Dato = new String();

System.out.println("Nombre ");
Dato = Campo.readLine();
while (Dato.length() != 20) Dato = Dato.concat(" ");
Registro.Nombre = Dato.toCharArray();


Y la explicacin es
Cdigo:
BufferedReader Campo = new BufferedReader(new InputStreamReader(System.in));


Nos permitir la captura de datos desde el buffer de teclado.
Cdigo:
while (Dato.length() != 20) Dato = Dato.concat(" ");


Como hay que grabar datos de longitud fija, de esta forma completamos la longitud del
dato hasta lo longitud definida.
Cdigo:
Registro.Nombre = Dato.toCharArray();


Si se define el registro como un
Cdigo:
public char[] Nombre = new char[20];


Con est lnea se convierte el string en array of char, que es como se ha definido, para
despus ejecutar,
Cdigo:
Salida.write(Registro.Nombre);


1.6 Leer un registro.
El siguiente paso sera intentar leer el registro que hemos grabado anteriormente.
Cdigo:
private static void Lectura() throws IOException
{
File Archivo;
Archivo = new File("Pruebas.dat");
FileReader Entrada = new FileReader(Archivo);

TipoRegistro Registro;
Registro = new TipoRegistro();

Entrada.read(Registro.Exped, 0, 2);
Entrada.read(Registro.Nomb, 0, 12);
Entrada.read(Registro.Ape1, 0, 12);
Entrada.read(Registro.Ape2, 0, 12);
Entrada.read(Registro.Domic, 0, 20);

Ver (Registro);
Entrada.close();
}


1.7 Lectura de un archivo secuencial.
La lectura de un archivo secuencial se basa siempre en el uso de un bucle del tipo
mientras. La estructura de dicho bucle es la que sigue:
Cdigo:
private static void Bucle() throws IOException
{
System.out.println("Inicio");
File Archivo;
Archivo = new File("Pruebas.dat");
FileReader Entrada = new FileReader(Archivo);

TipoRegistro Registro;
Registro = new TipoRegistro();
while (Entrada.read(Registro.Exped, 0, 2) != -1)
{
Entrada.read(Registro.Nomb, 0, 12);
Entrada.read(Registro.Ape1, 0, 12);
Entrada.read(Registro.Ape2, 0, 12);
Entrada.read(Registro.Domic, 0, 20);
Ver (Registro);
}
Entrada.close();
}


1.8 Cierre
Para ello se utiliza la instruccin Entrada.Close();

1.9 Ejercicios propuestos.
1. Disee un registro de datos con los datos de los telfonos de sus amigos.
2. Realice la entrada de datos por teclado y grabe los datos con un archivo
secuencial.
3. Realizar el listado de esos datos en pantalla.
4. Cree ahora un archivo igual al anterior y adale el dato tipo y grabe datos en l.
El campo tipo ser 1 para nuevos datos, 2 para actualizar datos existentes, 3 para
borrar datos.

1.10 Solucin a los ejercicios propuestos.
1.-Disee un registro de datos con los datos de los telfonos de sus amigos.
Cdigo:
public class Amigos
{
public char[] Codigo = new char[2];
public char[] Nombre = new char[20];
public char[] Domicilio = new char[20];
public char[] Telef_Fijo = new char[9];
public char[] Telef_Movil = new char[9];
public char[] Correo_Elect = new char[30];
public Amigos)
{
}
}

2.-Realice la entrada de datos por teclado y grabe los datos con un archivo secuencial.
Cdigo:
package tema_40;
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main
{
static void PedirDatos (TipoEjercicio Registro) throws IOException
{
BufferedReader Campo = new BufferedReader(new
InputStreamReader(System.in));
String Dato;
Dato = new String();
System.out.println("Cdigo" + Dato);
Dato = Campo.readLine();

if (Dato.length() == 1) Dato = "0" + Dato;
System.out.println("Cdigo [" + Dato +"]" );
Registro.Codigo =Dato.toCharArray();
System.out.println("Nombre ");
Dato = Campo.readLine();

while (Dato.length() != 20) Dato = Dato.concat(" ");
Registro.Nombre = Dato.toCharArray();
System.out.println("Domicilio ");
Dato = Campo.readLine();

while (Dato.length() != 20) Dato = Dato + " ";
Registro.Domicilio =Dato.toCharArray();
System.out.println("Telfono ");
Dato = Campo.readLine();

while (Dato.length() != 9) Dato = Dato + " ";
Registro.Telef_Fijo = Dato.toCharArray();
System.out.println("Telef. movil ");
Dato = Campo.readLine();

while (Dato.length() != 9) Dato = Dato + " ";
Registro.Telef_Movil = Dato.toCharArray();
System.out.println("Correo electrnico");
Dato = Campo.readLine();

while (Dato.length() != 30) Dato = Dato + " ";
Registro.Correo_Elect = Dato.toCharArray();
System.out.println("Los datos introducidos son ");
System.out.print("Cdigo ");
System.out.println(Registro.Codigo);
System.out.print("Nombre ");
System.out.println(Registro.Nombre);
System.out.print("Domicilio ");
System.out.println(Registro.Domicilio);
System.out.print("Telfono ");
System.out.println(Registro.Telef_Fijo);
System.out.print("Telef. movil ");
System.out.println(Registro.Telef_Movil);
System.out.print("Correo electrnico ");
System.out.println(Registro.Correo_Elect);
}
static boolean Pregunta(String Mensaje) throws IOException
{
BufferedReader Campo = new BufferedReader(new
InputStreamReader(System.in));
String Dato;
Dato = new String();
Boolean Respuesta;
System.out.println(Mensaje);
Dato = Campo.readLine();
Dato = Dato.toUpperCase();
Respuesta = Dato.contains("S");

return Respuesta;
}
static void Grabar(FileWriter Salida, TipoEjercicio Registro) throws IOException
{
Salida.write(Registro.Codigo);
Salida.write(Registro.Nombre);
Salida.write(Registro.Domicilio);
Salida.write(Registro.Telef_Fijo);
Salida.write(Registro.Telef_Movil);
Salida.write(Registro.Correo_Elect);
System.out.println("Datos grabados");
}
public static void main(String[] args) throws IOException
{
File Archivo;
FileWriter Salida;
Archivo = new File("Amigos.txt");
Salida = new FileWriter(Archivo);
TipoEjercicio Registro;
Registro = new TipoEjercicio();
do
{
PedirDatos(Registro);
if (Pregunta("Datos correctos S/N")) Grabar(Salida,Registro);
}
while (Pregunta("Desea grabar ms datos S/N"));
Salida.close();
}
}


3.-Realizar el listado de esos datos en pantalla.
Cdigo:
package tema_40;
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main
{
private static void Ver (TipoEjercicio Registro)
{
System.out.print(Registro.Codigo );
System.out.print(Registro.Nombre );
System.out.print(Registro.Domicilio );
System.out.print(Registro.Telef_Fijo );
System.out.print(Registro.Telef_Movil );
System.out.print(Registro.Correo_Elect);
System.out.println();
}
private static void Lectura (FileReader Entrada, TipoEjercicio Registro) throws
IOException
{
Entrada.read(Registro.Nombre, 0, 20);
Entrada.read(Registro.Domicilio, 0, 20);
Entrada.read(Registro.Telef_Fijo, 0, 9);
Entrada.read(Registro.Telef_Movil, 0, 9);
Entrada.read(Registro.Correo_Elect, 0, 30);
}
private static void Bucle(FileReader Entrada,
TipoEjercicio Registro) throws IOException
{
System.out.println("Inicio");
System.out.println("Co Nombre Domicilio Tel Fijo Tel
Movil Correo elec.");
while (Entrada.read(Registro.Codigo, 0, 2) != -1)
{
Lectura(Entrada,Registro);
Ver (Registro);
}
Entrada.close();
System.out.println("Final");
}
public static void main(String[] args) throws IOException
{
File Archivo;
FileReader Entrada;
Archivo = new File("Amigos.txt");
Entrada = new FileReader(Archivo);
TipoEjercicio Registro;
Registro = new TipoEjercicio();
Bucle(Entrada, Registro);
Entrada.close();
}
}


4.-Cree ahora un archivo igual al anterior y adale el dato tipo y grabe datos en l.
El campo tipo ser 1 para nuevos datos, 2 para actualizar datos existentes, 3 para borrar
datos.
Cdigo:
package tema_40;
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main
{
static void PedirDatosCambios (TipoCambio Registro) throws IOException
{
BufferedReader Campo = new BufferedReader(new
InputStreamReader(System.in));
String Dato;
Dato = new String();
System.out.println("Cdigo" + Dato);
Dato = Campo.readLine();

if (Dato.length() == 1) Dato = "0" + Dato;
System.out.println("Cdigo [" + Dato +"]" );
Registro.Codigo =Dato.toCharArray();
System.out.println("Nombre ");
Dato = Campo.readLine();

while (Dato.length() != 20) Dato = Dato.concat(" ");
Registro.Nombre = Dato.toCharArray();
System.out.println("Domicilio ");
Dato = Campo.readLine();

while (Dato.length() != 20) Dato = Dato + " ";
Registro.Domicilio =Dato.toCharArray();
System.out.println("Telfono ");
Dato = Campo.readLine();

while (Dato.length() != 9) Dato = Dato + " ";
Registro.Telef_Fijo = Dato.toCharArray();
System.out.println("Telef. movil ");
Dato = Campo.readLine();

while (Dato.length() != 9) Dato = Dato + " ";
Registro.Telef_Movil = Dato.toCharArray();
System.out.println("Correo electrnico");
Dato = Campo.readLine();

while (Dato.length() != 30) Dato = Dato + " ";
Registro.Correo_Elect = Dato.toCharArray();
System.out.println("Tipo de incidencia, 1 Nuevo, 2 Cambios, 3 Borrado");
Dato = Campo.readLine();
Registro.Tipo = Dato.toCharArray();

System.out.println("Los datos introducidos son ");
System.out.print("Cdigo ");
System.out.println(Registro.Codigo);
System.out.print("Nombre ");
System.out.println(Registro.Nombre);
System.out.print("Domicilio ");
System.out.println(Registro.Domicilio);
System.out.print("Telfono ");
System.out.println(Registro.Telef_Fijo);
System.out.print("Telef. movil ");
System.out.println(Registro.Telef_Movil);
System.out.print("Correo electrnico ");
System.out.println(Registro.Correo_Elect);
System.out.print("Tipo de incidencia ");
System.out.println(Registro.Tipo);
}
static boolean Pregunta(String Mensaje) throws IOException
{
BufferedReader Campo = new BufferedReader(new
InputStreamReader(System.in));
String Dato;
Dato = new String();
Boolean Respuesta;
System.out.println(Mensaje);
Dato = Campo.readLine();
Dato = Dato.toUpperCase();
Respuesta = Dato.contains("S");

return Respuesta;
}
static void GrabarCambios(FileWriter Salida, TipoCambio Registro) throws
IOException
{
Salida.write(Registro.Codigo);
Salida.write(Registro.Nombre);
Salida.write(Registro.Domicilio);
Salida.write(Registro.Telef_Fijo);
Salida.write(Registro.Telef_Movil);
Salida.write(Registro.Correo_Elect);
Salida.write(Registro.Tipo);
System.out.println("Datos grabados");
}
public static void main(String[] args) throws IOException
{
File Archivo;
FileWriter Salida;
Archivo = new File("Cambios.txt");
Salida = new FileWriter(Archivo);
TipoCambio Registro;
Registro = new TipoCambio();
do
{
PedirDatosCambios(Registro);
if (Pregunta("Datos correctos S/N")) GrabarCambios(Salida,Registro);
}
while (Pregunta("Desea grabar ms datos S/N"));
Salida.close();
}
}





Link Log
Una manera de perder el tiempo
Usando archivos secuenciales en Java
with 3 comments
Con este programa, se creara un archivo con registros de numero de matricula, nombre
y pedir 3 calificaciones para despus calcular el promedio.
import java.io.*;
import java.util.Scanner;
public class Archivos{
public static void main( String args[] )throws IOException{
Scanner leer = new Scanner(System.in);
DataOutputStream Archi = null;
int i;
int matricula=0;
String nombre=new String();
int calif1;
int calif2;
int calif3;
double promedio;
try{
for (i=0; i<5; i++){
Archi = new DataOutputStream( new FileOutputStream(../Archivo.dat,true) );
System.out.println(Escribe la matricula: );
matricula = leer.nextInt();
System.out.println(Escribe Nombre: );
nombre = leer.next();
System.out.println(Ingrese Calificacion 1: );
calif1 = leer.nextInt();
System.out.println(Ingrese Califiacin 2);
calif2 = leer.nextInt();
System.out.println(Ingrese Calificacion 3);
calif3 = leer.nextInt();
Archi.writeInt(matricula);
Archi.writeUTF(nombre);
Archi.writeInt(calif1);
Archi.writeInt(calif2);
Archi.writeInt(calif3);
Archi.close();
}
}
catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}
}
}
Este otro mostrara lo que hay en el archivo:
import java.io.*;
public class LeerArchivos{
public static void main( String args[] )throws IOException{
DataInputStream Archi = null;
int matricula=0;
String nombre=new String();
int calif1;
int calif2;
int calif3;
double promedio;
try{
Archi = new DataInputStream( new FileInputStream(../Archivo.dat) );
while (true){
matricula = Archi.readInt();
System.out.println(Matricula: +matricula+ );
nombre = Archi.readUTF();
System.out.println(Nombre: +nombre+ );
calif1= Archi.readInt();
System.out.println(Calificacion 1: +calif1+ );
calif2= Archi.readInt();
System.out.println(Calificacion 2: +calif2+ );
calif3= Archi.readInt();
System.out.println(Calificacion 3: +calif3+ );
System.out.println(n);
int suma = calif1 + calif2 + calif3;
promedio = suma/3;
System.out.println(El promedio es: +promedio+n);
}
}
catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}
Archi.close();
}
}
MODificado

























Curso de programacin en .NET - Tema 1.40.3 - Archivos secuenciales,
Java.


1. Archivos secuenciales, Java.
1.1 Objetivos del tema.
Visto el acceso a un archivo, vamos a ver el acceso a un archivo secuencial
utilizando un formato en ASCII delimitado como formato de grabacin,
que es el ms estndar de todos.

1.2 Introduccin.
Son archivos que se generan con una estructura que puede o no ser fija y
que su lectura no puede ser direccionada.
Otro aspecto, es que por la estructura de datos generada en el archivo, la
misma permita que se direccionen los registros, y que dicho archivo pueda
ser abierto bajo otro formato distinto, de acceso aleatorio, pero eso es una
particularidad, o una excepcin, y tambin podramos enfocarlo al revs, es
decir es un archivo random, que se usa como archivo secuencial, para
gustos los colores.

Otro aspecto sobre los archivos secuenciales, es que la estructura de datos
que albergan no tiene porque ser una estructura fija, pueden ser registros
con una estructura distinta de unos a otros, y adems la longitud puede ser
variable, siempre y cuando se est utilizando el formato de ASCII
delimitado, que incorpora la delimitacin de campos y de final de registro.

1.3 Proceso de actualizacin.
El proceso de actualizacin se basa en el emparejamiento de registros, para
ello los archivos han de estar grabados en secuencia, en caso contrario no
es posible realizar un proceso adecuadamente correcto.

El sistema seguido es el de high value, viejo sistema utilizado en otros
lenguajes de programacin, pero no por ello menos efectivo.
La filosofa es la de emparejar registros como ya se explic en el tema
anterior.
Importante que el valor utilizado como High value, no sea alcanzable por
los datos del archivo.
Cdigo:
String Hv = "99"; // ZZ

El valor ms adecuado sera el de "ZZ"

El proceso se basa en que solo puede haber proceso de actualizacin si los
cdigos coinciden, en ese caso puede darse el caso de borrado o
actualizacin, pero nunca un alta, eso sera un error.
Si el cdigo del archivo principal se adelanta al de los cambios, significa
que los registros hasta igualarse deben ser del tipo alta, en caso contrario
sera un error en la grabacin del archivo de cambios.

Si el cdigo del archivo principal se queda por detrs significa que ese
cdigo no dispone de incidencias, por lo que debe ser copiado tal como est
en el archivo que se crea nuevo en el proceso, para no perder los datos que
no van a sufrir cambios.
Siempre debemos disponer de una pareja de registros, por lo que al tratar
un registro del archivo principal, inmediatamente hay que leer otro.

Igual con el de los cambios.
Por este motivo antes de entrar en el bucle de proceso, se debe cargar una
pareja de registros fuera del bucle.
Cdigo:
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
Cod_Cam = String.copyValueOf(Reg_Cambios.Codigo);
Cod_Ami = String.copyValueOf(Reg_Amigos.Codigo);


Al realizar la lectura en un archivo, si se da la circunstancia de final de
archivo, es cuando al cdigo de ese archivo se le asigna el high value.
Cdigo:
if (Ent_Cambios.read(Reg_Cambios.Codigo, 0, 2) != -1)
{
LecturaCambio(Ent_Cambios,Reg_Cambios);
}
else
{
Reg_Cambios.Codigo = Hv.toCharArray();
}


No sirve utilizar variables de tipo booleano, ni cualquier otra combinacin,
cuyo nico resultado al final es maquiavlico, comparado con la sencillez
de ste proceso.
Cdigo:
while ((Cod_Ami.compareTo(Hv) != 0 ) || (Cod_Cam.compareTo(Hv) != 0
))


A continuacin exponemos el ncleo del proceso.
Cdigo:
public static void Actualiza() throws IOException
{
String Hv ="99";

// Archivo de amigos
File Arc_Amigos;
FileReader Ent_Amigos;
Arc_Amigos = new File("Amigos.txt");
Ent_Amigos = new FileReader(Arc_Amigos);

// Registro
TipoEjercicio Reg_Amigos;
Reg_Amigos = new TipoEjercicio();

// Archivo de incidencias
File Arc_Cambios;
FileReader Ent_Cambios;
Arc_Cambios = new File("Cambios.txt");
Ent_Cambios = new FileReader(Arc_Cambios);

// Registro
TipoCambio Reg_Cambios;
Reg_Cambios = new TipoCambio();

// Nuevo archivo de amigos, con las incidencias realizadas
File Arc_Nue_Amigos;
FileWriter Sal_Amigos;
Arc_Nue_Amigos = new File("Nuevo.txt");
Sal_Amigos = new FileWriter(Arc_Nue_Amigos);

// Registro
TipoEjercicio Reg_Sal_Amigos;
Reg_Sal_Amigos = new TipoEjercicio();
String Cod_Ami="00";
String Cod_Cam="00";
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
Cod_Cam = String.copyValueOf(Reg_Cambios.Codigo);
Cod_Ami = String.copyValueOf(Reg_Amigos.Codigo);
while ((Cod_Ami.compareTo(Hv) != 0 ) || (Cod_Cam.compareTo(Hv) !=
0 ))
{
if (Cod_Cam.compareTo(Cod_Ami) > 0)
{ // copiar existente
GrabarActualiz(Sal_Amigos,
Reg_Amigos.Codigo,
Reg_Amigos.Nombre,
Reg_Amigos.Domicilio,
Reg_Amigos.Telef_Fijo,
Reg_Amigos.Telef_Movil,
Reg_Amigos.Correo_Elect);
LeeAmigo(Ent_Amigos,Reg_Amigos);
}
else if (Cod_Cam.compareTo(Cod_Ami)< 0)
{
switch (Reg_Cambios.Tipo[0])
{
case '1': // registro nuevo
GrabarActualiz(Sal_Amigos,
Reg_Cambios.Codigo,
Reg_Cambios.Nombre,
Reg_Cambios.Domicilio,
Reg_Cambios.Telef_Fijo,
Reg_Cambios.Telef_Movil,
Reg_Cambios.Correo_Elect);
LeeCambio(Ent_Cambios,Reg_Cambios);
break;
default: // Error de tipo de incidencia
// Incidencia Habra que imprimir o grabar incidencias
LeeCambio(Ent_Cambios,Reg_Cambios);
break;
}
}
else if (Cod_Cam.compareTo(Cod_Ami) == 0)
{
switch (Reg_Cambios.Tipo[0])
{
case '1': // alta, error
// Incidencia Habra que imprimir o grabar incidencias
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
case '2': // modificacin, se graba el nuevo
GrabarActualiz(Sal_Amigos,
Reg_Cambios.Codigo,
Reg_Cambios.Nombre,
Reg_Cambios.Domicilio,
Reg_Cambios.Telef_Fijo,
Reg_Cambios.Telef_Movil,
Reg_Cambios.Correo_Elect);
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
case '3': // baja, no se graba
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
}
}
Cod_Cam = String.copyValueOf(Reg_Cambios.Codigo);
Cod_Ami = String.copyValueOf(Reg_Amigos.Codigo);
}
Sal_Amigos.close();
Ent_Amigos.close();
Ent_Cambios.close();
}


1.4 Cierre
Para ello se utiliza la instruccin Ent_Amigos.close();
Y se cierra cada uno de los archivos que nos interesa.

1.5 Comentarios.
El proceso de actualizacin de archivos secuenciales expuesto, parte de que
sera un proceso basado en archivos de gran volumen, que imposibilitan su
tratamiento en memoria.

Dada la capacidad de recursos de los equipos actuales, para procesos de
poca entidad, se pueden plantear alternativas distintas a la aqu propuesta,
basadas en la carga completa del archivo en un array.
Alternativas hay varias, es solo cuestin de elegir en cada momento la ms
apropiada.

Pero si que hay que tener presente que la correcta, filosficamente, es la
aqu expuesta, las dems soluciones basadas en estructuras de datos en
memoria, tienen un lmite, que es la capacidad de recursos del equipo en el
que se ejecuten.

1.6 Ejercicios propuestos.
1. Realice el proceso de actualizacin del archivo de amigos con los
datos del archivo de cambios del tema anterior.

1.7 Solucin a los ejercicios propuestos.
1.-Realice el proceso de actualizacin del archivo de amigos con los datos
del archivo de cambios del tema anterior.
Cdigo:
public static void Actualiza() throws IOException
{
String Hv ="99";

// Archivo de amigos
File Arc_Amigos;
FileReader Ent_Amigos;
Arc_Amigos = new File("Amigos.txt");
Ent_Amigos = new FileReader(Arc_Amigos);

// Registro
TipoEjercicio Reg_Amigos;
Reg_Amigos = new TipoEjercicio();

// Archivo de incidencias
File Arc_Cambios;
FileReader Ent_Cambios;
Arc_Cambios = new File("Cambios.txt");
Ent_Cambios = new FileReader(Arc_Cambios);

// Registro
TipoCambio Reg_Cambios;
Reg_Cambios = new TipoCambio();

// Nuevo archivo de amigos, con las incidencias realizadas
File Arc_Nue_Amigos;
FileWriter Sal_Amigos;
Arc_Nue_Amigos = new File("Nuevo.txt");
Sal_Amigos = new FileWriter(Arc_Nue_Amigos);

// Registro
TipoEjercicio Reg_Sal_Amigos;
Reg_Sal_Amigos = new TipoEjercicio();
String Cod_Ami="00";
String Cod_Cam="00";
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
Cod_Cam = String.copyValueOf(Reg_Cambios.Codigo);
Cod_Ami = String.copyValueOf(Reg_Amigos.Codigo);
while ((Cod_Ami.compareTo(Hv) != 0 ) || (Cod_Cam.compareTo(Hv) !=
0 ))
{
if (Cod_Cam.compareTo(Cod_Ami) > 0)
{ // copiar existente
GrabarActualiz(Sal_Amigos,
Reg_Amigos.Codigo,
Reg_Amigos.Nombre,
Reg_Amigos.Domicilio,
Reg_Amigos.Telef_Fijo,
Reg_Amigos.Telef_Movil,
Reg_Amigos.Correo_Elect);
LeeAmigo(Ent_Amigos,Reg_Amigos);
}
else if (Cod_Cam.compareTo(Cod_Ami)< 0)
{
switch (Reg_Cambios.Tipo[0])
{
case '1': // registro nuevo
GrabarActualiz(Sal_Amigos,
Reg_Cambios.Codigo,
Reg_Cambios.Nombre,
Reg_Cambios.Domicilio,
Reg_Cambios.Telef_Fijo,
Reg_Cambios.Telef_Movil,
Reg_Cambios.Correo_Elect);
LeeCambio(Ent_Cambios,Reg_Cambios);
break;
default: // Error de tipo de incidencia
// Incidencia Habra que imprimir o grabar incidencias
LeeCambio(Ent_Cambios,Reg_Cambios);
break;
}
}
else if (Cod_Cam.compareTo(Cod_Ami) == 0)
{
switch (Reg_Cambios.Tipo[0])
{
case '1': // alta, error
// Incidencia Habra que imprimir o grabar incidencias
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
case '2': // modificacin, se graba el nuevo
GrabarActualiz(Sal_Amigos,
Reg_Cambios.Codigo,
Reg_Cambios.Nombre,
Reg_Cambios.Domicilio,
Reg_Cambios.Telef_Fijo,
Reg_Cambios.Telef_Movil,
Reg_Cambios.Correo_Elect);
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
case '3': // baja, no se graba
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
}
}
Cod_Cam = String.copyValueOf(Reg_Cambios.Codigo);
Cod_Ami = String.copyValueOf(Reg_Amigos.Codigo);
}
Sal_Amigos.close();
Ent_Amigos.close();
Ent_Cambios.close();
}


Los procedimientos utilizados en este ejercicio son:
Cdigo:
private static void GrabarActualiz(FileWriter Salida, char[] Codigo, char[]
Nombre, char[] Domicilio, char[] Telef_Fijo, char[] Telef_Movil, char[]
Correo) throws IOException
{
Salida.write(Codigo);
Salida.write(Nombre);
Salida.write(Domicilio);
Salida.write(Telef_Fijo);
Salida.write(Telef_Movil);
Salida.write(Correo);
}
private static void Lectura (FileReader Entrada, TipoEjercicio Registro)
throws IOException
{
Entrada.read(Registro.Nombre, 0, 20);
Entrada.read(Registro.Domicilio, 0, 20);
Entrada.read(Registro.Telef_Fijo, 0, 9);
Entrada.read(Registro.Telef_Movil, 0, 9);
Entrada.read(Registro.Correo_Elect, 0, 30);
}
private static void LeeAmigo(FileReader Ent_Amigos, TipoEjercicio
Reg_Amigos) throws IOException
{
String Hv = "99"; // ZZ
if (Ent_Amigos.read(Reg_Amigos.Codigo, 0, 2) != -1)
{
Lectura(Ent_Amigos,Reg_Amigos);
}
else
{
Reg_Amigos.Codigo = Hv.toCharArray();
}
}
private static void LecturaCambio (FileReader Entrada, TipoCambio
Registro) throws IOException
{
Entrada.read(Registro.Nombre, 0, 20);
Entrada.read(Registro.Domicilio, 0, 20);
Entrada.read(Registro.Telef_Fijo, 0, 9);
Entrada.read(Registro.Telef_Movil, 0, 9);
Entrada.read(Registro.Correo_Elect, 0, 30);
Entrada.read(Registro.Tipo, 0, 1);
}
private static void LeeCambio(FileReader Ent_Cambios, TipoCambio
Reg_Cambios) throws IOException
{
String Hv = "99"; // ZZ
if (Ent_Cambios.read(Reg_Cambios.Codigo, 0, 2) != -1)
{
LecturaCambio(Ent_Cambios,Reg_Cambios);
}
else
{
Reg_Cambios.Codigo = Hv.toCharArray();
}
}


Y se deben importar.
Cdigo:
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;


El cdigo completo.
Cdigo:
package tema_40;
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;

public class Actualizacion
{
private static void GrabarActualiz(FileWriter Salida, char[] Codigo,
char[] Nombre, char[] Domicilio, char[] Telef_Fijo, char[] Telef_Movil,
char[] Correo) throws IOException
{
Salida.write(Codigo);
Salida.write(Nombre);
Salida.write(Domicilio);
Salida.write(Telef_Fijo);
Salida.write(Telef_Movil);
Salida.write(Correo);
}
private static void Lectura (FileReader Entrada, TipoEjercicio Registro)
throws IOException
{
Entrada.read(Registro.Nombre, 0, 20);
Entrada.read(Registro.Domicilio, 0, 20);
Entrada.read(Registro.Telef_Fijo, 0, 9);
Entrada.read(Registro.Telef_Movil, 0, 9);
Entrada.read(Registro.Correo_Elect, 0, 30);
}
private static void LeeAmigo(FileReader Ent_Amigos, TipoEjercicio
Reg_Amigos) throws IOException
{
String Hv = "99"; // ZZ
if (Ent_Amigos.read(Reg_Amigos.Codigo, 0, 2) != -1)
{
Lectura(Ent_Amigos,Reg_Amigos);
}
else
{
Reg_Amigos.Codigo = Hv.toCharArray();
}
}
private static void LecturaCambio (FileReader Entrada, TipoCambio
Registro) throws IOException
{
Entrada.read(Registro.Nombre, 0, 20);
Entrada.read(Registro.Domicilio, 0, 20);
Entrada.read(Registro.Telef_Fijo, 0, 9);
Entrada.read(Registro.Telef_Movil, 0, 9);
Entrada.read(Registro.Correo_Elect, 0, 30);
Entrada.read(Registro.Tipo, 0, 1);
}
private static void LeeCambio(FileReader Ent_Cambios, TipoCambio
Reg_Cambios) throws IOException
{
String Hv = "99"; // ZZ
if (Ent_Cambios.read(Reg_Cambios.Codigo, 0, 2) != -1)
{
LecturaCambio(Ent_Cambios,Reg_Cambios);
}
else
{
Reg_Cambios.Codigo = Hv.toCharArray();
}
}
public static void Actualiza() throws IOException
{
String Hv ="99";

// Archivo de amigos
File Arc_Amigos;
FileReader Ent_Amigos;
Arc_Amigos = new File("Amigos.txt");
Ent_Amigos = new FileReader(Arc_Amigos);

// Registro
TipoEjercicio Reg_Amigos;
Reg_Amigos = new TipoEjercicio();

// Archivo de incidencias
File Arc_Cambios;
FileReader Ent_Cambios;
Arc_Cambios = new File("Cambios.txt");
Ent_Cambios = new FileReader(Arc_Cambios);

// Registro
TipoCambio Reg_Cambios;
Reg_Cambios = new TipoCambio();

// Nuevo archivo de amigos, con las incidencias realizadas
File Arc_Nue_Amigos;
FileWriter Sal_Amigos;
Arc_Nue_Amigos = new File("Nuevo.txt");
Sal_Amigos = new FileWriter(Arc_Nue_Amigos);

// Registro
TipoEjercicio Reg_Sal_Amigos;
Reg_Sal_Amigos = new TipoEjercicio();
String Cod_Ami="00";
String Cod_Cam="00";
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
Cod_Cam = String.copyValueOf(Reg_Cambios.Codigo);
Cod_Ami = String.copyValueOf(Reg_Amigos.Codigo);

while ((Cod_Ami.compareTo(Hv) != 0 ) || (Cod_Cam.compareTo(Hv)
!= 0 ))
{
if (Cod_Cam.compareTo(Cod_Ami) > 0)
{ // copiar existente
GrabarActualiz(Sal_Amigos,
Reg_Amigos.Codigo,
Reg_Amigos.Nombre,
Reg_Amigos.Domicilio,
Reg_Amigos.Telef_Fijo,
Reg_Amigos.Telef_Movil,
Reg_Amigos.Correo_Elect);
LeeAmigo(Ent_Amigos,Reg_Amigos);
}
else if (Cod_Cam.compareTo(Cod_Ami)< 0)
{
switch (Reg_Cambios.Tipo[0])
{
case '1': // registro nuevo
GrabarActualiz(Sal_Amigos,
Reg_Cambios.Codigo,
Reg_Cambios.Nombre,
Reg_Cambios.Domicilio,
Reg_Cambios.Telef_Fijo,
Reg_Cambios.Telef_Movil,
Reg_Cambios.Correo_Elect);
LeeCambio(Ent_Cambios,Reg_Cambios);
break;
default: // Error de tipo de incidencia
// Incidencia Habra que imprimir o grabar incidencias
LeeCambio(Ent_Cambios,Reg_Cambios);
break;
}
}
else if (Cod_Cam.compareTo(Cod_Ami) == 0)
{
switch (Reg_Cambios.Tipo[0])
{
case '1': // alta, error
// Incidencia Habra que imprimir o grabar incidencias
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
case '2': // modificacin, se graba el nuevo
GrabarActualiz(Sal_Amigos,
Reg_Cambios.Codigo,
Reg_Cambios.Nombre,
Reg_Cambios.Domicilio,
Reg_Cambios.Telef_Fijo,
Reg_Cambios.Telef_Movil,
Reg_Cambios.Correo_Elect);
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
case '3': // baja, no se graba
LeeCambio(Ent_Cambios,Reg_Cambios);
LeeAmigo(Ent_Amigos,Reg_Amigos);
break;
}
}
Cod_Cam = String.copyValueOf(Reg_Cambios.Codigo);
Cod_Ami = String.copyValueOf(Reg_Amigos.Codigo);
}
Sal_Amigos.close();
Ent_Amigos.close();
Ent_Cambios.close();
}
}