Fecha y hora actual: Jueves 17 Ene 2019 04:53
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Curso VB .NET - Tema 1.40.3 - Archivos secuenciales, Java.

Responder al Tema

Índice del Foro > Visual Basic .NET > Curso VB .NET - Tema 1.40.3 - Archivos secuenciales, Java.

Autor Mensaje
Tesis
Administrador


Registrado: 04 Mar 2007
Mensajes: 3200
Ubicación: Valencia - España

Mensaje Publicado: Lunes 25 Ene 2010 12:33

Título del mensaje: Curso VB .NET - Tema 1.40.3 - Archivos secuenciales, Java.

Responder citando

Curso de programación 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 grabación, que es el más estándar de todos.

1.2 Introducción.
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 excepción, y también podríamos enfocarlo al revés, 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 además la longitud puede ser variable, siempre y cuando se esté utilizando el formato de ASCII delimitado, que incorpora la delimitación de campos y de final de registro.

1.3 Proceso de actualización.
El proceso de actualización 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 programación, pero no por ello menos efectivo.
La filosofía 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.
Código:
String Hv = "99"; // ZZ

El valor más adecuado sería el de "ZZ"

El proceso se basa en que solo puede haber proceso de actualización si los códigos coinciden, en ese caso puede darse el caso de borrado o actualización, pero nunca un alta, eso sería un error.
Si el código del archivo principal se adelanta al de los cambios, significa que los registros hasta igualarse deben ser del tipo alta, en caso contrario sería un error en la grabación del archivo de cambios.

Si el código del archivo principal se queda por detrás significa que ese código 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.
Código:
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 código de ese archivo se le asigna el high value.
Código:
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 combinación, cuyo único resultado al final es maquiavélico, comparado con la sencillez de éste proceso.
Código:
while ((Cod_Ami.compareTo(Hv) != 0 ) || (Cod_Cam.compareTo(Hv) != 0 ))


A continuación exponemos el núcleo del proceso.
Código:
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 Habría 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 Habría que imprimir o grabar incidencias
               LeeCambio(Ent_Cambios,Reg_Cambios);
               LeeAmigo(Ent_Amigos,Reg_Amigos);
               break;
            case '2': // modificación, 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 instrucción Ent_Amigos.close();
Y se cierra cada uno de los archivos que nos interesa.

1.5 Comentarios.
El proceso de actualización de archivos secuenciales expuesto, parte de que sería 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 cuestión de elegir en cada momento la más apropiada.

Pero si que hay que tener presente que la correcta, filosóficamente, es la aquí expuesta, las demás soluciones basadas en estructuras de datos en memoria, tienen un límite, que es la capacidad de recursos del equipo en el que se ejecuten.

1.6 Ejercicios propuestos.

  1. Realice el proceso de actualización del archivo de amigos con los datos del archivo de cambios del tema anterior.

1.7 Solución a los ejercicios propuestos.
1.-Realice el proceso de actualización del archivo de amigos con los datos del archivo de cambios del tema anterior.

Código:
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 Habría 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 Habría que imprimir o grabar incidencias
               LeeCambio(Ent_Cambios,Reg_Cambios);
               LeeAmigo(Ent_Amigos,Reg_Amigos);
               break;
            case '2': // modificación, 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:
Código:
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.
Código:
import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;


El código completo.
Código:
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 Habría 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 Habría que imprimir o grabar incidencias
                  LeeCambio(Ent_Cambios,Reg_Cambios);
                  LeeAmigo(Ent_Amigos,Reg_Amigos);
                  break;
               case '2': // modificación, 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();
   }
}



Autor del curso: casiopea


Normas del foro
Aprende a postear correctamente usando las etiquetas
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

necesito ayuda con el algoritmo de dijkstra en ...

mery Python 0 Jueves 13 Dic 2018 18:07 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Ayuda con TestNG Parametrico en java netbeans

baltigo Java 0 Sábado 30 Jun 2018 01:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Publicar Aplicación web JAVA en tomcat

Irvin Java Web 1 Viernes 13 Oct 2017 17:54 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Imagen referencial De creación de jtable en apl...

Jensel S.G Java 6 Miércoles 13 Sep 2017 20:06 Ver último mensaje
El tema está bloqueado: no pueden editarse ni agregar mensajes.

EMPLEO ANALISTA PROGRAMADOR/A BACK-END JAVA EE

GRUPOARESTORA Bolsa de trabajo 0 Viernes 23 Jun 2017 14:33 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,