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 Time

Read / Write Objects Read / Write

repository

1
 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
 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.).
12
 Clases de Streams
(Streams orientados a caracter)
• Soportan UNICODE (16 bits para un char).
• Módulos sombreados son fuentes, y sin sombrear son
procesadores.

13
 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.
14
 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(); 15
 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());

16
 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 Memoria secundaria

(volátil) (persistente)
CPU B
A
A+B=C 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

1. Cree un bloc de notas vacío en una carpeta cualquiera

2. Digite el siguiente código
3. Ejecute la aplicación
 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
Archivos Acceso Aleatorio
 Archivos Acceso Aleatorio
En un archivo secuencial:

María Reyes estudia aquí

Esta es una prueba
Otra línea mas larga que todas las otras

En un archivo aleatorio (Directo)

Registro María Reyes 52
José Castro 85
Campo
María Reyes 52
José Castro 85

Longitud fija para

todos los campos

María _ _ _ _ _ Reyes 52
José _ _ _ _ _ _ Castro 85

Si hace falta se
debe completar
 Como se define el tamaño de un registro?

1 María _ _ _ _ _ Reyes _ _ _ _ _ 52
2 José _ _ _ _ _ _ Castro _ _ _ _ 85

10 Caracteres 10 Caracteres

4 bytes 10 X 2 bytes 10 X 2 bytes 4 bytes

Tamaño del registro = 48 bytes

public class ArchivoDirecto {
private int clave;
private String nombre;
private int edad;
private long tamreg;
private long canreg;
private File fl;
RandomAccessFile archivo;

public ArchivoDirecto() {
this.clave = 0;
this.nombre = "";
this.edad = 0;
this.tamreg = 58;
this.canreg = 0;
try {
fl = new File("C://prueba.dat");
archivo = new RandomAccessFile(fl, "rw");
} catch (FileNotFoundException fnfe) {/* Archivo no encontrado */
}
}
public void escribir() {
BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
try {
System.out.println("\nEscribiendo Registros:");
String r = "S";
while (r.equalsIgnoreCase("S")) {
clave++;
System.out.println("Ingrese nombre: ");
nombre = teclado.readLine();
if (nombre.length() < 25) {
for (int i = nombre.length(); i < 25; i++)
nombre = nombre + " ";
} else {nombre = nombre.substring(0, 25);}
System.out.println("Ingrese edad: ");
edad = Integer.parseInt(teclado.readLine());
if (archivo.length()!= 0) {
archivo.seek(archivo.length());
}
archivo.writeInt(clave);
archivo.writeChars(nombre);
archivo.writeInt(edad);
System.out.println("Ingresar otra linea (S or N)?: \t");
r = teclado.readLine();
}
} catch (FileNotFoundException fnfe) {/* Archivo no encontrado */
} catch (IOException ioe) { /* Error al escribir */}
}
public void leerTodo() {
System.out.println("\nMostrando todos los Registros");
try {
archivo.seek(0);
nombre = "";
canreg = archivo.length() / tamreg;
for (int r = 0; r < canreg; r++) {
clave = archivo.readInt();
for (int i = 0; i < 25; ++i) {
nombre += archivo.readChar();
}
edad = archivo.readInt();
System.out.println(" Registro No: " + clave + " Nombre: "
+ nombre + " Edad: " + edad);
nombre = "";
}
} catch (FileNotFoundException fnfe) {/* Archivo no encontrado */
} catch (IOException ioe) { /* Error al escribir */}
}
public void cerrar() {
try {
archivo.close();
} catch (IOException e) {e.printStackTrace();}
}

public static void main(String[] args) {

ArchivoDirecto arch = new ArchivoDirecto();
arch.escribir();
arch.leerTodo();
arch.cerrar();
} //fin del main
} //fin de la clase
 Como se carga un registro determinado

public void leerUnRegistro() {

BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
System.out.println("\nBuscando un Registro:");
System.out.println("Ingrese el numero de registro a buscar: ");
try {
archivo.seek(0);
clave = Integer.parseInt(teclado.readLine());
archivo.seek((clave - 1) * tamreg); // argumento es tipo long
clave = archivo.readInt();
for (int i = 0; i < 25; ++i) {
nombre += archivo.readChar();
}
edad = archivo.readInt();
System.out.println("Registro No. " + clave + " Nombre: " + nombre
+ " Edad: " + edad + "\n\n");
nombre = "";
} catch (FileNotFoundException fnfe) {
} catch (IOException ioe) {}
}
 Ejercicio Extraclase
1.Como se actualiza un registro, por ejemplo: cómo se le suma
un año mas a cada edad
2. Como se modifica un registro, por ejemplo: Cómo se cambia
la edad de una persona que quedo mal digitado
3. Como se busca la clave del penúltimo registro
4. Cómo se busca la clave del primer registro
5. Cómo se determina la cantidad de registros de un archivo
 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