Curso Programación en Java



Descargar 44,56 Kb.
Fecha de conversión27.05.2017
Tamaño44,56 Kb.

Curso Programación en Java

  • Tema 8
  • FLUJOS (ENTRADA/SALIDA )

FLUJOS Y ARCHIVOS

  • En Java un archivo es, sencillamente, una secuencia de bytes, que son la representación de los datos almacenados.
  • Java dispone de clases para trabajar las secuencias de bytes como datos de tipos básicos (int, double, String ...); incluso, para escribir o leer del objetos.
  • Un flujo (stream) es una abstracción que se refiere a corriente de datos que fluyen entre un origen o fuente (productor) y un destino o sumidero (consumidor). Entre el origen y el destino debe existir una conexión o canal ("pipe") por la que circulen los datos.
  • La apertura de un archivo supone establecer la conexión del programa con el dispositivo que contiene el archivo. Por el canal que comunica el archivo con el programa van a fluir las secuencias de datos.
  • Abrir un archivo supone crear un objeto que queda asociado con un flujo.
  • En un programa se crean automáticamente tres objetos flujo:
    • System.in; permite la entrada al programa de flujos de bytes desde el teclado.
    • System.out; permite al programa la salida de datos por pantalla.
    • System.err permite al programa salida de errores por pantalla
  • El flujo es por tanto una abstracción de tal forma que las operaciones que realizan los programas son sobre el flujo independientemente del dispositivo al que esté asociado.
  • El paquete java.io agrupa al conjunto de clases e interfaces necesarios para procesar archivos. Para utilizar estas clases será necesariola sentencia: import java.io.*.

CLASE File.

  • La clase File define métodos para conocer propiedades del archivo (última modificación, permisos de acceso, tamaño, ...); también métodos para modificar alguna característica del archivo.
  • Los constructores de File permiten inicializar el objeto con el nombre de un archivo y la ruta donde se encuentra. También, inicializar el objeto con otro objeto File como ruta y el nombre del archivo.
  • public File(String nombreCompleto)
  • public File(String ruta, String nombre)
  • public File(File ruta, String nombre)
  • Por ejemplo:
  • File miFichero = new File("C:\LIBRO\Almacen.dat");
  • File otro = new File("COCINA", "Enseres.dat");
  • Es una buena práctica crear objetos File con el archivo que se va a procesar, para pasar el objeto al constructor del flujo en vez de pasar directamente el nombre del archivo. De esta forma se pueden hacer controles previos sobre el archivo.
  • Al procesar archivos los nombres de las rutas relativas comienzan en la dirección actual. Para conocer la dirección actual se puede llamar al método:
  • System.getProperty("user.dir")

INFORMACIÓN DE FILE

  • Con los métodos de la clase File se obtiene información relativa al archivo o ruta con que se ha inicializado el objeto.
  • Los métodos mas útiles para conocer los atributos de un archivo o un directorio:
    • public boolean exists() true si existe el archivo(o el directorio)
    • public boolean canWrite() true si se puede escribir en el archivo
    • public boolean canRead() true si es de sólo lectura
    • public boolean isFile() true si es un archivo
    • public boolean isDirectory() true si es un directorio
    • public long length() número de bytes que ocupa el archivo
    • public String getName()
    • public String getPath()
    • public String getAbsolutePath() cadena con la ruta completa
    • public boolean delete()
    • public boolean renameTo(File nuevo)
    • public String[] list() devuelve un array de cadenas, cada una contiene un elemento(archivo o directorio) del directorio con el que se ha inicializado el objeto FILE

EJEMPLO(I)

  • Se muestra por pantalla cada uno de los archivos y subdirectorios de que consta un directorio que se transmite en la línea de ordenes.
  • La aplicación crea un objeto File inicializado con el nombre del directorio o ruta procedente de la línea de ordenes. El programa comprueba que es un directorio y llamando al método list() se obtiene un array de cadenas con todos los elementos del directorio.
  • Directorio.java
  • import java.io.*;
  • class Directorio
  • {
  • public static void main(String[] a)
  • {
  • File dir;
  • String[] cd;
  • // para la ejecución es necesario especificar el directorio
  • if (a.length > 0)
  • {
  • dir = new File(a[0]);
  • // debe ser un directorio

EJEMPLO(II)

  • Directorio.java
  • if (dir.exists() && dir.isDirectory())
  • {
  • // se obtiene la lista de elementos
  • cd = dir.list();
  • System.out.println("Elementos del directorio " + a[0]);
  • for (int i = 0; i < cd.length; i++)
  • System.out.println(cd[i]);
  • }
  • else
  • System.out.println("Directorio vacío");
  • }
  • else
  • System.out.println("No se ha especificado directorio ");
  • }
  • }

JERARQUIA DE CLASES

  • Las clases e interfaces que representan los flujos (stream) están agrupados en el paquete java.io.
  • Hay dos familias de clases:
    • Clases para procesar bytes, flujos de bytes
    • Clases para procesar caracteres, flujos de char (texto)
  • Por cada familia hay dos jerarquías: flujos de entrada y flujos de salida.
  • Entonces, se coonsideran 4 jerarquías, cuyas clases base son las siguientes:
    • InputStream flujo de entrada a nivel de bytes
    • OutputStream flujo de salida a nivel de bytes
    • Reader flujo de entrada con char
    • Writer flujo de salida con char
  • Las cuatro clases son clases abstractas. Además, la clase RandomAccesFile está definida para procesar archivos de acceso directo.
  • InputStream y Reader tienen el método básico de entrada read().
  • OutputStream y Writer tienen el método básico de salida write() .

JERARQUIAS a NIVEL de BYTES

  • Las clases base son InputStream y OutputStream:
  • InputStream OutputStream
  • FileInputStream FileOutputStream
  • PipedInputStream PipedOutputStream
  • ObjectInputStream ObjectOutputStream
  • StringBufferInputStream ByteArrayOutputStream
  • FilterInputStream FilterOutputStream
  • FilterInputStream FilterOutputStream
  • BufferedInputStream BufferedOutputStream
  • DataInputStream DataOutputStream
  • PrintStream

FileInputStream y FileOutputStream

  • Todo archivo, tanto para entrada como salida, se puede considerar como una secuencia de bytes. A partir de estas secuencias de bytes, flujos de bajo nivel, se construyen flujos de mas alto nivel para proceso de datos complejos. , desde tipos básicos hasta objetos.
  • FileInputStream y FileOutputStream se utilizan para leer o escribir bytes en un archivo.
  • Los constructores de ambas clases permiten crear flujos (objetos) asociados a un archivo que se encuentra en cualquier dispositivo, el archivo queda abierto.
    • FileInputStream(String nombre) throws FileNotFoundException
    • FileInputStream(File nombre) throws FileNotFoundException
    • FileOutputStream(String nombre) throws IOException
    • FileOutputStream(String nombre, boolean sw) throws IOException (sw = true, añade al final)
  • FileOutputStream(File nombre) throws IOException
  • Métodos de FileInputStream :
    • int read() throws IOException; devuelve –1 si lee carácter fin de fichero
    • int read(byte[] s) throws IOException
  • Métodos de FileOutoutStream :
    • void write(byte a) throws IOException
  • void write(byte[] s) throws IOException
  • Ambas clases disponen del método close() para cerrar el flujo.

EJEMPLO

  • Dado el archivo jardines.txt, se desea escribir toda su información en el archivo jardinOld.txt
  • import java.io.*;
  • public class CopiaArchivo
  • {
  • public static void main(String [] a)
  • {
  • FileInputStream origen = null;
  • FileOutputStream destino = null;
  • File f1 = new File("jardines.txt");
  • File f2 = new File("jardinOld.txt");
  • try
  • {
  • origen = new FileInputStream(f1);
  • destino = new FileOutputStream(f2);
  • int c;
  • while ((c = origen.read()) != -1)
  • destino.write((byte)c);
  • }
  • catch (IOException er)
  • {
  • System.out.println("Excepción en los
  • flujos " + er.getMessage());
  • }
  • finally {
  • try
  • {
  • origen.close();
  • destino.close();
  • }
  • catch (IOException er)
  • {
  • er.printStackTrace();
  • }
  • }
  • }
  • }
  • CLASES FILTRO
  • Los flujos filtro también leen secuencias de bytes, pero organizan internamente estas secuencias para formar datos de los tipos primitivos (int, long, double …). Los stream filtro son una abstración de las secuencias de bytes para hacer procesos de datos a mas alto nivel.
  • Los objetos stream filtro leen de un flujo que previamente ha tenido que ser escrito por otro objeto stream filtro de salida.
  • FilterInputStream y FilterOutputStream (derivan de InputSream y OutputStream), son las clases base de los filtros. Son clases abstractas que definen la funcionalidad común.
  • Los objeto stream filtro siempre están enlazados con secuencias de bytes. Al crear un objeto filtro se pasa como argumento un objeto stream que representa la secuencia de bytes que transformará (filtrará) el objeto creado.
  • Por ejemplo:
  • File mar = new File("Martas.dat");
  • FileInputStream fEntrada = new FileInputStream (mar);
  • LineNumberInputStream miFjo = new LineNumberInputStream (fEntrada)
  • DataInputStream y DataOutputStream(I)
  • La clases DataInputStream y DataOutputStream (derivan de FilterInputStream y FilterOutputStream respectivamente), filtran una secuencia de bytes, organizan los bytes para formar datos de tipo primitivo. De tal forma que se puedan escribir o leer directamente datos de tipo: char, byte, short, int, long, float, double, boolean, String .
  • DataInputStream declara el comportamiento de los flujos de entrada, con métodos que leen cualquier tipo básico: readInt(), readDouble(), readUTF(), ... Este tipo de flujos leen bytes de otro flujo de bajo nivel (flujo de bytes); por esa razón se asocian a un flujo de tipo InputStream, generalmente un flujo FileInputStream .
  • File mf = new File("nubes.dat");
  • DataInputStream ent = new DataInputStream(
  • new FileInputStream(mf));
  • Los flujos de salida, DataOutputStream, se asocian o enlazan con otro flujo de salida de bajo nivel, de bytes. Los métodos de este tipo de flujos permiten escribir cualquier valor de tipo de dato primitivo, int double ... y String
  • DataOutputStream snb = new DataOutputStream(
  • new FileOuputStream("nube.dat"))
  • Constructor:
  • public DataInputStream(InputStream entrada) throws IOException
  • public DataOutputStream(OutputStream entrada) throws IOException
  • DataInputStream
  • Métodos de DataInputStream:
  • public final boolean readBoolean() throws IOException
  • Devuelve el valor de tipo boolean leído
  • public final byte readByte() throws IOException
  • Devuelve el valor de tipo byte leído
  • public final short readShort() throws IOException
  • Devuelve el valor de tipo short leído
  • public final char readChar() throws IOException
  • Devuelve el valor de tipo char leído
  • public final int readInt() throws IOException
  • Devuelve el valor de tipo int leído
  • public final long readLong() throws IOException
  • Devuelve el valor de tipo long leído
  • public final float readFloat() throws IOException
  • Devuelve el valor de tipo float leído
  • public final double readDouble() throws IOException
  • Devuelve el valor de tipo double leído
  • public final String readUTF() throws IOException
  • Devuelve una cadena que se escribió en formato UTF.
  • El flujo de entrada lee un archivo que previamente ha sido escrito con un flujo de salida del tipo DataOutputStream.
  • El método close() se encuentra en DataInputStream y en DataOutputStream
  • UTF: Formato de transformación de unicode de 8 bits. Los 2 primeros bytes contienen el nº de bytes de la cadena
  • DataOutputStream
  • Métodos de DataOutputStream :
  • public final void writeBoolean(boolean v) throws IOException
  • Escribe el dato de tipo boolean v
  • public final void writeByte(int v) throws IOException
  • Escribe el dato v como un byte
  • public final void writeShort(int v) throws IOException
  • Escribe el dato v como un short
  • public final void writeChar(int v) throws IOException
  • Escribe el dato v como un carácter
  • public final void writeChars(String v) throws IOException
  • Escribe la secuencia de caracteres de la cadena v
  • public final void writeInt(int v) throws IOException
  • Escribe el dato de tipo int v
  • public final void writeLong(long v) throws IOException
  • Escribe el dato de tipo long v
  • public final void writeFloat(float v) throws IOException
  • Escribe el dato de tipo float v
  • public final void writeDouble(double v) throws IOException
  • Escribe el valor de tipo double v
  • public final void writeUTF(String cad) throws IOException
  • Escribe la cadena cad en formato UTF. Escibe los caracteres de la cadena y dos bytes adicionales con longitud de la cadena.
  • .
  • EJEMPLO-DataOutputStream
  • Suponer que se dispone de los datos registrados en la estación metereológica situada en el cerro Garabitas, correspondientes a un día del mes de Septiembre. La estructura de los datos: un primer registro con el día (p.e. 1 Septiembre); y para cada hora: hora, presión y temperatura. Los datos se han de grabar en el archivo "SeptGara.tmp" .
  • Para resolver el supuesto se define un flujo del tipo DataOutputStream asociado a otro flujo de salida a bajo nivel o simplemente flujo de bytes. Con el fin de simular la situación real, los datos se obtiene aleatoriamente, llamando al método Math.random() y transformando el número aleatorio en otro dentro de un rango preestablecido. Se utilizan los métodos writeUTF(), writeDouble() y writeInt()para escribir en flujo. En cuanto al tratamiento de excepciones, simplemente se capturan y se escribe el mensaje asociado a la excepción.
  • El archivo con la codificación es Garabitas.java
  • Garabitas.java (I)
  • import java.io.*;
  • public class Garabitas
  • {
  • public static void main(String[] a)
  • {
  • String dia = "1 Septiembre 2001";
  • DataOutputStream obfl = null;
  • try {
  • obfl = new DataOutputStream (
  • new FileOutputStream("septGara.tmp"));
  • obfl.writeUTF(dia); // escribe registro inicial
  • for (int hora = 0; hora < 24; hora++)
  • {
  • double presion, temp;
  • presion = presHora(); temp = tempHora();
  • // escribe según la estructura de cada registro
  • obfl.writeInt(hora);
  • obfl.writeDouble(presion);
  • obfl.writeDouble(temp);
  • }
  • }
  • Garabitas.java (II)
  • catch (IOException e)
  • {
  • System.out.println(" Anomalía en el flujo de salida " +
  • e.getMessage());
  • }
  • finally {
  • try
  • {
  • obfl.close();
  • }
  • catch (IOException er)
  • {
  • er.printStackTrace();
  • }
  • }
  • }
  • // métodos auxiliares
  • Garabitas.java (III)
  • static private double presHora()
  • {
  • final double PREINF = 680.0;
  • final double PRESUP = 790.0;
  • return (Math.random()*(PRESUP - PREINF) + PREINF);
  • }
  • static private double tempHora()
  • {
  • final double TEMINF = 5.0;
  • final double TEMSUP = 40.0;
  • return (Math.random()*(TEMSUP - TEMINF) + TEMINF);
  • }
  • }
  • EJEMPLO-DataInputStream
  • Se tiene el archivo "SeptGara.tmp" creado con un flujo DataOutputStream; la estructura de datos de los registros es la siguiente: el primer registro es una cadena escrita con formato UTF; los demás registros tienen los datos: hora(tipo int), presión(tipo double) y temperatura(tipo double). Se quiere escribir un programa para leer cada uno de los datos, calcular la temperatura máxima y mínima y mostrar los resultados por pantalla.
  • Para leer los datos del archivo se necesita un flujo DataInputStream. Al conocer perfectamente la estructura de los campos se procede a la lectura con los métodos read adecuados. Primero se lee la cadena inicial con la fecha (readUTF()); a continuación se leen los campos hora, temperatura y presión con los métodos readInt(), readDouble() y readDouble(). Hay que leer todo el archivo mediante el típico bucle mientras no fin de fichero; sin embargo la clase DataInputStream no dispone del método eof(), por ello el bucle está diseñado como un bucle infinito; la salida del bucle se produce cuando un método intente leer después de fin de fichero, entonces lanza la excepción EOFException y termina el bucle.
  • El nombre del programa es LeeGarabitas.java
  • LeeGarabitas.java(I)
  • import java.io.*;
  • class LeeGarabitas
  • {
  • public static void main(String[] a)
  • {
  • String dia;
  • double mxt = -11.0; // valor mínimo para encontrar máximo
  • FileInputStream f;
  • DataInputStream obfl = null;
  • try {
  • f = new FileInputStream("septGara.tmp");
  • obfl = new DataInputStream(f);
  • }
  • catch (IOException io)
  • {
  • System.out.println("Anomalía al crear flujo de entrada, " +
  • io.getMessage());
  • return; // termina la ejecución
  • }
  • // proceso del flujo
  • try {
  • int hora;
  • boolean mas = true;
  • double p, temp;
  • dia = obfl.readUTF();
  • System.out.println(dia);
  • while (mas) LeeGarabitas.java(II)
  • {
  • hora = obfl.readInt();
  • p = obfl.readDouble();
  • temp = obfl.readDouble();
  • System.out.println("Hora: " + hora + "\t Presión: " + p
  • + "\t Temperatura: " + temp);
  • mxt = Math.max(mxt,temp);
  • }
  • }
  • catch (EOFException eof)
  • {
  • System.out.println("Fin de lectura del archivo.\n");
  • }
  • catch (IOException io)
  • {
  • System.out.println("Anomalía al leer flujo de entrada, "
  • + io.getMessage());
  • return; // termina la ejecución
  • }
  • finally {
  • try
  • {
  • obfl.close();
  • }
  • catch (IOException er)
  • {
  • er.printStackTrace();
  • }
  • }
  • System.out.println("\n La temperatura máxima: " + (float)mxt);
  • }
  • }
  • PrintStream
  • PrintStream deriva directamente de FilterOutputStream, la característica mas importante es que dispone de métodos que añaden la marca de fin de línea.
  • Los flujos tipo PrintStream son de salida que se asocian con otro flujo de bajo nivel, de bytes, que a su vez se crea asociado a un archivo externo.
  • PrintStream fjp = new PrintStream(new FileOutputStream("Complex.dat"));
  • Constructores:
  • public PrintStream(OutputStream destino)
  • public PrintStream(OutputStream destino, boolean s) { s = true, volcado automático }
  • Métodos: print() y println() para cada tipo de dato primitivo.
  • public void print(Object obj); void println(Object o);
  • public void print(String cad); void println(string c);
  • public void print(char c) ...
  • public void flush() Vuelca el flujo actual
  • System.out es de tipo PrintStream, asociado, normalmente, con la pantalla.
  • FLUJOS DE CHAR (TEXTO)
  • Reader es la clase base, abstracta, de la jerarquía de clases para leer un carácter o una secuencia de caracteres. Writer es la clase base, abstracta, de la jerarquía de clases diseñadas para escribir caracteres.
  • Reader Writer
  • BufferedReader BufferedWriter
  • InputStreamReader OutputWriter
  • FileReader FileWriter
  • FilterReader FilterWriter
  • PrintWriter
  • Los flujos de la clase InputStreamReader envuelven a un flujo de bytes; convierte la secuencia de bytes en secuencia de caracteres. Generalmente se utilizan estos flujos como entrada en la construcción de flujos con buffer.
  • En el siguiente ejemplo se crea el flujo entradaChar que puede leer caracteres del flujo de bytes System.in ( asociado con el teclado):
  • InputStremReader entradaChar = new InputStreamReader(System.in);
  • BufferedReader ent = new BufferedReader(entradaChar); // para utilizar el método readLine()
  • FileReader
  • Para leer archivos de texto, archivos de caracteres, se puede crear un flujo del tipo FileReader. Esta clase deriva de InputStreamReader, hereda los métodos read() para lectura de caracteres. Ell constructor tiene como entrada una cadena con el nombre del archivo.
  • public FileReader(String miFichero) throws FileNotFoundException;
  • Por ejemplo,
  • FileReader fr = new FileReader("C:\cartas.dat");
  • No resulta eficiente, en general, leer directamente de un flujo FileReader; se utilizará un flujo BufferedReader envolviendo al flujo FileReader.
  • BufferedReader
  • La lectura de archivos de texto se realiza con un flujo que almacena los caracteres en un buffer intermedio. Los caracteres no se leen directamente del archivo sino que se leen del buffer; con esto se consigue mas eficiencia en las operaciones de entrada .
  • BufferReader permite crear flujos de caracteres con buffer, es una forma de organizar el flujo básico de caracteres; esto se manifiesta en que al crear el flujo BufferReader se inicializa con un flujo de caracteres (InputStreamReader ...) .
  • El constructor de la clase tiene un argumento de tipo Reader.
  • File mf = new File("C:\listados.txt");
  • FileReader fr = new FileReader(mf);
  • BufferedReader bra = new BufferedReader(fr);
  • File mfz = new File("Complejo.dat");
  • BufferedReader brz = new BufferedReader(new InputStreamReader(
  • new FileInputStream(mfz)));
  • El método más importante es readLine(); lee una línea de caracteres, termina con el carácter de fin de línea, y devuelve una cadena con la línea leída (no incluye el carácter fin de línea). Puede devolver null si lee la marca de fin de archivo.
  • public String readLine() throws IOException;
  • EJEMPLO -BufferedReader
  • Para ver el contenido de un archivo de texto se van a leer línea a línea hasta leer la marca de fin de fichero. El nombre completo del archivo se ha de transmitir en la línea de ordenes de la aplicación.
  • LeerTexto.java (I)
  • import java.io.*;
  • public class LeerTexto
  • {
  • public static void main(String[] a)
  • {
  • File mf;
  • BufferedReader br = null;
  • String cd;
  • // se comprueba que hay una cadena
  • if (a.length > 0)
  • {
  • mf = new File(a[0]);
  • LeerTexto.java(II)
  • if (mf.exists())
  • {
  • int k = 0;
  • try {
  • br = new BufferedReader(new FileReader(mf));
  • while ((cd = br.readLine()) != null)
  • {
  • System.out.println(cd);
  • if ((++k)%21 == 0)
  • {
  • System.out.print("Pulse una tecla ...");
  • System.in.read();
  • }
  • }
  • br.close();
  • }
  • catch (IOException e)
  • {
  • System.out.println(e.getMessage());
  • }
  • }
  • else
  • System.out.println("Directorio vacío");
  • }
  • }
  • }
  • FLUJOS QUE ESCRIBEN CARACTERES
  • La clase Writer define métodos write() para escribir arrays de caracteres o cadenas (String). De Writer deriva OutputStreamWriter que permite escribir caracteres en un flujo de bytes al cual se asocia en la creación del objeto o flujo.
  • Por ejemplo
  • OutputStreamWriter ot = new OutputStreamWriter(
  • new FileOutputStream(archivo));
  • la clase FileWriter es una extensión de OutputStreamWriter, diseñada para escribir en un archivo de caracteres. Los flujos de tipo FileWriter escriben caracteres, método write(), en el archivo asociado el flujo cuando se crea el objeto.
  • FileWriter nr = new FileWriter("cartas.dat");
  • nr.write("Estimado compañero de fatigas");
  • Los flujos mas utilizados para salida de caracteres son de tipo PrintWriter
  • PrintWriter
  • Esta clase declara constructores para asociar un flujo PrintWriter con cualquier otro flujo de tipo Writer, o bien OutputStream. Constuctores:
  • PrintWriter(OutputStream destino)
  • PrintWriter(Writer destino)
  • La importancia de esta clase radica en que define los métodos print() y println() para cada uno de los tipos de datos simples, para String y para Object.
  • public void print(Object obj)
  • public void print(String cad)
  • public void print(char c)
  • Sobrecarga de print() para cada tipo de dato primitivo
  • public void println(Object obj)
  • public void println(String cad)
  • public void println(char c)
  • Sobrecarga de println()para cada tipo de dato primitivo
  • EJEMPLO - PrintWriter
  • En un archivo de texto se va a escribir los caminos directos entre los pueblos de una comarca alcarreña. Cada línea contiene el nombre de dos pueblos y la distancia del camino que los une (sólo si hay camino directo) separados por un blanco. La entrada de los datos es a partir del teclado.
  • El archivo de texto, argumento de la línea de ordenes, se maneja con un objeto File de tal forma que si ya existe se crea un flujo de bytes FileOutputStream con la opción de añadir al final. Este flujo se utiliza para componer un flujo de mas alto nivel, DataOutputStream, que a su vez se le asocia con el flujo PrintWriter para escribir datos con los métodos print y println.
  • La entrada es a partir del teclado, se repiten las entradas hasta que el método readLine() devuelve null (cadena vacía) debido a que el usuario ha tecleado ^Z; o bien termina al pulsar una línea vacía. La cadena leída inicializa un objeto de la clase StringTokenizer para comprobar que se han introducido correctamente los datos pedidos.
  • Nombre del programa: EscribeCamino.java
  • EscribeCamino.java(I)
  • import java.io.*;
  • import java.util.StringTokenizer;
  • class EscribeCamino
  • {
  • static boolean datosValidos(String cad) throws Exception
  • {
  • StringTokenizer cd;
  • String dist;
  • boolean sw;
  • cd = new StringTokenizer(cad);
  • sw = cd.countTokens() == 3;
  • cd.nextToken();
  • sw = sw && (Integer.parseInt(cd.nextToken()) > 0);
  • return sw;
  • }
  • public static void main(String[] a)
  • {
  • File mf;
  • BufferedReader entrada = new BufferedReader(
  • new InputStreamReader(System.in));
  • EscribeCamino.java(II)
  • DataOutputStream d = null;
  • PrintWriter pw = null;
  • String cad;
  • boolean modo;
  • // se comprueba que hay una cadena
  • if (a.length > 0)
  • {
  • mf = new File(a[0]);
  • if (mf.exists())
  • modo = true;
  • else
  • modo = false;
  • try {
  • pw = new PrintWriter( new DataOutputStream (
  • new FileOutputStream(mf,modo)));
  • System.out.println("Pueblo_A distancia Pueblo_B");
  • EscribeCamino.java(III)
  • while (((cad = entrada.readLine())!= null)&& (cad.length() > 0))
  • {
  • if (datosValidos(cad))
  • pw.println(cad);
  • }
  • pw.close();
  • }
  • catch (Exception e)
  • {
  • System.out.println(e.getMessage());
  • e.printStackTrace();
  • }
  • }
  • else
  • System.out.println("Archivo no existente ");
  • }
  • }

ARCHIVOS DE OBJETOS

  • Para que un objeto persista una vez que termina la ejecución de una aplicación se ha de guardar en un archivo de objetos. Por cada objeto que se almacena en un archivo se graban características de la clase y los atributos del objeto
  • Las clases ObjectInputStream y ObjectOutputStream están diseñadas para crear flujos de entrada y salida de objetos persistentes .
  • La clase cuyos objetos van a persistir debe de implementar el interface Serializable del paquete java.io. Es un interface vacío, no declara métodos, simplemente indica a la JVM que las instancias de estas clases podrán grabarse en un archivo.
  • class Racional implements Serializable {...}
  • Los atributos de los objetos declarados transient no se escriben al grabar un objeto en un archivo.
  • class TipoObjeto implements Serializable
  • {
  • transient tipo dato;// no se escribe en el flujo de objetos
  • }

Flujos ObjectOutputStream

  • la clase ObjectOutputStream se utiliza para grabar objetos persistentes. El método writeObject() escribe cualquier objeto de una clase serializable en el flujo de bytes asociado; puede elevar excepciones del tipo IOException que es necesario procesar.
  • public void writeObject(Object obj) throws IOException;
  • El constructor de la clase espera un argumento de tipo OutputStream, que es la clase base de los flujos de salida a nivel de bytes.
  • FileOutputStream bn = new FileOutputStream("datosRac.dat");
  • ObjectOutputStream fobj = new ObjectOutputStream(bn);
  • A continuación se puede escribir cualquier tipo de objeto en el flujo:
  • Racional rd = new Racional(1,7);
  • fobj.writeObject(rd);
  • String sr = new String("Cadena de favores");
  • fpbj.writeObj(sr);

Flujos ObjectInputStream

  • Los objetos guardados en archivos con flujos de la clase ObjectOutputStream se recuperan, se leen, con flujos de entrada del tipo ObjectInputStream . Esta clase es una extensión de InputStream, además implementa el interface DataInput; por ello dispone de los diversos métodos de entrada (read) para cada uno de los tipos de datos, readInt()
  • El método mas interesante definido por la clase ObjectInputStream es readObject(), lee un objeto del flujo de entrada (del archivo asociado al flujo de bajo nivel); este objeto se escribió en su momento con el método writeObject().
  • public Object readObject() throws IOException;
  • El constructor de flujos ObjectInputStream tiene como entrada otro flujo, de bajo nivel, de cualquier tipo derivado de InputStream, por ejemplo FileInputStream, asociado con el archivo de objetos.
  • ObjectInputStream obje = new ObjectInputStream(
  • new FileInputStream("archivoObjets.dat "));
  • El constructor levanta una excepción si, por ejemplo, el archivo no existe,..., del tipo ClassNotFoundException, o bien IOException; es necesario poder capturar estas excepciones.

EJEMPLO DE SERIALIZACIÓN de OBJETOS

  • Se desea guarda en un archivo los libros y discos de que disponemos. Los datos de interés para un libro son: título, autor, editorial, número de páginas; para un disco: cantante, título, duración en minutos, numero de canciones y precio.
  • Se podría diseñar una jerarquía de clases que modelase los objetos libro, disco, ... . Sin embargo el ejercicio sólo pretende mostrar cómo crear objetos persistentes; declara directamente las clases Libro y Disco con la propiedad de ser "serializables" (implementan el interface java.io.Serializable). La clase principal crea un flujo de salida para objetos; según los datos que introduce el usuario se instancia un tipo de objeto Disco o Libro y con el método writeObject() se escribe en el flujo.
  • Nombre de la aplicación: Libreria.java
  • Libreria.java(I)
  • import java.io.*;
  • class Libro implements Serializable
  • {
  • private String titulo;
  • private String autor;
  • private String editorial;
  • private int pagina;
  • public Libro()
  • {
  • titulo = autor = editorial = null;
  • }
  • public Libro(String t, String a, String e, int pg)
  • {
  • titulo = t;
  • autor = a;
  • editorial = e;
  • pagina = pg;
  • }
  • public void entrada(BufferedReader ent) throws IOException
  • {
  • System.out.print("Titulo: "); titulo = ent.readLine();
  • System.out.print("Autor: "); autor = ent.readLine();
  • System.out.print("Editorial: "); editorial = ent.readLine();
  • System.out.print("Páginas: ");
  • pagina = Integer.parseInt(ent.readLine());
  • }
  • }
  • Libreria.java(II)
  • class Disco implements Serializable
  • {
  • private String artista;
  • private String titulo;
  • private int numCancion, duracion;
  • private transient double precio;
  • public Disco()
  • {
  • artista = titulo = null;
  • }
  • public Disco(String a, String t, int n, int d, double p)
  • {
  • titulo = t;
  • artista = a;
  • numCancion = n;
  • duracion = d;
  • precio = p;
  • }
  • public void entrada(BufferedReader ent) throws IOException
  • {
  • System.out.print("Cantante: "); artista = ent.readLine();
  • System.out.print("Titulo: "); titulo = ent.readLine();
  • System.out.print("Canciones: ");
  • numCancion = Integer.parseInt(ent.readLine());
  • System.out.print("Duración(minutos): ");
  • duracion = Integer.parseInt(ent.readLine());
  • System.out.print("Precio: ");
  • precio = Double.valueOf(ent.readLine()).doubleValue();
  • }
  • }
  • Libreria.java(III)
  • public class Libreria
  • {
  • public static void main (String [] a)
  • {
  • BufferedReader br = new BufferedReader(
  • new InputStreamReader(System.in));
  • File mf = new File("libreria.dat");
  • ObjectOutputStream fobj = null;
  • Libro libro = new Libro();
  • Disco disco = new Disco();
  • int tipo;
  • boolean mas = true;
  • try {
  • fobj = new ObjectOutputStream(new FileOutputStream(mf));
  • do {
  • System.out.println
  • ("Pulsa L(libro), D(disco), F(finalizar)");
  • tipo = System.in.read();
  • System.in.skip(2); // salta caracteres fin de línea
  • Libreria.java(IV)
  • switch (tipo) {
  • case 'L':
  • case 'l': libro = new Libro();
  • libro.entrada(br);
  • fobj.writeObject(libro);
  • break;
  • case 'D':
  • case 'd': disco = new Disco();
  • disco.entrada(br);
  • fobj.writeObject(disco);
  • break;
  • case 'F':
  • case 'f': fobj.close();
  • mas = false;
  • }
  • } while (mas);
  • }
  • catch (IOException e)
  • {
  • e.printStackTrace();
  • }
  • }
  • }


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal