PERSISTENCIA BASADA EN ARCHIVOS
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
5,826
On Slideshare
5,512
From Embeds
314
Number of Embeds
3

Actions

Shares
Downloads
190
Comments
0
Likes
5

Embeds 314

http://evirtual.ucuenca.edu.ec 309
url_unknown 4
http://www.slideshare.net 1

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Persistencia basada en archivos
  • 2. Introducción
    • Todas las aplicaciones realizadas hasta ahora obtenían los datos necesarios para su ejecución de la entrada estándar y visualizaban los resultados en la salida estándar.
    • De esta forma los datos estarán disponibles mientras dure la ejecución de la aplicación. Si finalizamos la ejecución de la aplicación y la ejecutamos de nuevo, tendremos que volver a ingresar de nuevo todos los datos.
  • 3. … Introducción
    • La solución para hacer que los datos persistan de una ejecución a otra es almacenarlos en un archivo en el disco.
    • Entonces cada vez que se ejecute la aplicación podrá leer el archivo almacenado en disco y recuperar los datos que requiera, los mismos que serán cargarlos en la memoria y podrán ser manipularlos.
  • 4. Datos de una aplicación
  • 5. Persistir datos de una aplicación
    • Como Java es un lenguaje orientado a objetos, la mayoría de aplicaciones tienen un conjunto de clases de datos (modelo de datos).
    • En la memoria residen las instancias de estas clases de datos y los componentes de vista y controlador (interfaz de usuario).
    • Para almacenar los datos de forma permanente una aplicación debe tomar el modelo de datos de la memoria y escribirlo en disco.
  • 6. Archivos
    • Un archivo, también denominado “fichero”, es un conjunto de datos almacenados como una “unidad” en un soporte físico, por ejemplo un disco magnético o un CD.
    • Los datos almacenados en un archivo son de manera permanente de modo que pueden ser manipulados en cualquier momento.
    • Cada archivo está referenciado mediante un identificador único (ruta + nombre).
  • 7. Ejemplos bajo Windows
    • Nombre completo:
      • C:FarmaciaDatosBalance.dat
    • Nombre corto:
      • Balance.dat
    • Extensión:
      • .dat
    • Ruta:
      • C:FarmaciaDatos
  • 8. Ejemplos bajo UNIX/Linux
    • Nombre completo:
      • home/ccp/farmacia/datos/Balance.dat
    • Nombre corto:
      • Balance.dat
    • Extensión:
      • .dat
    • Ruta:
      • home/ccp/farmacia/datos/
  • 9. La clase File
    • Un objeto de la clase java.io.File permite referenciar un archivo o un directorio que puede existir en el sistema de archivos.
    • Básicamente, podemos ver los objetos de esta clase como una referencia al nombre del elemento del sistema de archivos, bien sea un archivo o directorio.
    • A través de esta clase podemos manipular los atributos de los elementos referenciados.
  • 10. Métodos de la clase File - Directorios Método Descripción boolean isDirectory() Investiga si es un directorio. boolean exist() Investiga si existe el directorio. boolean mkdir() Crea un directorio. boolean mkdirs() Crear los directorios necesarios de una ruta. boolean delete() Borra un directorio. String[] list() Lista archivos de un directorio. File[] listRoots() Lista cada uno de los sistemas de archivos disponibles.
  • 11. Métodos de la clase File - Archivos Método Descripción boolean isFile() Investiga si es un archivo. boolean exist() Investiga si existe el archivo. boolean canRead() Investiga si se puede leer el archivo. boolean canWrite() Investiga si se puede escribir el archivo. long length() Tamaño del archivo en bytes. long lastModified() Fecha de la última modificación. boolean renameTo() Cambia el nombre del archivo. boolean delete() Borra un archivo.
  • 12. Ejemplo
    • File[] roots = File.listRoots();
    • for (File r : roots) {
    • System.out.println(r);
    • }
  • 13. Ejemplo
    • File dir = new File("/home/ccp/");
    • String files = dir.list();
    • for (String f : files) {
    • System.out.println(f);
    • }
  • 14. Flujos de Entrada/Salida
    • La escritura y lectura de archivos en Java se basa en “flujos” de datos.
    • Un flujo no es más que un objeto que hace de intermediario entre la aplicación y el origen o el destino de los datos.
    • De esta forma la aplicación leerá o escribirá en el flujo sin importarle desde donde vienen los datos o hacia donde van.
  • 15. Visión general de los flujos E/S
  • 16. Filtros
    • Existen otras clases que también representan flujos de datos, pero que se utilizan como un “filtro” previo a un flujo sobre un archivo o cualquier otro dispositivo.
    • El uso habitual de estas clases es transformar los datos de otro flujo. Por ejemplo, podríamos tener un filtro que convierta a mayúsculas todo el texto y que trabaje con flujos asociados a archivos, memoria o cualquier otro destino.
  • 17. Flujos de entrada de caracteres
  • 18. Flujos de salida de caracteres
  • 19. Flujos de entrada binarios
  • 20. Flujos de salida binarios
  • 21. Reader y Writer
    • Java proporciona las clases Reader y Writer , clases abstractas de las que derivan las clases que permiten crear flujos de caracteres de 16 bits (Unicode) mediante la codificación local por defecto.
  • 22. Subclases de Reader y Writer Subclase Descripción FileReader Crea flujos de bytes procedentes de archivos de caracteres. BufferedReader Crea un filtro con área de almacenamiento en memoria ( buffer ) con lo que permite la lectura de bloques mayores a un byte. FileWriter Crear flujos de bytes para enviar datos a un archivo. BufferedWriter Crear un filtro con área de almacenamiento en memoria ( buffer ) con lo que permite la escritura de bloques mayores a un byte.
  • 23. Lectura de un archivo de texto
    • String texto = "";
    • try {
    • FileReader fr = new FileReader("nombres.txt");
    • BufferedReader br = new BufferedReader(fr);
    • while (texto != null) {
    • texto = br.readLine();
    • if (texto != null) {
    • System.out.println(texto);
    • }
    • }
    • br.close();
    • } catch (IOException ex) {
    • ex.printStackTrace();
    • }
  • 24. Escritura de un archivo de texto
    • String texto = {"Elena", "Carolina", "Carmen Nora"};
    • try {
    • FileWriter fw =
    • new FileWriter("nombres.txt", false);
    • BufferedWriter bw = new BufferedWriter(fw);
    • for (String t : texto) {
    • bw.write(t);
    • bw.newLine();
    • }
    • bw.close();
    • } catch (IOException ex) {
    • ex.printStackTrace();
    • }
  • 25. Lectura de un archivo con Scanner
    • try {
    • File nombres = new File("nombres.txt");
    • Scanner sc = new Scanner(nombres);
    • while (sc.hasNextLine()) {
    • String texto = sc.readLine();
    • System.out.println(texto);
    • }
    • } catch (IOException ex) {
    • ex.printStackTrace();
    • }
  • 26. InputStream y OutputStream
    • Java proporciona las clases InputStream y OutputStream , ambas clases abstractas de las que derivan las clases principales de lectura y escritura a través de flujos de bytes (conocidos como streams ).
  • 27. Subclases de InputStream y OutputStream Subclase Descripción FileInputStream Abre un archivo para lectura. FileOutputStream Abre un archivo para escritura. DataInputStream Lee un flujo de bytes y lo convierte en primitivas válidas de Java. DataOutputStream Convierte primitivas válidas de Java y lo escribe como un flujo de bytes. ObjectInputStream Lee desde un archivo la estructura de un objeto. ObjectOutputStream Escribe en un archivo la estructura de un objeto. ByteArrayInputStream Lee un arreglo de bytes como si fuera un archivo. ByteArrayOutputStream Escribe en un arreglo de bytes como si fuera un archivo.
  • 28. Escritura de un archivo binario
    • try {
    • FileOutputStream fos =
    • new FileOutputStream("datos.bin");
    • ObjectOutputStream oos =
    • new ObjectOutputStream(fos);
    • oos.writeObject(
    • new Persona("Castro", "Aquiles", 'M', 21)
    • );
    • oos.close();
    • } catch (IOException ex) {
    • ex.printStackTrace();
    • }
  • 29. Lectura de un archivo binario
    • try {
    • FileInputStream fis =
    • new FileInputStream("datos.bin");
    • ObjectInputStream ois =
    • new ObjectInputStream(fis);
    • Persona persona = (Persona) ois.readObject();
    • System.out.println(persona.getNombres() + " " +
    • persona.getApellidos());
    • System.out.println(persona.getSexo());
    • System.out.println(persona.getEdad());
    • ois.close();
    • } catch (IOException ex) {
    • ex.printStackTrace();
    • }
  • 30. Serialización
    • La serialización es el proceso por el cual un objeto o una colección de objetos se convierten en una secuencia de bytes, los que pueden ser almacenados en un archivo y recuperados más adelante.
    • Cuando se serializa un objeto se almacena la estructura de la clase y los datos contenidos.
    • Para serializar y deserializar objetos se usa la interfaz java.io.Serializable .
  • 31. Ejemplo
    • import java.io.Serializable;
    • public class Persona implements Serializable {
    • private String apellidos;
    • private String nombres;
    • private char sexo;
    • private int edad;
    • .
    • .
    • .
    • }
  • 32. Muchas gracias por su atención.