You are on page 1of 28

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.