E/S con flujos (streams)

„ En Java se define la abstracción de stream (flujo) para tratar la comunicación de información entre el programa y el exterior „ Entre una fuente y un destino fluye una secuencia de datos „ Los flujos actúan como interfaz con el dispositivo o clase asociada

„

Operación independiente del tipo de datos y del dispositivo „ Mayor flexibilidad (p.e. redirección, combinación) „ Diversidad de dispositivos (fichero, pantalla, teclado, red, …) „ Diversidad de formas de comunicación • Modo de acceso: secuencial, aleatorio • Información intercambiada: binaria, caracteres, líneas



EL TRY CATCH



***********************************************************************************

abstract class InputStream

InputStream es una clase abstracta de la que no pueden crearse objetos. No obstante, todos los objetos que se creen de clases derivadas dispondrán de algunas operaciones interesantes:

abstract class InputStream { int read () throws IOException; int read (byte[] b) throws IOException; int read (byte[] b, int desde, int n) throws IOException; ... ... ... }

int read ()

Lee el siguiente byte del InputStream. El byte leido se devuelve como un entero en el rango [0..255].
Si no hubiera byte que leer porque el InputStream ha llegado a su final, se devuelve el valor -1.

int read (byte[] b)

Lee unos cuantos bytes del InputStream y los coloca en el array. Devuelve el número de bytes que ha leido (puede ser menor que el tamaño del array, si no estuvieran disponibles).
Si no hubiera byte que leer porque el InputStream ha llegado a su final, se devuelve el valor -1.

int read (byte[] b, int desde, int n)

Lee unos cuantos bytes del InputStream y los coloca en el array. Devuelve el número de bytes que ha leido (puede ser menor que n, si no estuvieran disponibles). Los bytes leidos se colocan en el array a partir de la posición b[desde] en adelante.
Si no hubiera byte que leer porque el InputStream ha llegado a su final, se devuelve el valor -1.

class FileInputStream

Esta sí es una clase de la que se pueden crear objetos:

  class FileInputStream extands InputStream {
    FileInputStream (String fichero) throws FileNotFoundException;
    FileInputStream (File fichero) throws FileNotFoundException;
    ... ... ...
  }

Esto nos permite leer bytes de un fichero y poco más.

abstract class OutputStream

OutputStream es una clase abstracta de la que no pueden crearse objetos. No obstante, todos los objetos que se creen de clases derivadas dispondrán de algunas operaciones interesantes:

  abstract class OutputStream {
    void write (int b) throws IOException;
    void write (byte[] b) throws IOException;
    void write (byte[] b, int desde, int n) throws IOException;
    ... ... ...
  }

que respectivamente escriben un byte, un array de bytes, o una zona de un vector de bytes.

class FileOutputStream

Esta sí es una clase de la que se pueden crear objetos:

  class FileOutputStream extends OutputStream {
    FileOutputStream (String fichero) throws FileNotFoundException;
    FileOutputStream (File fichero) throws FileNotFoundException;
    ... ... ...
  }

Esto nos permite escribir bytes en un fichero y poco más.

Un ejemplo clásico de uso de InputStream y OutputStream en la copia de un fichero en otro:

void copia (String origen, String destino) throws IOException { InputStream in= new FileInputStream(origen); OutputStream out= new FileOutputStream(destino); byte[] buffer= new byte[256]; while (true) { int n= in.read(buffer); if (n < 0) break; out.write(buffer, 0, n); } in.close(); out.close(); }

Nótese que el tamaño del buffer es poco relevante en cuanto a funcionalidad, aunque diferentes tamaños pueden tener un impacto notable sobre la velocidad de ejecución del programa.

class PrintStream

Una clase muy interesante, y a la que el lector estará acostumbrado pues los objetos System.out y System.err son de esta clase.

  class FilterOutputStream extends OutputStream {
    // esta es una clase auxiliar
    // en cuyo detalle no entraremos
  }

  class PrintStream extends FilterOutputStream {
    PrintStream (OutputStream out);
    PrintStream (OutputStream out, boolean autoflush);

    void print (long v);
    void print (int v);
    void print (float v);
    void print (double v);
    void print (boolean v);
    void print (Object v);	// usa v.toString()
    ... ... ...
    void println (long v);
    void println (int v);
    void println (float v);
    void println (double v);
    void println (boolean v);
    void println (Object v);	// usa v.toString()
    ... ... ...
  }

Bytes y caracteres

Un byte es un conjunto de 8 bits que puede representar hasta 256 valores.

Un carácter en Java se representa con 16 bits, capacitando a los programas para manejar 65536 caracteres. Para codificar los caracteres se utiliza el convenio denominado Unicode.

Ahora el problema es que los ficheros manejan bytes (8 bits) en los que hay que escribir caracteres (16 bits) y leerlos. Necesitamos pues un convenio de codificación.

Un convenio de codificación muy básico consiste en decir que

1. en escritura sólo se escriben los 8 últimos bits del carácter
2. en lectura se lee un byte y se le anteponen 8 ceros
es decir, que sólo tratamos los 8 últimos bits de los caracteres.

Este criterio es muy cómodo para nosotros porque Unicode utiliza los primeros 256 caracteres de acuerdo a la norma ISO 8859-1, que cubre todas las necesidades de un idioma como el Español por lo que probablemente no necesitemos más en un uso normal.

Los objetos derivados de InputStream utilizan el criterio básico, rellenando de ceros los bits que le faltan a un byte. Así funcionan las siguientes expresiones:

  int i= is.read();		// de byte a entero
  char c= (char)is.read();	// de byte a carácter
  int i= (int)caracter;		// de carácter a entero

Los objetos derivados de OutputStream utilizan el criterio básico, quedándose sólo con los 8 últimos bits. Así funcionan las siguientes expresiones:

  byte b= (byte)caracter;	// de carácter a byte
  byte b= (byte)entero;		// de entero a byte
  out.print(caracter);		// de carácter a byte
  out.print(string);		// de carácter a byte

Referencias

El paquete java.io contiene muchas más clases y métodos que los visto en este breve nota. Los detalles están en:

package java.io

Flujos estándar

„ System.in

Instancia de la clase InputStream: flujo de bytes de entrada „ Metodos • read() permite leer un byte de la entrada como entero • skip(n ) ignora n bytes de la entrada • available() número de bytes disponibles para leer en la entrada

System.out

„ Instancia de la clase PrintStream: flujo de bytes de salida „ Metodos para impresión de datos • print(), println() • flush() vacía el buffer de salida escribiendo su contenido

System.err

Funcionamiento similar a System.out „ Se utiliza para enviar mensajes de error (por ejemplo a un fichero de log o a la consola)

Flujos Estandar

Utilización de los flujos

„ Los flujos se implementan en las clases del paquete java.io „ Esencialmente todos funcionan igual, independientemente de la fuente de datos „ Clases java.io.Reader y java.io.Writer

Utilización de los flujos

„ Lectura 1. Abrir un flujo a una fuente de datos (creación del objeto stream) • Teclado • Fichero • Socket remoto 2. Mientras existan datos disponibles • Leer datos 3. Cerrar el flujo (método close) „ Escritura 1. Abrir un flujo a una fuente de datos (creación del objeto stream) • Pantalla • Fichero • Socket local 2. Mientras existan datos disponibles • Escribir datos 3. Cerrar el flujo (método close)

Nota: para los flujos estándar ya se encarga el sistema de abrirlos y cerrarlos

Entrada de texto desde un fichero