UNIVERSIDAD DE GUAYAQUIL

FACULTAD DE CIENCIAS MATEMATICAS Y FISICAS

CARRERA: INGENIERÍA EN NETWORKING Y

TELECOMUNICACIONES
TEMA:

• GESTIÒN BASICA DE ARCHIVOS

• ACCESO SECUENCIAL, ALEATORIO, MODO DE ESCRITURA,

LECTURA
• MODO CARÁCTER

• MODO BYTES

• MODO ALEATORIO

INTEGRANTES:

PEREZ CHOEZ CARLOS ANDRES

MABEL QUIÑONEZ CASTILLO
KATHIA QUINDE PIN
JHON PARRAGA DONAIRA

MATERIA:

PROGRAMACION PARA REDES

CURSO:

6-1
DOCENTE:

ING.

AÑO LECTIVO:
 2020-2021

Indice
GESTIÒN BASICA DE ARCHIVOS.............................................................................2

ACCESO SECUENCIAL, ALEATORIO, MODO DE ESCRITURA, LECTURA...3

MODO CARACTER.....................................................................................................11

Modo Bytes:...................................................................................................................13

Entrada y Salida de Tipos Primitivos: las

clases DataInputStream y DataOutputStream................................................................13

Entrada y Salida con Ficheros: las clases FileInputStream y FileOutputStream.......14

Modo aleatorio...............................................................................................................16

RandomaccessFile.....................................................................................................16
 GESTIÒN BASICA DE ARCHIVOS
Los programas usan variables para almacenar información: los datos de
entrada, los resultados calculados y valores intermedios generados a lo largo del
cálculo. Toda esta información es efímera: cuando acaba el programa, todo
desaparece. Pero, para muchas aplicaciones, es importante poder almacenar
datos de manera permanente. Cuando se desea guardar información más allá
del tiempo de ejecución de un programa lo habitual es organizar esa información
en uno o varios ficheros almacenados en algún soporte de almacenamiento
persistente. Otras posibilidades como el uso de bases de datos utilizan archivos
como soporte para el almacenamiento de la información.

Los archivos desde el bajo nivel

Desde el punto de vista de más bajo nivel, podemos definir un archivo (o

fichero) como:

Un conjunto de bits almacenados en un dispositivo, y accesible a través de un

camino de acceso (pathname) que lo identifica. Es decir, un conjunto de 0s y 1s
que reside fuera de la memoria del ordenador, ya sea en el disco duro, un
pendrive, un CD, entre otros.

El criterio del contenido

Sabemos que es diferente manipular números que Strings, aunque en el fondo

ambos acaben siendo bits en la memoria del ordenador. Por eso, cuando
manipulamos archivos, distinguiremos dos clases de archivos dependiendo del
tipo de datos que contienen:

• Los archivos de caracteres (o de texto)

• Los archivos de bytes(o binarios)

Un fichero de texto es aquel formado exclusivamente por caracteres y que, por

tanto, es aquel formado exclusivamente por caracteres y que, por lo tanto, puede
crearse y visualizarse usando un editor. Las operaciones de lectura y escritura
trabajarían con caracteres. Pero ejemplo, los ficheros con código java son
ficheros de texto.
 En cambio, un fichero binario ya no está formado por caracteres sino que los
bytes, que contienen pueden representar otras cosas como números, imágenes,
sonido, etc.

Los archivos desde java

En Java, los distintos tipos de ficheros se diferencian por las clases que
usaremos para representarlos y manipularlos.

Como las clases que usaremos pertenecen a la biblioteca estándar del

lenguaje, su uso es algo más complejo que las de las clases de la ACM, ya que
su diseño se ha realizado pensando en su uso industrial.

Las clases que usaremos para el tratamiento de ficheros están ubicadas en el

paquete java.io por lo que deben ser importadas.

Además, el código que trabaja con archivos ha de considerar que muchas

cosas pueden ir mal cuando se trabaja con ellos: el archivo puede estar corrupto,
alguien ha desconectado el pendrive a medio ejecutar del programa, es un disco
en red y ésta ha caído, o no tiene más espacio para almacenar información, etc.

ACCESO SECUENCIAL, ALEATORIO, MODO DE ESCRITURA,

LECTURA
Existen dos modos básicos de acceso a la información contenida en un
archivo:

• Acceso directo

• Secuencial

Modo de acceso directo

El modo de acceso directo nos permite acceder directamente a la información

del byte i--‐ésimo. Un ejemplo muy conocido de acceso directo lo tenemos con
los vectores (arrays).

Modo secuencial

Es la forma básica de organizar un conjunto de registros, que forman un

archivo, utilizando una organización secuencial. En un archivo organizado
secuencialmente, lo registros quedan grabados consecutivamente cuando el
archivo se utiliza como entrada. En la mayoría de los casos, los registros de un
archivo secuencial quedan ordenados de acuerdo con el valor de algún campo
de cada registro. Semejante archivo se dice que es un archivo ordenado; el
campo, o los campos, cuyo valor se utiliza para determinar el ordenamiento es
conocido como la llave del ordenamiento. Un archivo puede ordenarse
ascendente o descendentemente con base en su llave de ordenamiento.

La forma más común de estructura de archivo es el archivo secuencial. En

este tipo de archivo, un formato fijo es usado para los registros. Todos los
registros tienen el mismo tamaño, constan del mismo número de campos de
tamaño fijo en un orden particular. Como se conocen la longitud y la posición de
cada campo, solamente los valores de los campos se necesitan almacenarse; el
nombre del campo y longitud de cada campo son atributos de la estructura de
archivos.

Grafico 1- Ejemplo de archivo secuencial

Escritura de los archivos secuenciales

En estos archivos, la información sólo puede leerse y escribirse empezando

desde el principio del archivo. Los archivos secuenciales tienen algunas
características que hay que tener en cuenta:

• La escritura de nuevos datos siempre se hace al final del archivo.

• Para leer un dato concreto del archivo hay que avanzar siempre hasta

donde se
 encuentre dicho dato. Si el dato requerido se encuentra antes del dato en que
está se está posicionado el archivo en un momento dado, será necesario
regresar al comienzo del archivo y avanzar hasta el dato necesario.

Almacenamiento de archivos secuenciales. Los archivos

secuenciales pueden almacenarse en dispositivos de acceso serial o
directo. Con frecuencia los dispositivos de acceso serial son
considerablemente menos caros que los dispositivos de acceso directo en
un sistema de cómputo, pero de hecho, los dispositivos de almacenamiento
de acceso directo en una computadora siempre proporcionan mayor
capacidad de almacenamiento y acceso más rápido que los dispositivos de
acceso serial.

Grafico 2- Almacenamiento de archivos secuenciales

Acceso Aleatorio

La clase RandomAccessFile permite abrir un archivo como de lectura, o de

lectura y escritura simultáneamente. Si se utiliza para lectura del archivo (modo
“r”), dispone de métodos para leer elementos de cualquier tipo
primitivo: readInt(), readLong(), readDouble, readLine() y otros. Así mismo,
cuando se utiliza el modo de lectura y escritura (modo “rw”) se puede utilizar los
métodos de escritura para escribir los tipos de datos de forma similar a como se
pueden leer, con los métodos: writeInt(), writeLong(), writeDouble, writeBytes()…

Los métodos que resultan de interés para el acceso aleatorio son los que
permiten acceder a un lugar concreto dentro del archivo y conocer el punto del
mismo en el que se va a realizar la operación de lectura y/o escritura:
 • getFilePosition(): Devuelve la posición actual donde se va a realizar la

operación de lectura o escritura. Devuelve la posición, contando en bytes

donde se encuentra actualmente el cursor del archivo.

• seek(): Sitúa la posición de la próxima operación de lectura o escritura

en el byte especificado.

• length(): Devuelve el tamaño actual del archivo.

En el siguiente ejemplo, lo que hace es convertir a mayúsculas todos los

caracteres ‘i’ que encuentre. Cuando una encuentra una i minúscula vuelve una
posición atrás de donde la había leído y escribe el mismo carácter convertido a
mayúsculas. El resultado es que el archivo de texto aparece con todas letras i en
mayúsculas.

import java.io.EOFException;

import java.io.FileNotFoundException; import java.io.IOException;

import java.io.RandomAccessFile; public class ArchivoAleatorio {

public static void main(String[] args) throws IOException {

char c;

boolean finArchivo = false; RandomAccessFile archivo = null;

try {

archivo = new RandomAccessFile(“prueba.txt”, “rw”); System.out.println(“El

tamaño es: ” +

archivo.length());

do {
 1);

archivo.writeByte(Character.toUpperCase(c));

} catch (EOFException eof) { finArchivo = true; archivo.close();

System.out.println(“Convertidas a

mayusculas”);

} while (!finArchivo);

} catch (FileNotFoundException fe) { System.out.println(“No se encontro el

archivo”);

Los métodos de la clase RandomAccessFile generan una excepción,

EOFException, para indicar que se ha intentado llegar fuera del archivo. Por eso,
para detectar que se ha terminado de leer se utiliza una variable finArchivo, que vale
false mientras se siga leyendo el archivo. Cuando se genere la excepción
EOFException, se captura, se cierra el archivo y se pone el valor true en la variable
finArchivo. Al cambiar este valor, termina el bucle de lectura.

Modo escritura y lectura

En el lenguaje Java los flujos de datos se describen mediante clases que forman
jerarquías según sea el tipo de dato char Unicode de 16 bits o byte de 8 bits. A su
vez, las clases se agrupan en jerarquías según sea su función de lectura o de
escritura. La característica de internacionalización del lenguaje Java es la razón por
la que existe una jerarquía separada de clases para la lectura y escritura de
caracteres. Todas estas clases se encuentran en el paquete java.io, por lo que al
principio del código fuente se deberá escribir la sentencia
Ilustración 1- Sentencia

CHAR UNICODE, 16 bits

Ilustración 2-Char Unicode

BYTE, 8 bits

Ilustración 3- Byte
 Lectura

Las clases Reader e InputStream son similares aunque se refieren a distintos

tipos de datos, lo mismo ocurre con Writer y OutputSream. Por ejemplo, Reader
proporciona tres métodos para leer un carácter char o un array de caracteres

Ilustración 4- Modo Lectura

InputStream proporciona métodos similares para leer un byte o un array de bytes.

Ilustración 5-Otras maneras de lecturas

La primera versión lee un byte como entero del flujo de entrada, devuelve – 1 si
no hay más datos que leer. La segunda versión, lee un array de bytes devolviendo el
número de bytes leídos. La tercera versión, lee también, un array de bytes, pero nos
permite especificar, la posición de comienzo del array en la que se empiezan a
guardar los bytes, y el máximo número de bytes que se van a leer.

Métodos de lectura

La lectura del fichero se realiza con una función que depende del tipo de datos
que queremos leer.

• BooleanreadBoolean (); Lee un byte y devuelve false si vale 0 o true sino.

• byte readByte (); Lee y devuelve un byte.

• CharreadChar (); Lee y devuelve un caracter.

• DoublereadDouble (); Lee 8 bytes, y devuelve un double.

• floatreadFloat(); Lee 4 bytes, y devuelve un float.

• VoidreadFully (byte b []); Lee bytes del fichero y los almacena en un vector

b.

• VoidreadFully (byte b [], intini, intlen); Lee len bytes del fichero y los
 almacena en un vector b.

• IntreadInt (); Lee 4 bytes, y devuelve un int.

• LongreadLong (); Lee 8 bytes, y devuelve un long.

• ShortreadShort (); Lee 2 bytes, y devuelve un short.

• IntreadUnsignedByte (); Lee 1 byte, y devuelve un valor de 0 a 255.

• IntreadUnsignedShort (); Lee 2 bytes, y devuelve un valor de 0 a 65535.

• StringreadUTF (); Lee una cadena codificada con el formato UTF-8.

• IntskipBytes (int n); Salta n bytes del fichero.

Si no es posible la lectura devuelven –1.

Escritura

La clase Writer proporciona tres métodos para escribir un carácter char o un array
de caracteres

La clase OutputStream proporciona métodos similares

Ilustración 7- Otras maneras de escrituras Ilustración 6-Modo Escritura

Métodos de escritura

La escritura del fichero se realiza con una función que depende el tipo de datos
que se desee escribir.

• Voidwrite byte b [], intini, intlen); Escribe len caracteres del vector b.

• Voidwrite (int i); Escribe la parte baja de i (un byte) en el flujo.

• VoidwriteBoolean (boolean b); Escribe el boolean b como un byte.

• VoidwriteByte (int i); Escribe i como un byte.

 • VoidwriteBytes (String s); Escribe la cadena s tratada como bytes, no

caracteres.

• VoidwriteChar (inti); Escribe i como 1 byte.

• VoidwriteChars ( String s); Escribe la cadena s.

• VoidwriteDouble (double d); Convierte d a long y le escribe como 8 bytes.

• VoidwriteFloat (float f); Convierte f a entero y le escribe como 4 bytes.

• VoidwriteInt (inti); Escribe i como 4 bytes.

• VoidwriteLong (long v); Escribe v como 8 bytes.

• VoidwriteShort (inti); Escribe i como 2 bytes.

• VoidwriteUTF (String s); Escribe la cadena s utilizando la codificación UTF-

Los métodos que escriben números de más de un byte escriben el primero su

parte alta.

MODO CARACTER
En Java los caracteres no están restringidos a los ASCII sino son Unicode. Un
carácter está siempre rodeado de comillas simples como 'A', '9', 'ñ', etc. El tipo de
dato char sirve para guardar estos caracteres.

Un tipo especial de carácter es la secuencia de escape, similares a las del

lenguaje C/C+

+, que se utilizan para representar caracteres de control o caracteres que no se

imprimen. Una secuencia de escape está formada por la barra invertida (\) y un
carácter. En la siguiente tabla se dan las secuencias de escape más utilizadas.

Carácte Secuencia de
r escape
 retorno \r
de
carro
tabulad \t
or
horizontal
nueva \n
línea
barra \\
invertida

1.1Las cadenas de caracteres o strings

Además de los ocho tipos de datos primitivos, las variables en Java pueden ser
declaradas para guardar una instancia de una clase, como veremos en el siguiente
capítulo (Clases y objetos).

Las cadenas de caracteres o strings son distintas en Java y en el lenguaje C/C++,

en este último, las cadenas son arrays de caracteres terminados en el carácter '\0'.
Sin embargo, en Java son objetos de la clase String.

String mensaje="El primer programa";

Empleando strings, el primer programa quedaría de la forma equivalente

public class PrimeroApp{

public static void main(String[] args) {

//imprime un mensaje

String mensaje="El primer programa"; System.out.println(mensaje);

}
 En una cadena se pueden insertar caracteres especiales como el carácter
tabulador '\t' o el de nueva línea '\n'

String texto="Un string con \t un carácter tabulador y \n un salto de línea";

 try {

c = (char) archivo.readByte(); if (c == ‘i’) {

archivo.seek(archivo.getFilePointer() –

Modo Bytes:

Entrada y Salida de Tipos Primitivos: las

clases DataInputStream y DataOutputStream

Aunque leer y escribir bytes es util, a menudo es necesario transmitir datos de

tipos primitivos dentro de un flujo.

Las clases DataInputStream y DataOutputStream proporcionan métodos para la

lectura y escritura de tipos primitivos de un modo independiente de la máquina. Así
proporcionan los siguientes pares de métodos lectura/escritura:
readBoolean y writeBoolean, readChar y writeChar, readByte y writeByte, readUnsig
nedByte y writeUnsignedByte, readShort y writeShort, readUnsignedShort y writeUns
ignedShort, readInt y writeInt, readLong y writeLong, readFloat y writeFloat, readDou
ble y writeDouble, readUTF y writeUTF (UTF es Unicode Transmition Format, que se
utiliza para transmitir los caracteres de un String de 16 bits codificada en 8 bits.)

Además de estos métodos la clase DataInputStream proporciona varios métodos

más:

 void readFully(byte [] buf) lee bytes en buf. Tambien existe la

version readFully (byte [] buf, int offset, int count).
 int skipBytes(int n) salta n bytes.
 String readLine() lee un String hasta que se alcanza una \n un \r o un par \r\n.
La secuencia final no es incluida en la cadena. Si se alcanza el final de la
entrada se devuelve el null.
 La clase DataOutputStream proporciona también un conjunto de métodos aparte
de los dedicados a escribir los tipos primitivos. Proporciona signaturas equivalentes
a los tres métodos write de la clase OutputStream y además los siguientes métodos:

 void writeBytes(String s) escribe un String como una secuencia de bytes,

perdiendo el byte superior de cada caracter.
 void writeChars(String s) escribe un String como una secuencia de
caracteres.

Entrada y Salida con Ficheros: las

clases FileInputStream y FileOutputStream

Gran parte de la entrada y salida de los programas se realiza basandose en

ficheros y para ello java.io aporta dos clases. Una para ficheros de
entrada, FileInputStream, y otra para ficheros de salida, FileOutputStream.

FileInputStream

A FileInputStream obtiene bytes de entrada de un archivo en un sistema de

archivos. Los archivos disponibles dependen del entorno del host.
 FileInputStream está diseñado para leer flujos de bytes sin procesar, como datos
de imagen. Para leer flujos de caracteres, considere usar FileReader.

Detalle del constructor

public FileInputStream (  nombre de cadena )

lanza FileNotFoundException

Crea un FileInputStream abriendo una conexión a un archivo real, el archivo

nombrado por el nombre de la ruta name en el sistema de
archivos. Se FileDescriptor crea un nuevo objeto para representar esta conexión de
archivo.

Ejemplo

1. try {
2. File file = new File(nombreFichero);
3. InputStream inputStream = new FileInputStream(file);
4. } catch (FileNotFoundException e) {
5. System.out.println("Fichero no encontrado");
6. }

FileOutputStream

Un flujo de salida de archivo es un flujo de salida para escribir datos en a File o en

a FileDescriptor. Si un archivo está disponible o puede crearse depende de la
plataforma subyacente. Algunas plataformas, en particular, permiten que un archivo
se abra para escritura por solo un FileOutputStream (u otro objeto de escritura de
archivos) a la vez. En tales situaciones, los constructores de esta clase fallarán si el
archivo involucrado ya está abierto.

FileOutputStreamestá diseñado para escribir flujos de bytes sin procesar, como

datos de imagen. Para escribir secuencias de caracteres, considere usar FileWriter.

Detalle del constructor

public FileOutputStream (  nombre de cadena )

 lanza FileNotFoundException
Crea una secuencia de salida de archivo para escribir en el archivo con el nombre
especificado. Se FileDescriptor crea un nuevo objeto para representar esta conexión
de archivo.

Ejemplo

1. try {
2. File file = new File(nombreFichero);
3. OutputStream outputStream = new FileOutputStream(file);
4. outputStream.write(bytes);
5. } catch (FileNotFoundException e) {
6. System.out.println("Fichero no encontrado");
7. } finally {
8. outputStream.close();
9.
10. }

Modo aleatorio
RandomaccessFile

La clase RandomAccessFile permite abrir un archivo como de lectura, o de lectura

y escritura simultáneamente. Si se utiliza para lectura del archivo (modo “r”), dispone
de métodos para leer elementos de cualquier tipo
primitivo: readInt(), readLong(), readDouble, readLine() y otros.

Los métodos que resultan de interés para el acceso aleatorio son los que
permiten acceder a un lugar concreto dentro del archivo y conocer el punto de este
en el que se va a realizar la operación de lectura y/o escritura:

1. getFilePosition(): Devuelve la posición actual donde se va a realizar la

operación de lectura o escritura. Devuelve la posición, contando en bytes
donde se encuentra actualmente el cursor del archivo.
2. seek(): Sitúa la posición de la próxima operación de lectura o escritura en el
byte especificado.
 3. length(): Devuelve el tamaño actual del archivo.

Ejemplo

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class ArchivoAleatorio {
    public static void main(String[] args) throws IOException {
        char c;
        boolean finArchivo = false;
        RandomAccessFile archivo = null;
        try {
            archivo = new RandomAccessFile(“prueba.txt”, “rw”);
            System.out.println(“El tamaño es: ” + archivo.length());
            do {
                try {
                    c = (char) archivo.readByte();
                    if (c == ‘i’) {
                        archivo.seek(archivo.getFilePointer() – 1);
                        archivo.writeByte(Character.toUpperCase(c));
                    }
                } catch (EOFException eof) {
                    finArchivo = true;
                    archivo.close();
                    System.out.println(“Convertidas a mayusculas”);
                }
            } while (!finArchivo);
        } catch (FileNotFoundException fe) {
            System.out.println(“No se encontro el archivo”);
        }
    }
}