Instituto Tecnológico de Chetumal

Programación

“ARCHIVOS”

Alejandra Martínez Ochoa

19390058

28 de abril del 2020

1
 ARCHIVOS

Un programa nos puede servir para conseguir datos que nosotros necesitemos, o que el
cliente necesite, basta con pedir esos datos, pero estos solamente se guardan y existen
durante la ejecución del mismo. Cuando salimos del programa, todo lo que se genero y
guardo se pierde.

Muchas veces surge la necesidad, que se guarden los datos permanentemente,

principalmente para que en un futuro se pueda acceder a ellos, y manipularlos, e incluso
enviar o recibir información de la red. El uso de archivos en Java para conseguir la
persistencia de datos es algo indispensable en la programación. Para ello, debemos conocer
distintos conceptos en torno al tema archivos, y algunas de las clases de la biblioteca
estándar de Java; al igual que nos toparemos con excepciones, y trataremos esos errores de
la manera correcta para conseguir el funcionamiento correcto de nuestro programa.

Los programas que creamos, almacenan información en las variables, objetos, arrays, etc
para almacenar la información, desde los datos de entrada, hasta los resultados de los
cálculos y los valores que se van teniendo durante dicho calculo. Pero toda esta información
es volátil. Esta se guarda en la memoria RAM de nuestro computador, la cual, al acabar la
ejecución, borra automáticamente toda la información. Es necesario almacenar dicha
información en uno, o varios ficheros almacenados en algún dispositivo físico (disco duro, CD,
usb, etc). Los flujos de datos en java confieren a los programas la capacidad de poder
interactuar con otros dispositivos de E/S o la misma memoria

Se define a un archivo como “un conjunto de bits almacenados en un dispositivo, y accesible a

través de un camino de accedo (pathname) que lo identifica” -J.M Gimeno

Desde el punto de vista de la programación, los archivos podrían proporcionar diferentes

funcionalidades (métodos) para su manipulación. Tenemos a los archivos de caracteres (o de
texto) los cuales contienen exclusivamente información que se quiere almacenar para ser
leído por una persona normal, y pueden crearse y visualizarse usando un editor de texto; y los
archivos de bytes (binarios) están formados simplemente por bytes y que pueden representar
cosas como números, imágenes, sonidos, etc.

2
Un flujo de datos en java es lo que permite que un programa realizado en Java u otro lenguaje
de programación pueda leer o escribir datos en otro periférico, programa, etc. Por ejemplo,
podemos leer o escribir datos usando flujos de datos en archivos del disco duro, escribir
usando el teclado (Tal como hacemos con la clase EntDatos), leer o escribir en un DVD,
realizar impresiones, etc.

¿Cómo se abordan los flujos de datos?

Usamos el flujo de bytes cuando queremos enviar información por la red, que genera tu
programa. Cuando se quiere almacenar información que una persona quiere leer usamos el
Flujo de caracteres.

Para el Flujo de bytes, haríamos uso de dos clases: InputStream para ver la información de
bytes almacenada en un archivo y OutputStream para escribir informacion en bytes en un
archivo o fichero. Todas las clases que hacen referencias al acceso de información a
secuencias de datos, pertenecen al paquete java.io.

Para el Flujo de caracteres usaremos las clases Reader y Writer, también pertenecientes al
paquete java.io.

ACCEDER A LA INFROMACION DE UN FICHEO

La clase FILEWRITER nos permite la escritura de flujos de caracteres, es decir, una cadena
de letras. Esta hereda de la clase OutputStreamWriter. Usaremos el constructor FileWriter(File
file). Para poder acceder a un archivo, y escribir en él.

1. Guardamos el texto que queremos escribir en una variable.

String frase= “Esto es una prueba”
2. Accedemos al archivo que usaremos, usando la clase FileWriter y el constructor
fileWriter():
Para escribir en un archivo existente:

FileWriter nom_instancia = new FileWriter(“Direccion del fichero al que accederemos”);

Para crear un archivo y escribir en el:

FileWriter nom_instancia = new FileWriter(“Ruta del archive que queremos crear”, true);

3
 3. Introducimos el texto deseado en el archivo seleccionado, usando el método write
For (int=0; i<frase.length(); i++) {
Nom_instancia.write(frase.charAt(i)); }
4. Al usar la clase FileWriter, que extiende de IOException, nuestro programa marca una
excepción, la cual tendríamos que reparar con la cláusula Try / catch.
5. Algo indispensable, y que no debemos olvidar, es cerra el flujo de datos, para esto,
usamos el método close(). Esto normalmente se pone después del Try catch, y no es
necesario usar la cláusula finally, más bien, depende del uso y propósito de tu
programa.
Escritura.close();

La clase FILEREADER nos permite leer información de un fichero ya existente. Esta clase
tiene métodos que nos permiten leer caracteres

1. Almacenamos el archivo que deseamos leer

FileWriter nombre = new fileWriter (“ruta del archive a leer”);
2. La apertura del fichero y su posterior lectura pueden lanzar excepciones que debemos
capturar. Por ello, la apertura del fichero y la lectura debe meterse en un bloque try-
catch.
3. Empezamos a leer la información, para eso utilizamos read(), el cual nos devuelve un
dato de tipo entero, devuelve todos los caracteres leídos hasta el -1(final).
Int c= nombre.read();
While (c! =-1){
c= nombre.read();
char letra= (char)c;
System.out.println(letra);}

BUFFERS

Cuando un archivo tiene muchos caracteres, en este momento, el método usado se vuelve
poco eficiente. Para esto, creamos un Buffer, el cual, es una memoria interna que se coloca
físicamente en la parte media entre el programa y el archivo externo que queremos usar.

4
En vez de acceder directamente desde nuestro código al archivo, lo haremos a la memoria
interna (Buffer), de tal forma que la información contenida en el archivo de texto se almacena
directamente al Buffer, y el programa accede y descarga poco a poco.

Para esto, usamos la clase BufferedReader para crear un buffer para leer información, y la
clase BufferedWriter para escribir.

ReadLine() lee línea a línea el texto de un archivo y te devuelve la línea entera. Cuando
hacemos uso de esta, el programa devuelve null cuando no encuentra más líneas.

Para hacer uso del buffer, es en parte lo mismo que el método anterior.Tienes que crear una
instancia de tipo BufferedReader donde se almacenara la ruta de tu archivo.Y con la ayuda de
un bucle while, recorrer todo el archivo hasta que el método readline devuelva null que
indicará que se ha llegado al final del archivo leido.

FLUJO DE BYTES
Para ficheros binarios se hace exactamente igual, pero en vez de usar los "Reader" y los
"Writer", se usan los "InputStream" y los "OutputStream". En lugar de los readLine() y println(),
hay que usar los métodos read() y write() de array de bytes. Para hacer uso de este, se crea
un instancia de la clase FileInputStream.
Para abrir un FileInputStream sobre un archivo, se le da al constructor un String o un objeto
File:
FileInputStream mi ArchivoSt;
miArchivoSt = new FileInputStream( "/etc/kk" );
Una vez abierto el FileInputStream, se puede leer de él. El método read() tiene muchas
opciones:
int read(); //Lee un byte y devuelve -1 al final del stream.
Para abrir un objeto FileOutputStream, se tienen las mismas posibilidades que para abrir un
archivo stream de entrada. Se le da al constructor un String o un objeto File.
FileOutputStream miArchivoSt; miArchivoSt = new FileOutputStream( "/etc/kk" );
Una vez abierto el archivo, se pueden escribir bytes de datos utilizando el método write().
Como con el método read() de los streams de entrada, tenemos tres posibilidades:
void write( int b );//Escribe un byte.
SERIALIZACIÓN

5
Consiste en convertir un objeto que hayamos creado en una sucesión de bytes, para poder
almacenarlo en un medio de almacenamiento, y en un futuro poder restaurar el objeto al
estado en el que estaba cuando fue serializado.
Para que un objeto sea serializable, basta con implementar la clase Serializable en la clase en
la cual, puede estar el objeto que queremos serializar.
Cualquier clase que desee poder serializar sus objetos debe implementar la interfaz
Serializable. En esta implementación el objeto define cómo debe almacenarse o recuperarse
de un fichero con los métodos
• writeObject: responsable de escribir el estado del objeto en el flujo
• readObject: responsable de recuperar el estado del objeto desde el flujo.
Si se trata de serializar un objeto que no lo implementa se obtiene la excepción
NotSerializableException
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException
{ // Aquí debemos leer los bytes de stream y reconstruir el objeto }
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException
{ // Aquí escribimos en stream los bytes que queramos que se envíen por red. }
Durante la serialización, Java Runtime asocia un número de versión con cada clase
serializable. Este número se llama serialVersionUID, que se utiliza durante la deserialización
para verificar que el emisor y el receptor de un objeto serializado hayan cargado clases para
ese objeto que son compatibles con respecto a la serialización. Si el receptor ha cargado una
clase para el objeto que tiene una clase diferente serialVersionUIDa la de la clase del
remitente correspondiente, la deserialización dará como resultado un InvalidClassException.
Todos los programas tienen un numero identificativo (SHA), esto quiere decir, que cada
programa tiene su número propio, o más bien, su huella única (sucesión de 20 bytes). Esta
huella la realiza el compilador de Java con cálculos complejos analizando cómo está
construido ese programa y genera la huella. Por lo tanto, ambos deben tener el mismo
programa con el mismo número de serialVersionUID.
Una clase serializable puede declarar explícitamente su propio serialVersionUID declarando
un campo llamado " serialVersionUID" que debe ser estático, final y de tipo largo.
¿Qué ocurre cuando se cambia de versión el programa que se encarga de serializar el
programa?
Java hace una comprobación muy estricta a la hora de serializar objetos, de que el objeto
serializado tiene el mismo serialVersionUID que el programa va a tratar de leer el objeto.

6
Un problema común que surge es que al crear un objeto serializado en una nueva versión del
programa se envía al receptor con una versión del programa antigua este no podrá leer el
objeto serializado. La solución de este es crear una constante de tipo Long de clase estática
encapsulada que debe llamarse serialVersionUID y darle un valor, por defecto suele ser un 1.
Y al cambiar de versión se debe cambiar el valor.
Así, al actualizar la versión por el emisor y el receptor no ha actualizado, esto no va a influir
porque mantienen la misma huella.
Siempre que en un programa de Java se cree una clase que implemente la interfaz
serializable o que la herede y la implemente, el compilador va a arrojar un Warning.
FICHEROS Y DIRECTORIOS
Cuando hablamos de manipular el sistema de archivos nos referimos a ver que archivos
puede haber por ejemplo en una ruta en concreto, ver las propiedades de esos archivos y
directorio e incluso poder crear y borrar nuevos ficheros y directorios.
Para poder hacer todas estas tareas vamos a utilizar una única clase de la API de Java (Clase
File)
La clase File permite manipular archivos, documentos o carpetas.
El método String getAbsolutePath() devuelve datos de tipo String, un texto de la ruta absoluta
de un archivo o directorio
El método Boolean Exists() especifica si un archivo o directorio existen
El método String[] list() arroja un array de Strings con los nombres y directorios que se
encuentran dentro de la ruta especificada.
El método Boolean isDirectory() devuelve un verdadero o falso indicando si lo que estamos
examinando es un directorio o no lo es.
El método String getPath() devuelve la ruta con la que se creó el objeto File. Puede ser
relativa o no.
El método String getCanonicalPath() devuelve la ruta única absoluta asociada al objeto File.
Puede haber varias rutas absolutas asociadas a un File pero solo una única ruta canónica.
Lanza una excepción del tipo IOException.
Java pretende ser un lenguaje multiplataforma, por lo tanto, dependiendo de los sistemas
operativos la barra que se utiliza para las rutas (/ o \) suelen ser diferentes. En Windows
puede ser una barra y en Linux otra.
Para esto solo se utiliza un separador de tipo String e ir concatenando la dirección con
File.separator() en lugar del / o \

7
El método Mkdir() crea un directorio tal cual especifiquemos en el Path name y para crear un
archivo deberemos indicarlo como nombre de archivo (por ejemplo archivo.extension) y
usamos el método createNewFile().
Como conclusión del tema, se obtuvo que es un tema realmente indispensable en las vidas de
los programadores, con muchas utilidades, y ayuda mucho a resolver problemas o situaciones
que se quieren manejar en un programa.