Programación Orientada a Objetos - Persistencia de Objetos

Programación Orientada a Objetos
Ph.D. Franklin Parrales
Carrera de Software
0
07/06/2022
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Programación Orientada a Objetos
Persistencia de objetos y
manejo de archivos
Unidad 4

Carrera de Software
1
07/06/2022
Objetivo general de la Unidad 4
Utilizar persistencia de datos para manipular la información
concerniente a un programa, a través del manejo de
archivos y serialización.

Carrera de Software
2
07/06/2022
Contenido
▪ Archivos (Flujos, conceptos, archivos texto y binarios,
accesos secuencial y aleatorio).
▪ Serialización de objetos
▪ Lectura y escritura de archivos de texto, binarios de acceso
secuencial y acceso aleatorio.

Ph.D. Franklin Parrales 3
07/06/2022
Programación Orientada a Objetos Carrera de Software
Introducción
◼ Un computador puede almacenar grandes cantidades de información.
◼ Puede acceder a ella de manera muy rápida.
◼ Para hacer cualquier cosa es necesario tener MEMORIA disponible,
para almacenar variables, recordar valores, etc.
◼ Esta memoria puede ser volátil o persistente.
CPU
A+B=C
Memoria secundaria
(persistente)
Memoria primaria
(volátil)
A B
C
Datos.txt

07/06/2022
Memoria RAM
◼ RAM: Random Access Memory.
◼ Acceso aleatorio.
◼ Volátil, por tanto insegura.
◼ Capacidades de algunos GB.
◼ Velocidad de acceso:
◼ Del orden de los nanosegundos (10-9 seg.)
◼ 133 MHz → 8 ns
◼ Implica que puede transmitir mas de 1 GB/seg.
◼ Es necesario
◼ Evitar la volatilidad de la memoria RAM.
◼ Aumentar su capacidad a costos razonables.
◼ Realizar respaldos de información.

07/06/2022
HDD
◼ HDD: Hard Drive Disk
◼ Acceso aleatorio.
◼ Persistente y confiable.
◼ Capacidades de algunos TB.
◼ Velocidad de acceso
◼ Del orden de los milisegundos (10-3 seg)
◼ 5 – 10 ms
◼ Transmiten en tasas de MB/seg.

07/06/2022
Archivos
◼ La memoria secundaria puede almacenar cantidades inmensas de
información.
◼ Para organizar los datos en ella, se crean los conceptos de archivos.
◼ Además, se crea el concepto de directorio.
Unidad de disco Directorios Archivos

07/06/2022
Archivos
◼ Archivo: Conjunto de datos de distintos tipos, almacenados en un
disco.
◼ Los archivos son entidades que define el sistema operativo para
identificar un conjunto de datos
◼ Un archivo tiene un conjunto de atributos
◼ Nombre y extensión.
◼ Ubicación (muchas veces es solo parte del nombre).
◼ Tamaño.
◼ Tipo.
◼ Permisos: Lectura , escritura y ejecución (puede estar especificado
por usuarios y grupos)
◼ Fecha de creación y modificación.
◼ Etc...

07/06/2022
Archivos
◼ Los archivos son una secuencia de bits que se guarda en el disco
duro. La ventaja de utilizar archivos es que los datos que guardemos
no son volátiles (a diferencia de la memoria) y por lo tanto podemos
verlos después de reiniciar la computadora o en otra computadora.
◼ Los archivos de computadora, por convención cuentan con diferentes
extensiones. Por lo regular las extensiones son de tres letras y nos
permiten saber el tipo de archivo. Es importante cuando utilizamos
archivos pensar en que el tipo de extensión sea congruente con el
archivo.
◼ Los archivos pueden ser:
◼ Estructurados
◼ conformados por campos y registros
◼ No estructurados
◼ voz, video, etc.

07/06/2022
Archivos
◼ Debido a su facilidad de uso y compresión, muchos sistemas utilizan
archivos especiales para manejar dispositivos
◼ Teclado → Entrada secuencial
◼ Pantalla → Salida secuencial
◼ Impresora → Salida secuencial
◼ Red, Serial, paralela → E/S secuencial
◼ Etc...
◼ Todo se resume a saber manejar archivos
◼ Si manejan archivos, manejarán al mundo.

07/06/2022
Archivos
◼ Se pueden realizar un conjunto de operaciones a través del sistema
operativo con los archivos:
◼ Abrir
◼ Cerrar
◼ Leer
◼ Escribir
◼ Mover a una posición (solo acceso aleatorio)

07/06/2022
Flujos
◼ Para abstraer la interacción entre los archivos y los programas que
realicen operaciones sobre ellos, se define el concepto de flujo.
◼ Un flujo(stream) es como una manguera por donde fluyen datos
en uno o ambos sentidos.
“hola”
“hola”
“chao”
“chao”

07/06/2022
Flujos
“1”

07/06/2022
“hola”
Flujos
Notepad
Abrir
Leer
Escribir
Cerrar

07/06/2022
Abrir un flujo
◼ Antes de poder utilizar un flujo, debemos abrirlo.
◼ Al momento de abrirlo se especifica el “modo”
◼ Solo lectura (r)
◼ Solo escritura (w)
◼ Lectura/escritura (rw)
◼ Al abrir:
◼ Se asigna un descriptor del archivo a nuestro programa
◼ Se modifica el estado del archivo
◼ Estado de un archivo
◼ Si esta abierto para lectura, otros programas pueden también
abrirlo para lectura, pero no para escritura.
◼ Si está abierto para escritura, nadie más puede abrirlo.

07/06/2022
Cerrar un flujo
◼ Al terminar de usarlos, los flujos deben ser cerrados.
◼ Al cerrar los flujos, nuevamente se modifica el estado del archivo
(para que otros puedan abrirlo).
◼ Al salir del programa de manera normal, los flujos se cierran en forma
automática.
◼ Si el programa termina de manera anormal, los flujos pueden quedar
abiertos.

07/06/2022
Leer desde un flujo
◼ Los archivos contienen información binaria.
◼ Esta información puede representar cualquier cosa.
◼ Los archivos se separan en dos grandes grupos
◼ Archivos de texto
◼ Archivos binarios
◼ Al momento de leer, hay que tener claro el tipo de archivo desde el cual
se desea leer información.
◼ Leer desde un flujo de texto
◼ Se pueden leer letras, palabras o frases completas.
◼ Por lo general se leen de manera secuencial, desde la primera letra
hasta el fin de archivo.
◼ Leer desde un flujo binario
◼ Pueden contener cualquier cosa.
◼ Por lo general se leen de manera aleatoria.
◼ Pueden contener estructuras de datos.

07/06/2022
Ficheros de texto y binarios
◼ Ficheros de texto:
◼ +Pueden ser editados/leídos por una persona
◼ +Portables entre distintos lenguajes de programación, sistemas
operativos y arquitecturas hardware
◼ -Requieren más espacio que los binarios
◼ Ficheros binarios
◼ +Requieren menos espacio que los de texto
◼ - No pueden ser editados/leídos por una persona
◼ - Posibles problemas de portabilidad (formato de números en
coma flotante, little-endian/big-endian, etc.)
◼ Ficheros binarios de objetos
◼ +Mecanismo sencillo y potente
◼ - No portables (sólo para Java)

07/06/2022
Escribir en un flujo
◼ También depende del tipo de archivo.
◼ Por lo general, el escribir en un flujo no significa que la información se
guarde de manera inmediata en el archivo.
◼ La operación de escritura en memoria secundaria es muy costosa.
◼ Para mejorar el rendimiento se utiliza un buffer.

07/06/2022
Escribir en un flujo
2 datos
5 datos
1 datos
[Llenando buffer]
[Llenando buffer]
[buffer lleno]
[Vaciando buffer]

07/06/2022
Mover a una posición
◼ Acción permitida solo para archivos de acceso directo.
◼ Al abrir un archivo, se define una posición al comienzo de este.
◼ Al leer o escribir de manera secuencial, esta posición se actualiza
automáticamente al la posición siguiente.
◼ Se puede modificar de manera manual esta posición para leer o
modificar un datos especifico o en un orden distinto al secuencial.

07/06/2022
Elementos de un archivo estructurado
Registro
Campos

07/06/2022
Esquema de acceso a archivos
◼ Para accesar al archivo se requiere de métodos de busqueda de
informacion.
◼ Todo esquema de acceso requiere una CLAVE (key) de busqueda, la
cual debe ser comparada con las claves de los registros del archivo
hasta encontrar el buscado.
◼ Realmente se puede localizar un registro por cualquiera de sus
campos.

07/06/2022
Esquema de acceso a archivos Secuenciales
◼ Debe empezar la búsqueda siempre desde el registro No. 1
◼ Método muy lento. Aplicable sólo en archivos relativamente
pequeños (< 1000 registros).
◼ Cada registro implica un acceso a disco.

07/06/2022
Esquema de acceso a archivos Indexados
◼ Puede localizar cualquier registro de una forma más directa, sin
necesidad de iniciar desde el primero.
◼ Es más rápido, ya que sólo realiza unos pocos accesos al disco.
◼ Requiere de un archivo auxiliar: Archivo de índices.
◼ Indice: Tabla o lista que relaciona registros claves con ubicaciones
físicas sobre archivos de acceso directo.

07/06/2022
Esquema de acceso a archivos Indexados
◼ El índice tiene una estructura de árbol con varios niveles.
◼ Para accesar a un registro de datos se debe navegar el árbol de
índices hasta llegar al nivel más bajo, el cual apunta a los datos.
◼ El número de accesos al disco será equivalente al número de niveles
+1.

07/06/2022
Usos para los diferentes tipos de acceso.
◼ Acceso secuencial: Cintas magnéticas.
◼ Ya no es popular.
◼ La típica aplicación que utiliza el acceso secuencial es “roles de
pago”.
◼ Acceso directo: Tecnología de discos magnéticos.
◼ Actualmente la mayoría de aplicaciones usan esta forma de
acceso.
◼ ISAM (Indexed sequential access method).
◼ VSAM (Virtual storage access method)
◼ Direct File access Method
Métodos para el acceso a sistemas de archivos

Carrera de Software
27
07/06/2022
Contenido
▪ Lectura y escritura de archivos de texto, binarios de acceso
secuencial y acceso aleatorio.

07/06/2022
Persistencia de objetos y serialización en Java
◼ Un objeto se dice persistente cuando es almacenado en un archivo u
otro medio permanente. Un programa puede grabar objetos
persistentes y luego recuperarlos en un tiempo posterior.
◼ A diferencia de C++ que sólo soporta persistencia a través de
bibliotecas propietarias por lo cual su portabilidad y generalidad es
limitada, Java se provee un mecanismo de serialización para
almacenar objetos en disco.
◼ La serialización se obtiene llamando al método writeObject de la
clase ObjectOutputStream para grabar el objeto, para recuperarlo
llamamos al método readObject de la clase ObjectInputStream.
◼ La serialización además de persistencia, se puede usar para transferir
objetos desde una máquina a otra a través de un socket.

07/06/2022
Interfaz Serializable
◼ Sólo objetos que implementen la interfaz Serializable pueden ser
escritos a stream. La clase de cada objeto es codificada incluyendo
el nombre de la clase y la firma de la clase (su prototipo) los
valores de los sus campos y arreglos, y la clausura de cualquier
otro objeto referenciado desde el objeto inicial.
◼ Para hacer que un objeto sea serializable, sólo debemos declarar
que implementa la interfaz serializable. Nada más. No hay
métodos que debamos definir.
◼ Por razones de seguridad las clases no son serializables por
defecto.
◼ Hay que tener claro el orden y tipo de los objetos almacenados en
disco para recuperarlos en el mismo orden.

07/06/2022
Ejemplo: Empleados serializables
Class Employee implements Seralizable {....}
Employee staff = new Employee[3];
....
out.writeObject(staff);
◼ Luego podemos recuperar el objeto haciendo:
Employee[] newStaff=(Employee[])in.readObject();
◼ Sólo objetos pueden ser serializados con writeObject().
◼ Veamos el ejemplo ObjectFileTest.java

07/06/2022
Tratamiento de referencia a objetos
◼ Múltiples referencias a un único objeto son codificadas usando un mecanismo de
referencias compartidas de modo que el “grafo” de objetos puede ser restaurado
con la misma forma original.
◼ Los métodos writeObject y readObject se encargan de crear y almacenar un
número de “serie” para cada objeto. De este modo objetos ya almacenados no son
grabados nuevamente.
◼ Supongamos que dada mánager tiene una secretaria. Dos mánager podrían
compartir la secretaria, en este caso tendríamos algo como:
◼ Si grabamos staff, no queremos
tres secretarias luego sino algo
equivalente a esta vista en memoria.
staff Employee
Name=“Eugenia”
Manager
Secretary=
Manager
Secretary=

07/06/2022
Tratamiento de referencia a objetos
◼ Para ello Java utiliza el siguiente algoritmo para serializar (poner número de
series).
◼ A todos los objetos grabados a discos se les asigna un número de serie.
◼ Antes de grabar un objeto a disco se ve si ya ha sido grabado.
◼ Si ya ha sido grabado, se graba “lo mismo que el objeto con número de series
xxx”
◼ Sino, se almacena el objeto.
Employee
name=“Eugenia”
Manager
secretary=
Manager
secretary=
En disco:
Serial number=1
type=Employee
name=“Eugenia”
Serial number=2
type=Manager
secretary=objeto 1
Serial number=3
type=Manager
secretary=objeto 1

07/06/2022
Mezcla de objetos serializables y datos básicos
◼ Podemos hacerlo por medio de los métodos writeInt, readInt, etc dado que
ObjectOutputStream implementa la interfaz DataOutput. Análogo para la entrada. De
datos.
◼ Ejemplo: para escribir un objeto,
FileOutputStream ostream = new FileOutputStream("t.tmp");
ObjectOutputStream p = new ObjectOutputStream(ostream);
p.writeInt(12345);
p.writeObject("Today");
p.writeObject(new Date());
p.flush();
ostream.close();
◼ La lectura se hace en forma análoga.
FileInputStream istream = new FileInputStream("t.tmp");
ObjectInputStream p = new ObjectInputStream(istream);
int i = p.readInt();
String today = (String)p.readObject();
Date date = (Date)p.readObject();
istream.close();

07/06/2022
Cuando hay objetos no serializables
◼ Clases que requieren manejos especiales durante el proceso de
serialización o deserialización deben implementar los métodos:
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException
◼ Se aplica en casos que tengamos objetos que no sean serializables
(aquellos que tienen algún dato no serializable)
◼ Por ejemplo Point2D.Double no es serializable en Java.
◼ Para que no reclame el compilador, definimos nuestro dato
Point2D.Double como transiente (transient) y luego definimos los
métodos indicados.

07/06/2022
Cuando hay objetos no serializables
◼ Ejemplo:
public class LabelPoint
{....
Private String label;
private transient Point2D.Double point;
}
◼ Luego implementamos:
private void writeObject(ObjectOutputStream out) throws IOException
{
out.defaultWriteObject();
out.writeDouble(point.getX());
out.writeDouble(point.getY());
}
private void readObject(ObjectInutStream in) throws IOException
{
in.defaultReadObject();
double x=in.readDouble();
double y=in.writeDouble();
point =new Point2D.Double(x,y);
}

Carrera de Software
36
07/06/2022
Contenido
▪ Lectura y escritura de archivos de texto o binarios de
acceso secuencial y acceso aleatorio.

07/06/2022
Manejo de Archivos en Java
◼ Generalmente, un programa necesita traer y mandar
información desde o a fuentes externas: un archivo, en
memoria, otro programa, o una base de datos.
◼ Esa información puede estar en diversos formatos:
caracteres de texto, objetos, imágenes, sonido, bytes o
registros de tablas relacionales.
◼ El paquete java.io provee el manejo básico para esta
funcionalidad. Extensiones adicionales están presentes en
otros paquetes.
◼ Para el manejo de entrada y salida de datos, el paquete
java.io utiliza una abstracción de todos los posibles
dispositivos, denominada Stream.
◼ Un stream es una secuencia de información que el
programa lee o envía hacia un dispositivo.

07/06/2022
Streams para Entrada y Salida
◼ Un Stream es simplemente una fuente o destino de bytes.
◼ Los streams más comunes son los archivos. También pueden
ser caracteres de un string o bloque de memoria o bytes de un
“socket”. La idea es que el programador los trate de la misma
forma que archivos.
◼ En Java se usan diferentes mecanismos para dar formato a
datos, buffer, y destino o fuente de bytes.

07/06/2022
Clasificación de los Streams o flujos
◼ Por el tipo de datos que “transportan”
◼ binarios (de bytes): clases InputStream y OutputStream
◼ de caracteres (de texto): Clases Reader y Writer
◼ Por Propósito:
◼ de entrada (lectura): los datos fluyen desde el dispositivo o fichero
hacia el programa. Clases InputStream, Reader.
◼ de salida (escritura): los datos fluyen desde el programa al
dispositivo. OutputStream, Writer
◼ entrada/salida – lectura/escritura: RandomAccessFile
◼ Por Acceso:
◼ Secuencial: InputStream y OutputStream, Reader y Writer
◼ Aleatorio: RandomAccessFile

07/06/2022
◼ Los algoritmos de lectura y escritura son:
Lectura Escritura
- Abrir el Archivo - Abrir el archivo
- Mientras hayan datos - Mientras hayan datos
Leer el stream de datos del Escribir el stream de datos al
archivo archivo
- Cerrar el archivo - Cerrar el archivo

07/06/2022

07/06/2022
◼ El paquete java.io posee dos
jerarquías independientes de
clases de acuerdo al tipo de
datos que el stream maneja:
◼ Character Streams
◼ Byte Streams
◼ Reader y Writer son clases
abstractas ancestros de todos
los streams de caracteres de
lectura y escritura,
respectivamente. Proveen la
funcionalidad básica común a
todos.

07/06/2022
Character Streams – Archivos de Texto: Clases Reader y
Writer

07/06/2022
Bytes Streams – Archivos Binarios InputStream-OutputStream,

07/06/2022
◼ Los streams de caracteres implementan las operaciones de
lectura/escritura de caracteres de 16 bits en código Unicode.
Código nativo se encarga de traducir esta representación a la
codificación del sistema en caso de ser necesario.
◼ Los streams de bytes implementan las operaciones de
lectura/escritura de bytes de 8-bits. Son las clases InputStream y
OutputStream que se usan para leer y escribir datos binarios
tales como archivos comprimidos, imágenes y sonidos.
◼ Dos de los descendientes de estas clases ObjectInputStream y
ObjectOutputStream son usadas para almacenar objetos.

07/06/2022
◼ Las operaciones de las cuatro clases abstractas Reader, Writer,
InputStream y OutputStream siguen interfaces análogas:
◼ int read() int read()
◼ int read(char cbuf[]) int read(byte cbuf[])
◼ void write() void write()
◼ void write(char cbuf[]) void write(byte cbuf[])
◼ Las clases FileReader, FileWriter, FileInputStream y
FileOutputStream son clases concretas que implementan cada
uno de los comportamientos respectivos sobre archivos. En los
respectivos constructores se debe indicar el objeto de tipo File
sobre el cual actúan.

07/06/2022
Archivos de Texto
◼ Para poder leer archivos de texto en Java debemos crear un
objeto de tipo BufferedReader.
◼ BufferedReader es una clase que contiene métodos predefinidos
para poder leer de una secuencia de bits.
◼ Para poder guardar archivos de texto en Java debemos crear un
objeto de tipo PrintWriter.
◼ PrintWriter es una clase que contiene métodos predefinidos para
meter datos a una secuencia de bits.

07/06/2022
Archivos de Texto: BufferedReader
◼ El constructor que vamos a utilizar para crear un BufferedReader es:
BufferedReader fileIn = new BufferedReader(new
FileReader(fileName);
◼ Ya que tenemos el objeto tipo BufferedReader podemos utilizar varios
métodos para leer, él más común es:
fileIn.readLine();
◼ Este método lee una línea y la devuelve o devuelve null si llegamos al
final del archivo y no hay nada que leer.
◼ Es importante recordar cuando trabajamos con archivos que cada que
leemos o escribimos a un archivo debemos hacerlo dentro de un try.
◼ Un try es un manejador de excepciones, cuando sucede un error en la
ejecución de nuestro programa ejecuta ciertas instrucciones
dependiendo del tipo de error que sucedió.

07/06/2022
Archivos de Texto: Uso de try(Repaso)
n1 / n2 podría ser una división entre
cero, por lo tanto es una buena
práctica de programación utilizar un
try para que si fue una división entre
0 el programa maneje el error
(regularmente imprimiendo un mensaje
de error).
try {
int n1 = 1;
int n2 = 0;
double r = n1 / n2; //Aqui hay un error porque
//no podemos dividir entre 0!!!
} catch (ArithmeticException ae) {
//Manejar la excepcion;
} finally {
System.out("Ya termine!");
}
Primero ponemos try
y abrimos una llave
Lo que se encuentra en un finally se
ejecuta hasta el final, sin importar si el
código se ejecutó sin errores.

07/06/2022
◼ Los dos tipos de excepciones que debemos atrapar al leer archivos
son
◼ IOException (se genera normalmente porque el disco está lleno
o protegido contra escritura/lectura) y
◼ FileNotFoundException (se genera porque el nombre de archivo
no es válido)
◼ Otro método muy importante es el método fileIn.read();
◼ Este método nos permite leer un solo carácter del flujo de datos. El
método regresa un número (int) del 1 al 65535 si puede leer del
archivo o regresa -1 si no.
try {
BufferedReader fileIn = new BufferedReader(
new FileReader(fileName));
String s = fileIn.readLine();
} catch (IOException ioe) {
} catch (FileNotFoundException fnfe) {
}

07/06/2022
◼ Ya que el método read nos devuelve -1 cuando se termina el
archivo podemos utilizar un while que siga leyendo caracteres
hasta encontrar el final de archivo.
try {
int i = fileIn.read(); //Iniciamos una variable a la que
//vamos a leer
char c = (char) i; //Como lo que leimos es un int debemos
// hacer un cast a char
}
try {
int i = 0;
while (i != -1) {
i = fileIn.read();
char c = (char) i;
}
}

07/06/2022
Archivos de Texto: BufferedReader: Ejercicios
◼ Vamos a hacer un ejercicio para entender mejor como funcionan los
archivos de texto. El ejercicio consiste en leer cuantas veces aparece
una letra en un archivo.
◼ Con los métodos que hemos visto hay dos maneras de resolver este
problema:
◼ la primera es leer todo el archivo de texto con el método
readLine() y después buscar ahí todas las letras.
◼ El otro método sería leer letra por letra y comparar en cada
lectura.
◼ Ninguna de las dos maneras es “peor” que la otra sino que depende
de lo que haga el programa y las limitaciones que nos pongan. En
este caso sería prudente utilizar la segunda porque es más sencilla.

07/06/2022
● Si te fijas el ejercicio se parece mucho a los ejemplos anteriores,
esa es una de las ventajas de los archivos de texto: la sintaxis es
muy parecida siempre.
● Por último es importante que una vez que terminamos de utilizar el
archivo lo cerremos utilizando el método close() del objeto
BufferedReader que creamos.
try {
int suma = 0; //Ponemos una variable donde llevemos la suma
new FileReader(fileName)); //Creamos el BufferedReader
int i = 0;
while (i != -1) {
i = fileIn.read();
char c = (char) i;
if (c == letra) suma++;
}
}

07/06/2022
String fileName = "Texto.txt";
//Se declara desde aqui para que no haya error en el finally
BufferedReader fileIn = null;
try {
fileIn = new BufferedReader(new FileReader(fileName));
String s = fileIn.readLine();
System.out("La primera linea es: " + s);
System.out("Error, disco protegido contra lectura");
System.out("Error, no se encuentra el archivo");
} finally {
if (fileIn != null) {
try {
/**
* Una vez que termine de leer el archivo es
* importante cerrarlo para que otros programas lo
* puedan abrir y para que los cambios se guarden.
*/
fileIn.close(); //Es importante cerrar el archivo
} catch(IOException ioe) {
}
}
}

07/06/2022
Archivos de Texto: PrintWriter
◼ El constructor que vamos a utilizar para crear un PrintWriter es:
PrintWriter fileOut = new PrintWriter(new
FileWriter(fileName);
◼ Ya que tenemos el objeto PrintWriter podemos utilizar varios
métodos para escribir, los más comunes son:
fileOut.print(String);
fileOut.println(String);
◼ Estos dos métodos reciben un String y lo imprimen en el archivo,
el segundo método le pone un carácter de fin de línea al final.
◼ Al igual que al leer debemos recordar utilizar un try. Cuando
utilizamos el PrintWriter todo entra a un buffer y una vez que
terminemos de escribir los datos debemos recordar utilizar el
método flush() del PrintWriter para escribir todo al archivo.
◼ Al terminar de usar el archivo también debemos recordar que
debemos cerrarlo mediante el método close() del PrintWriter.

07/06/2022
String fileName = "Texto.txt";
PrintWriter fileOut = null;
try {
fileOut = new PrintWriter(new FileWriter(fileName));
String s = "Una linea de texto";
fileOut.println(s);
fileOut.flush();
System.out("Error, disco protegido contra lectura");
System.out("Error, no se encuentra el archivo");
} finally {
if (fileIn != null) {
try {
fileIn.close();
}
}
}
Archivos de Texto: PrintWriter

07/06/2022
Archivos binarios
◼ Vimos el uso de archivos de texto en Java, pero el uso de archivos
es mucho más poderoso que eso, al utilizar archivos podemos
guardar o leer cualquier cosa: int, double, String, boolean, etc.
◼ Todos estos datos los podemos guardar y leer desde archivos
mediante un tipo especial de archivos llamados Archivos Binarios.
◼ Para poder utilizar archivos binarios, al igual que cuando vamos a
utilizar archivos, es necesario importar la librería java.io.* para que
podamos utilizar todas las funciones de leer y escribir.
◼ Los archivos binarios guardan una representación de los datos en
el archivo, es decir, cuando guardamos texto no guardan el texto
en si, sino que guardan su representación en un código llamado
UTF-8.
◼ Los dos tipos de objetos que vamos a utilizar para leer de archivos
son el DataInputStream y el DataOutputStream.

07/06/2022
Archivos binarios: DataInputStream para leer
◼ El constructor que vamos a utilizar en esta clase para iniciar el
DataInputStream es DataInputStream(new FileInputStream(fileName));
◼ Donde fileName es un String con el nombre del archivo que queremos
abrir.
◼ Este constructor crea un objeto tipo DataInputStream que podemos utilizar
para leer archivos binarios.
◼ Los métodos más útiles de DataInputStream son:
◼ String readUTF()
◼ byte readByte()
◼ int readInt()
◼ long readLong()
◼ double readDouble()
◼ short readShort()
◼ boolean readBoolean()
◼ Como pudiste ver estos métodos sirven para leer los diferentes tipos de datos
que hemos manejado en clase.

07/06/2022
Archivos binarios: DataInputStream: Ejemplo de Lectura
String fileName = “C:Archivo.dat”;
DataInputStream fileIn = new
DataInputStream(new FileInputStream(fileName));
try {
String unString = fileIn.readUTF();
int unInt = fileIn.readInt();
double unDouble = fileIn.readDouble()
}
Primero declaramos el objeto
De tipo DataInputStream
Iniciamos el DataInputStream con
un nuevo FileInputStream con el
nombre del archivo.
Estos métodos nos sirven para
leer diferentes tipos de datos del
Archivo. Los datos permanecen
guardados en las variables y los
podemos utilizar después.
Siempre que leemos y
guardamos en archivos tenemos
que ponerlo en un try -> catch.

07/06/2022
Archivos binarios: DataOutputStream para escribir
◼ El constructor que vamos a utilizar en esta clase para iniciar el
DataOutputStream es DataOutputStream(new
FileOutputStream(fileName));
◼ Como puedes observar el constructor es muy similar al anterior ya que
en esencia funciona de la misma manera. Con este nuevo objeto
DataOutputStream vamos a poder escribir en archivos binarios.
◼ Los métodos más útiles de DataOutputStream son:
◼ void writeUTF(String s)
◼ void writeByte(byte b)
◼ void writeInt(int i)
◼ void writeLong(long l)
◼ void writeDouble(double d)
◼ void writeShort(short s)
◼ void writeBoolean(boolean b)
◼ Como puedes ver son muy similares a los de lectura, únicamente que
en vez de devolver datos, los escriben.

07/06/2022
Archivos binarios: DataOutputStream: Ejemplo de
Escritura
String fileName = “C:Archivo.dat”;
DataOutputStream fileOut = new
DataOutputStream(new FileOutputStream(fileName));
try {
String unString = “Hola mundo!”
fileOut.writeUTF(unString);
// Es lo mismo que fileOut.writeUTF(“Hola mundo!”)
int i = 5;
fileOut.writeInt(i);
// Es lo mismo que
// fileOut.writeInt(5)
catch (IOException ioe) {
}
Primero declaramos el objeto
De tipo DataOutputStream
Iniciamos el DataOutputStream con
un nuevo FileOutputStream con el
nombre del archivo.
Estos métodos nos sirven
para escribir diferentes tipos
de datos al archivo, una vez
que estén guardados
podemos abrir el archivo
binario y leerlo con el
DataInputStream como ya
vimos anteriormente.

07/06/2022
Archivos binarios: Ventajas
◼ Posiblemente con el ejercicio te diste cuenta de la enorme ventaja
que representan los archivos binarios sobre los archivos de texto.
◼ Para poder leer diferentes tipos de dato de un archivo de texto hay
que hacer casting, y además es muy difícil saber donde empieza y
donde termina cada dato (imagina ahora, que no sólo tienes que
leer la matrícula sino también la edad y el peso, cómo saber cuál
es cuál)

07/06/2022
Archivos binarios para objetos serializados
◼ Utilizar archivos binarios nos ayuda a guardar y leer más
fácilmente los datos de archivos.
◼ Pero como pudimos ver en el ejercicio de la clase anterior, si
tenemos un objeto de tipo Persona tenemos que guardar cada
variable por separado.
◼ Esto podría parecer sencillo, pero cuando manejamos una gran
cantidad de objetos el código se alarga y se vuelve más difícil de
entender y de mantener. Por lo tanto tenemos que guardar
objetos a archivos.

07/06/2022
Archivos binarios para objetos serializados
◼ Para guardar un objeto en un archivo binario el objeto debe
implementar la interfaz Serializable.
◼ La interfaz Serializable tiene un conjunto de métodos con los que
podemos guardar y leer objetos en archivos binarios.
◼ Los dos métodos más importantes que vamos a utilizar son
◼ writeObject(ObjectOutputStream out)
◼ readObject(ObjectInputStream in)
◼ Dentro de estos métodos debemos poner el código que guardaría
todas las variables de el objeto. Es decir, si el objeto tiene un int
edad, dentro de el código de writeObject debemos poner
out.writeInt(edad);
◼ Es decir, al mandar llamar los métodos estamos guardando o leyendo
todas las variables del objeto de un archivo de la misma manera que
habíamos visto antes.

07/06/2022
Cambios Necesarios para guardar objetos serializados
◼ Debemos Importar las librerías de IO en la clase que queremos
guardar
◼ import java.io.*;
◼ Debemos hacer que la clase implemente Serializable
◼ public class Persona implements Serializable
◼ Ahora debemos añadir los dos métodos que manejan archivos
◼ public void writeObject(ObjectOutputStream out)throws
IOException
◼ public void readObject(ObjectInputStream in)throws
IOException, ClassNotFoundException;
◼ Y por último debemos escribir el método que guarda y que lee.

07/06/2022
Archivos binarios para objetos serializados: writeObject
◼ Vamos a ver los métodos más a fondo
◼ public void writeObject(ObjectOutputStream out)throws
IOException
◼ Al final tenemos que poner throws IOException, esto es necesario
porque sino el programa no compila. Más adelante vamos a ver
todo sobre las excepciones.
◼ El objeto que escribimos a un archivo es el mismo con el que
llamemos el método, es decir:
◼ Persona p = new Persona(“Juan”);
◼ p.writeObject(out);
◼ El método anterior guarda p en un archivo
◼ El método recibe un ObjectOutputStream como parámetro,
tenemos que pasarle como parámetro el mismo objeto que
hicimos para escribir archivos binarios.

07/06/2022
Archivos binarios para objetos serializados: readObject
◼ Vamos a ver los métodos más a fondo
◼ public void readObject(ObjectInputStream in)throws IOException,
ClassNotFoundException
◼ Al final tenemos que poner throws IOException, esto es necesario
porque sino el programa no compila.
◼ Tenemos que llamar el método con el objeto que queremos modificar:
◼ Persona p = new Persona(); //La estoy creando en blanco
◼ p.readObject(in); //Utilizo readObject para leerla de un archivo
◼ p.getName(); //Me devuelve “Juan”
◼ El método anterior lee una Persona de un archivo y los guarda en el
objeto p.
◼ El método recibe un ObjectInputStream como parámetro, tenemos
que pasarle como parámetro el mismo objeto que hicimos para leer
archivos binarios.

07/06/2022
Ejemplo de Serializable (Clase Auto)
La clase debe implementar
Serializable
El método es void y lanza
IOException
Utilizamos los métodos que ya
conocemos para escribir y leer
del archivo.
import java.io.*;
public class Auto implements Serializable{
.... //Poner todos los métodos y los
.... //accessors y mutators.
public void writeObject(DataOutputStream out) throws IOException{
out.writeUTF( getMarca() );
out.writeInt( getAnio() );
out.writeDouble( getRendimiento() );
}
public void readObject(DataInputStream in) throws IOException,
ClassNotFoundException{
setMarca(in.readUTF());
setAnio(in.readInt());
setRendimiento(in.readDouble());
}
}
Debemos importar
java.io.*

07/06/2022
Ejemplo de Serializable (Clase Auto)
Para leer:
DataInputStream fileIn = new DataInputStream(
new FileInputStream(“datos.dat”));
Auto a = new Auto();
try {
a.readObject(fileIn);
} catch (ClassNotFoundException cnfe) {
}
Para escribir:
DataOutputStream fileOut = new DataOutputStream(
new FileOutputStream(“datos.dat”));
Auto a = new Auto(marca, anio, rendimiento);
try {
a.writeObject(fileOut);
}
Declaramos el objeto
para leer
Este método llama al método que
escribimos antes que lee el auto y
la guarda en a.
Este método manda llamar el método
que escribimos antes, que guarda el auto
en el archivo que abrimos (datos.dat)

07/06/2022
Clase File
◼ Esta clase permite obtener información sobre los archivos y los
directorios.
◼ File (String pathname). Ejemplo:
◼ File f1 = new File (“Archivo1.txt);
◼ File f2 = new File (“c:Archivo2.txt);
◼ File f3 = new File (“d:Paradigmas”);
◼ File f4 = new File (f3, “FileName.java”);
◼ Ver: InfoFichero.java

07/06/2022
Métodos de la Clase File

07/06/2022
Accediendo a Archivos Secuencialmente
◼ Son de acceso secuencial: los datos deben ser leídos exactamente
en el orden en que fueron escritos.
◼ Ver
◼ CopiaArchivo.java
◼ Nomina.txt
◼ CopiaBytes.java
◼ Ver
◼ CreateSequentialFile.java
◼ ReadSequentialFile.java

07/06/2022
Archivos de Acceso Aleatorio
◼ Los archivos de acceso secuencial son extremadamente útiles para
la mayoría de las aplicaciones, pero a veces son necesarios archivos
de acceso aleatorio que permiten acceder a sus contenido en forma
no secuencial, o aleatoria.
◼ La clase RandomAccessFile implementa en java.io un archivo de
acceso aleatorio, que puede ser usada tanto para lectura como
para escritura de bytes.
◼ Todo objeto instancia de RandomAccessFile soporta el concepto
de puntero que indica la posición actual dentro del archivo. Es un
entero que empieza en 0 y se mide en bytes.
◼ RandomAccessFile provee comandos y una consulta para operar
sobre el puntero.
◼ Ver RandomFile.java

Carrera de Software
74
07/06/2022
Persistencia de objetos y
manejo de archivos
Unidad 4
Final de la unidad
Y del curso…. !Muchas gracias
a todos!

Programación Orientada a Objetos - Persistencia de Objetos

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Programación Orientada a Objetos - Persistencia de Objetos

Similar to Programación Orientada a Objetos - Persistencia de Objetos (20)

More from Franklin Parrales Bravo

More from Franklin Parrales Bravo (20)

Programación Orientada a Objetos - Persistencia de Objetos