Download Presentación de Clase: Introducción a Persistencia Archivo

Estrategias de Persistencia
Persistencia: Es la capacidad de un objeto de continuar
existiendo después que su creador (programa que crea este)
deja de existir.
Program execution
Program execution
Object Lifetime
Time
Program
start
Object
creation
Program
end
Program
start
Object
edition
Program
end
“…object outlives the execution of the program…”
Persistencia en memoria
La persistencia en memoria es la capacidad de un dato u objeto para seguir
existiendo tras determinadas operaciones. La operación más común que se
presta a la persistencia en memoria es la asignación. Existen dos ideas
respecto de lo que debe suceder con un dato, estructura u objeto una vez
asignado desde el origina
Persistencia de aplicación
Es la capacidad para que los datos sobreviven a la ejecución
del programa que los ha creado. Sin esta capacidad, los datos solo existen
en memoria RAM, y se pierden cuando la memoria pierde energía, como
cuando se apaga el computador. Este tipo de persistencia requiere que los
datos sean almacenados en un medio secundario, no volátil, para su posterior
reconstrucción y utilización, por lo que su tiempo de vida es independiente
del proceso que los creó.
Persistencia en Memoria
Memoria Principal: (acceso directo de la CPU)
◦ Tiempo de acceso muy rápido
◦ Almacenamiento no persistente: volátil
◦ Capacidad de almacenamiento limitada
Memoria de Aplicación (Secundaria):
Discos duros, discos ópticos, memorias USB, etc.)
◦ Tiempo de acceso lento
◦ Almacenamiento persistente
◦ Gran capacidad de almacenamiento
Memoria RAM
•
•
•
•
•
RAM: Random Access Memory.
Acceso aleatorio.
Volátil, por tanto insegura.
Capacidades de cientos de MB.
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.
Persistencia Volátil
Al terminar la ejecución de una aplicación los
datos se pierden (son descargados de memoria
automáticamente!).
En la memoria volátil el contenido del
dispositivo
debe
de
ser
refrescado
continuamente para evitar la perdida de datos.
La memoria RAM y la memoria cache de los
procesadores son algunos ejemplos de
memorias volátiles.
Persistencia Volátil
Tipos de Persistencia
a. Variables
b.Objetos
c. Estructuras
de
Datos
Estáticas
Unidimensionales
d.Estructuras
de
Datos
Estáticas
Bidimensionales
e. Estructuras de Datos Dinámicas
f. Pilas, Colas, listas
g. Arboles
h.Grafos, etc.
Persistencia Volátil
Ejercicio
Diseñe un programa que
permita guardar una cantidad
indeterminada de objetos en
una estructura.
Persistencia No Volatil
•Datos que existen entre varias ejecuciones de un programa
•Datos que existen entre varias versiones de un programa
Program P
Program Q
Time
Read / Write
Time
Objects
repository
9
Read / Write
Persistencia No Volatil
a. Archivos de Texto
Secuenciales
b. Archivos de Texto Aleatorios
c. Archivos Binarios
d. Archivos de Propiedades
e. Bases de Datos
Streams
•
Stream: an object that either delivers data to its destination
(screen, file, etc.) or that takes data from a source
(keyboard, file, etc.)
– it acts as a buffer between the data source and
destination
•
Input stream: a stream that provides input to a program
– System.in is an input stream
•
Output stream: a stream that accepts output from a
program
– System.out is an output stream
•
A stream connects a program to an I/O object
– System.out connects a program to the screen
– System.in connects a program to the keyboard
Manejo de salida en “Prompt”
•
Desplegar línea y que pase a la próxima línea
– Método: println()
– Objeto:S ystem.out
– Formato: System.out.println(Datos o mensaje a imprimir)
– Ejemplos:
System.out.println(“Este es mi mensaje profundo”)
System.out.println(“Esto es un dato: ” + valor +”.”)
•
Desplegar línea y que no pase a la próxima línea
– Método: print()
– Objeto: System.out
– Formato: System.out.print(Datos o mensaje a imprimir)
– Ejemplos:
System.out.print(“Este es mi mensaje ”)
System.out.println(“profundo en dos instrucciones”)
System.out.print(“Esto es un dato: ” + valor +”.”)
Manejo de entrada por “Prompt”
•
Pedir dato por “Prompt”
– Método: readLine()
– Objeto: System.in {Devuelve bytes}
– Clases necesarias para manejo:
• InputStreamReader {Devuelve caracteres en Unicode}
• BufferedReader {Devuelve String)
– Librería: java.io.*
– Preparación para lectura:
• import java.io.*;
• public static void main(String[] args) throws IOException
• InputStreamReader inStream;
• BufferedReader in;
• inStream = new InputStreamReader(System.in);
• in = new BufferedReader(inStream);
– Formato:
String strdata;
strdata = in.readLine();
Manejo de entrada por “Prompt”
import java.io.*;
public static void main(String[] args) throws
IOException {
InputStreamReader inStream;
BufferedReader in;
String segSocial, nombre, strEdad;
int edad;
inStream = new
InputStreamReader(System.in);
in = new BufferedReader(inStream);
segSocial = in.readLine();
nombre = in.readLine();
strEdad = in.readLine();
edad = Integer.parseInt(strEdad);
Mismo Ejemplo acortado:
import java.io.*;
public static void main(String[] args) throws
IOException {
BufferedReader in;
String segSocial, nombre;
int edad;
in = new BufferedReader(new
InputStreamReader(System.in));
segSocial = in.readLine();
nombre = in.readLine()
edad = Integer.parseInt(in.readLine());
Flujos (Streams)
Es una abstracción, que representa a un flujo de datos entre un origen
y un destino en Java. Todo proceso de entrada y salida en Java se
hace a través de flujos.
Entre el origen y el destino debe existir un canal , por el que
viajan datos. Cuando se abre un archivo se establece una
conexión entre el programa y el dispositivo que contiene ese
archivo , por el canal fluirá la secuencia de datos. Igual ocurre
al intentar escribir en un archivo.
Archivos y Flujos (Streams)
Para obtener información de una fuente un programa abre un
stream y lee la información secuencialmente
Archivos y Flujos (Streams)
De igual forma, un programa puede enviar
información a un destino externo abriendo un
stream al destino y escribiendo la información
secuencialmente .
Streams
• Un stream representa un flujo de
información:
• procedente de una fuente
(teclado, file, memoria, red, etc.)
o
• dirigida a un destino (pantalla,
file, etc.)
• Los streams comparten una
misma interfaz que hace abstracción
de los detalles específicos de cada
dispositivo de E/S.
• Todas las clases de streams están
en el paquete java.io
Clases de Streams
(Streams orientados a byte)
• Los módulos sombreados representan
fuentes de datos.
• Los módulos sin sombrear representan
procesadores.
• Los procesadores se pueden aplicar a
otro procesador o a una fuente.
Subclases de InputStream
• FileInputStream: lectura de files byte a byte
• ObjectInputStream: lectura de files con objetos.
• FilterInputStream:
– BufferedInputStream: lectura con buffer, más eficiente.
– DataInputStream: lectura de tipos de datos primitivos (int,
double, etc.).
• FileOutputStream: escritura de files byte a byte
• ObjectOutputStream: escritura de files con objetos.
• FilterOutputStream:
– BufferedOutputStream: escritura con buffer, más eficiente.
– DataOutputStream: escritura de tipos de datos primitivos (int,
double, etc.).
20
Clases de Streams
(Streams orientados a caracter)
• Soportan UNICODE (16 bits para un char).
• Módulos sombreados son fuentes, y sin sombrear son
procesadores.
21
Subclases de Reader
• InputStreamReader: convierte un stream de bytes en un stream de chars.
– FileReader: se asocia a files de chars para leerlos.
• BufferedReader: proporciona entrada de caracteres a través de un buffer
(más eficiencia).
Subclases de Writer
• OutputStreamWriter: convierte un stream de bytes en un stream de chars.
– FileWriter: se asocia a files de chars para modificarlos.
• BufferedWriter: proporciona salida de caracteres a través de un buffer
(más eficiencia).
• PrintWriter: métodos print() y println() para distintos tipos de datos.
22
Típicos Usos de los Streams (lectura por líneas)
public static void main(String[] args) throws IOException {
// 1a. Se lee un file línea a línea
BufferedReader in = new BufferedReader( new FileReader("IOStreamDemo.java"));
String s, s2 = new String();
while((s = in.readLine())!= null)
s2 += s + "\n";
in.close();
// 1b. Se lee una línea por teclado
BufferedReader stdin = new BufferedReader( new
InputStreamReader(System.in));
System.out.print("Enter a line:"); System.out.println(stdin.readLine());
}
Típicos Usos de los Streams (escritura por líneas)
// throws IOException
String []s = {“hola“, “que”, “tal”};
// Se inicializa s
PrintWriter out1 = new PrintWriter( new BufferedWriter( new FileWriter("IODemo.out")));
int lineCount = 1;
for (int i=0; i<s.length(); i++)
out1.println(lineCount++ + ": " + s[i]);
out1.close();
23
Típicos Usos de los Streams (escritura de tipos básicos)
// throws IOException
DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream(new
FileOutputStream("Data.txt")));
out2.writeDouble(3.14159);
out2.writeBytes("That was pi\n“);
out2.writeChars( "That was pi\n“);
out2.writeDouble(1.41413);
out2.writeUTF("Square root of 2");
out2.close();
Típicos Usos de los Streams (lectura de tipos básicos)
// throws IOException
DataInputStream in5 = new DataInputStream( new
BufferedInputStream( new
FileInputStream("Data.txt")));
System.out.println(in5.readDouble());
System.out.println(in5.readLine()); // deprecated
System.out.println(in5.readDouble());
System.out.println(in5.readUTF());
24
Persistencia Posterior - Archivos
• 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.
Memoria primaria
(volátil)
CPU
A+B=C
A
Memoria secundaria
(persistente)
B
C
Datos.txt
Archivos.
Los archivos tienen como finalidad guardar datos de forma permanente. Una
vez que acaba la aplicación los datos almacenados están disponibles para que
otra aplicación pueda recuperarlos para su consulta o modificación.
Secuenciales
Archivos que se leen / escriben línea por línea. Cada línea
puede tener un tamaño en bytes diferente . Los registros se
insertan en el archivo en orden de llegada. Las operaciones
básicas permitidas son: escribir, añadir al final del archivo y
consultar .
Aleatorios
Archivos que se leen / escriben en una línea determinada.
Todas las líneas deben tener la misma cantidad de bytes para
ser recorrida. Un registro es directamente accesible mediante
la especificación de un índice.
Archivos Acceso Secuencial
public class Archivo {
File f;
JFileChooser fc;
//constructor de la clase
public Archivo(){
fc=new JFileChooser(System.getProperty("user.dir"));
fc.showOpenDialog(fc);
f=fc.getSelectedFile();
}
public void leer(){
try{
FileInputStream f1 =new FileInputStream(f);
InputStreamReader f2= new InputStreamReader(f1);
BufferedReader linea= new BufferedReader(f2);
if (f.exists()){
System.out.println("El fichero " + f + " existe \nSu contenido es: \n");
String linea_arch=linea.readLine();
while (linea_arch != null) {
System.out.println(linea_arch);
linea_arch = linea.readLine();
}
linea.close();
}
else{System.out.println("archivo no existe");}
}catch(IOException e){ System.out.println("No se pudo leer del archivo"); }
}
public void Escribir(){
try{
InputStreamReader isr= new InputStreamReader(System.in);
BufferedReader linea= new BufferedReader(isr);
System.out.println("Digite la nueva linea: \t");
String linea_arch=linea.readLine();
FileWriter linea_tx= new FileWriter(f,true);
linea_tx.write(linea_arch+"\r\n");
linea_tx.close();
}catch(IOException e){ System.out.print("No se pudo escribir"); }
}
public static void main(String [] args){
Archivo arch=new Archivo();
arch.leer();
arch.Escribir();
} //fin del main
} //fin de la clase
Bibliografía
http://www.tecn.upf.es/~bouayad/prog/material/teoria/collections/collections.pdf
http://mit.ocw.universia.net/6.170/6.170/f01/pdf/lecture-16.pdf