UNIDAD II
ARCHIVO SECUENCIAL
SUBTEMAS
2.1 Estructura de la organización
secuencial.
2.2 Operación sobre archivos
secuenciales.
OBJETIVO
Comprenderá la estructura y las
operaciones de los archivos
secuenciales, sus aplicaciones,
ventajas y desventajas.
CRITERIOS DE EVALUACIÓN
•Examen 40 %
•Prácticas 20 %
•Tareas 20 %
•Participación 10 %
•Asistencia 10%
BIBLIOGRAFÍA
Cairó.
Estructuras de datos, 2ª Edición.
Ed. Mc Graw-Hill, 2001.
Mari E. Loomis.
Estructura de Datos y Administración de Archivos.
Ed. Mc Graw-Hill.
Heileman.
Estructuras de datos, algoritmos y programación orientada a
objetos.
Ed. Mc Graw-Hill 2001. 1997
Brassard y Bratley.
Fundamentos de Algoritmia.
Ed. Prentice Hall.
Recordando …
Fichero o archivo: Es una colección de información
que se almacena en un soporte magnético para
poderla manipular en cualquier momento.
Esta información se almacena como un conjunto de
registros, conteniendo todos ellos, generalmente,
los mismos campos. Cada campo almacena un dato
de tipo predefinido o de un tipo definido por el
usuario. El registro más simple estaría formado por
un carácter.
Fichero
Para manipular un fichero que identificamos por un
nombre, son tres las operaciones que tenemos que
realizar:
Abrir el fichero.
Escribir o leer registros.
Y cerrar el fichero.
Para dar soporte al trabajo con fichero, la biblioteca
de Java proporcionar varias clases de entrada/salida
(E/S) que permiten leer y escribir datos a, y desde,
ficheros y dispositivos.
Flujo de E/S
La comunicación entre el programa y el origen o el
destino de cierta información, se realiza mediante
un flujo de información (en inglés stream) que no es
más que un objeto que hace de intermediario entre
el programa, y el origen o el destino de la
información. Esto es, el programa leerá y escribirá
en el flujo sin importarle de donde viene la
información o a donde va y tampoco importa el tipo
de los datos que se leen o escriben.
Entonces, para que un programa pueda obtener
información desde un fichero tiene que abrir un
flujo y leer la información en él almacenada.
Abriendo fichero secuenciales
El tipo de acceso más simple a un fichero de datos es el
secuencial.
Un fichero abierto para acceso secuencial es un fichero
que puede almacenar registros de cualquier longitud,
incluso de un solo byte.
Cuando la información se escribe registro a registro, éstos
son colocados uno a continuación de otro, y cuando se
lee, se empieza por el primer registro y se continúa al
siguiente hasta alcanzar el final.
Este tipo de acceso generalmente se utiliza con ficheros
de texto en los que se escribe toda la información desde
el principio hasta el final y se lee de la misma forma.
Flujos de bytes
Los datos pueden ser escritos o leídos de un fichero byte a
byte utilizando un flujos de las clases FileOutputStream y
FileInputStream.
FileOutputStream
Un flujo de la clase FileOutputStream permite escribir
bytes en un fichero.
El siguiente ejemplo es una aplicación en Java que lee una
línea de texto desde el teclado y la guarda en un fichero
denominado texto.txt.
Ejemplo:
import java.io.*;
public class CEscribirBytes
{
public static void main ( String [ ] args )
{
FileOutputStream fs = null;
byte [ ] buffer = new byte [81];
int nbytes;
try
{
System.out.println ( “Escriba el texto que desea almacenar en el fichero: “);
nbytes = System.in.read(buffer);
fs = new FileOutputStream (“texto.txt”);
fs.write (buffer,0,nbytes);
}
catch (IOException e)
{
System.out.println (“Error: “ +e.toString());
}
}
}
¿Qué hace la aplicación?
1. Define una matriz buffer de 81 bytes.
2. Lee una línea de texto desde el teclado y la almacena en
buffer.
3. Define un flujo fs hacia un fichero denominado texto.txt.
Tenga presente que si el fichero existe , se borrará en el
momento de definir el flujo que permita su acceso, excepto si
especifica como segundo parámetro true.
FileOutputStream fs = new FileOutputStream (“texto.txt”);
3. Escribir explícitamente la línea de texto en el flujo. Esto se
hace cuando el flujo recibe el mensaje write, lo que origina
que se ejecute el método write, en este caso con tres
parámetros, el primero es una referencia a la matriz, el
segundo es la posición en la matriz del primer byte, y el
tercero, el número de bytes a escribir.
fs.write (buffer.0.nbytes);
Buscando el archivo texto.txt
1. Una vez que hemos ejecutado la aplicación , escrito la
línea y pulsado Entrar.
2. Nos vamos al MS-DOS (símbolo del sistema), y
escribimos la ruta en donde está guardado nuestro
archivo, para ello ocupamos el comando CD (cambio
de directorio):
C:\Users\SANDOVAL\Mis
documentos\NetbeansProjects\FlujosO>
3. En la línea de órdenes del sistema tecleamos
type texto.txt (para windows), o bien cat
texto.txt en UNIX, para mostrar el texto del
fichero y comprobar que todo funciona como se
esperaba.
Flujos de bytes
Si lo que deseamos es añadir información al fichero, cree el flujo hacia
el mismo:
fs = new FileOutputStream (“texto.txt”, true);
En este caso, si el fichero no existe se crea y si existe, los datos que se
escriban en él se añadirán al final.
También es recomendable cerrar un flujo cuando ya no se vaya a
utilizar más, quedando el código de la siguiente manera:
finally
{
try
{
// Cerrar el fichero
if (fs != null) fs.close();
}
}
Flujos de bytes
FileInputStream
Un flujo de la clase FileInputStream permite leer bytes
desde un fichero.
El siguiente ejemplo es una aplicación en Java que lee el
texto guardado en el fichero texto.txt creado por la
aplicación anterior y lo almacena en una matriz
denominada buffer.
Ejemplo:
finally
import java.io.*; {
public class CLeerBytes try
{ {
public static void main ( String [ ] args ) // Cerrar el fichero
{ if (fe != null) fe.close();
FileInputStream fe = null; }
byte [ ] buffer = new byte [81]; catch (IOException e)
int nbytes; {
try System.out.println (“Error: “
{ +e.toString());
fe = new FileInputStream (“texto.txt”); }
nbytes = fe.read(buffer, 0, 81); }
String str= new String (buffer, 0, }
nbytes); }
System.out.println (str);
}
catch (IOException e)
{
System.out.println (“Error: “
+e.toString());
}
¿Qué hace la aplicación?
1. Define una matriz buffer de 81 bytes.
2. Define un flujo fe desde un fichero denominado texto.txt.
Tenga presente que si el fichero no existe, se lanzará una
excepción indicándolo.
FileInputStream fe = new FileInputStream (“texto.txt”);
3. Lee el texto desde el flujo y lo almacena en buffer. Esto se
hace cuando el flujo recibe el mensaje read, lo que origina
que se ejecute el método read, en este caso con tres
parámetros, el primero es una referencia a la matriz, el
segundo es la posición en la matriz del primer byte, y el
tercero, el número de bytes que se leeran
nbytes = fe.read(buffer, 0, 81);
4. Crea un objeto String con los datos leídos:
Clase File
Un objeto de la clase File representa el nombre de un
fichero o de un directorio que puede existir en el sistema
de ficheros de la máquina.
La clase File proporciona los constructores siguientes:
Public File (String ruta_completa)
Public File (String ruta, String nombre)
Public File (File ruta, String nombre)
El primer constructor crea un objeto File a partir de un
nombre de fichero más su ruta de acceso (relativa o
absoluta).
Por ejemplo, el siguiente código crea un objeto File a
partir de la ruta relativa proyecto\texto.txt.
Clase File
File fichero = new File (“proyecto\\texto.txt”);
System.out.println (“Nombre del fichero: “+ fichero.getName());
System.out.println (“Directorio padre: ” + fichero.getParent());
System.out.println (“Ruta relativa: “ + fichero.getPath());
System.out.println (“Ruta absoluta: “ + fichero.getAbsolutePath());
Resultado:
Nombre del fichero: texto.txt
Directorio padre: proyecto
Ruta relativa : proyecto\texto.txt
Ruta absoluta:
C:\Users\SANDOVAL\Documents\NetBeansProjects\FicheroRutaA\proyecto\texto.txt
Clase File
El segundo constructor crea un objeto File a partir de una
ruta (absoluta o relativa) y un nombre de fichero
separado. Por ejemplo:
File fichero = new File (“proyecto”, “texto.txt”);
El tercer constructor crea un objeto File a partir de otro
que representa una ruta y un nombre de fichero
separado. Por ejemplo:
File dir = new File (“proyecto”);
File fichero = new File (dir, “texto.txt”);
Flujos de caracteres
File Writer
Un flujo de la clase File Writer permite escribir caracteres
(char) en un fichero.
La clase proporciona los siguientes constructores:
FileWriter (String nombre)
FileWriter (String nombre, boolean añadir)
FileWriter (File fichero)
El primer constructor abre un flujo de salida hacia el
fichero especificado por nombre, mientras el segundo
hace lo mismo, pero con la posibilidad de añadir datos a
un fichero existente (añadir=true); el tercero lo hace a
partir de un objeto File.
Flujos de caracteres
File Reader
Un flujo de la clase File Reader permite leer caracteres
desde un fichero.
La clase proporciona los siguientes constructores:
FileReader (String nombre)
FileReader (File fichero)
El primer constructor abre un flujo de entrada desde el
fichero especificado por nombre, mientras que el segundo
lo hace a partir de un objeto File.
Flujos de datos
Seguramente, en alguna ocasión desearemos escribir en
un fichero datos de tipos primitivos (boolean, byte,
double, float, long, int y short) para posteriormente
recuperarlos como tal. Para estos casos, el paquete java.io
proporciona las clases DataInputStream y
DataOutputStream, las cuales permiten leer y escribir,
respectivamente, datos de cualquier tipo primitivo.
Un flujo DataInputStream sólo puede leer datos
almacenados en un fichero a través de un flujo
DataOutputStream.
Flujos de datos
Los flujos de estas clases actúan como filtros; esto es, los
datos obtenidos del origen o enviados al destino son
transformados mediante alguna operación; en este caso
sufren una conversión a un formato portable (UTF-8:
Unicode ligeramente modificado) cuando son
almacenados y viceversa cuando son recuperados.
El procedimiento para utilizar un filtro es el siguiente:
•Se crea un flujo asociado con su origen o destino de los
datos.
•Se asocia un filtro con el flujo anterior.
•Finalmente, el programa leerá o escribirá datos a través
de ese filtro.
DataOutputStream
Un flujo de la clase DataOutputStream, deriva
indirectamente de OutputStream, permite a una
aplicación escribir en un flujo de salida subordinado, datos
de cualquier tipo primitivo.
Todos los métodos proporcionados por esta clase están
definidos en la interfaz DataOutput implementada por la
misma.
DataInputStream
Un flujo de la clase DataInputStream, deriva
indirectamente de InputStream, permite a una aplicación
leer en un flujo de entrada subordinado, datos de
cualquier tipo primitivo escritos por un flujo de la clase
DataOutputStream.
Todos los métodos proporcionados por esta clase están
definidos en la interfaz DataInput implementada por la
misma.
En resumen…
La metodología de trabajo para escribir datos en un
fichero es la siguiente:
•Definimos un flujo hacia el fichero en el que deseamos
escribir datos.
•Leemos los datos del dispositivo de entrada o de otro
fichero y lo escribimos en nuestro fichero. Este proceso se
hace normalmente registro a registro. Para ello se utiliza
los métodos proporcionados por la interfaz del flujo.
•Cerramos el flujo.
En resumen…
La metodología para leer datos de un fichero existente es
la siguiente:
•Abrimos un flujo desde el fichero del cual queremos leer
los datos.
•Leemos los datos del fichero y los almacenamos en
variables de nuestro programa con el fin de trabajar con
ellos. Este proceso se hace normalmente registro a
registro. Para ello se utilizan los métodos proporcionados
por la interfaz del flujo.
•Cerramos el flujo.
