Práctica III: Streams, Readers y Writers

Transcripción

1 Práctica III: Streams, Readers y Writers Objetivos En esta práctica vamos a aprender a utilizar Streams, Readers y Writers para realizar operaciones de entrada/salida desde programas escritos en el lenguaje Java. Esta práctica tiene una gran importancia ya que los mecanismos que vamos a utilizar serán la base sobre la que realizaremos la lectura/escritura de datos en sockets en fases posteriores de la práctica. Streams La traducción literal del término inglés Stream es el vocablo castellano Corriente, aunque algunos autores prefieren traducirlo como Flujo. Esto nos puede proporcionar intuición de que un Stream es una secuencia (corriente) ordenada de bytes, donde éstos pueden fluir en dos direcciones: hacia afuera (de salida) o hacia dentro (de entrada). Es decir, desde un programa vamos a poder escribir bytes en un Stream o leer bytes del Stream de manera secuencial, pero ten siempre en cuenta que los Streams no han sido diseñados para "volver hacia atrás" una vez que un byte ha sido leído o escrito. Los Streams son uno de los mecanismos más utilizados en el lenguaje Java para realizar operaciones de lectura/escritura sobre diversos dispositivos de los que la máquina virtual de Java nos ofrecerá una abstracción, incluyendo tarjetas de red, discos duros, etc. Por tanto, entre otras cosas, los Streams van a servirnos para leer y escribir información en ficheros o para leer y escribir información sobre un socket que pertenece a una conexión de red. Existen diferentes clases de Streams, cada una de las cuales está especializada en algún tipo de operación de lectura/escritura sobre un flujo de bytes. Observa el siguiente ejemplo y trata de comprender en detalle qué es lo que hace cada una de las clases del mismo. Cópialo en tu editor de textos favorito y ejecutarlo de modo que se escriban un conjunto de bytes en un fichero, y que posteriormente se lean: Fichero: EscribeEnteros.java import java.io.file; import java.io.fileoutputstream; import java.io.ioexception; public class EscribeBytes { private static byte[] lista ={1, 2, 10, 60; public static void main(string[] args) { if(args.length!= 1){ System.out.println("Debe especificar un nombre de fichero"); System.exit(-1);

2 File mifichero = new File(args[0]); try{ FileOutputStream salida = new FileOutputStream(miFichero); for(int i = 0; i < lista.length; i++){ salida.write(lista[i]); salida.flush(); salida.close(); catch(ioexception e) { System.out.println("Ha habido un problema de entrada y salidad producido por la excepción siguiente:"); e.printstacktrace(); Fichero: LeeEnteros.java import java.io.fileinputstream; import java.io.ioexception; public class LeeBytes { public static void main (String[] args) throws IOException{ if(args.length!= 1){ System.out.println("Debe especificar un nombre de fichero"); System.exit(-1); FileInputStream entrada = new FileInputStream(args[0]); int mibyte; while( (mibyte = entrada.read())!= -1){ System.out.println("Se ha leido el byte " + (byte)mibyte); Modifica el programa anterior de modo que se escriban en el fichero 100 enteros aleatorios y posteriormente se lean y se impriman por pantalla. Para lograrlo, las siguientes clases te serán de gran ayuda: java.io.dataoutputstream java.io.datainputstream java.util.random Repite el ejemplo anterior, pero ahora con 100 doubles aleatorios. Readers y Writers Cuando deseamos almacenar y recuperar información en forma de cadenas de caracteres los Streams de bytes y datos son complejos de utilizar y propensos a errores debido a la gran

3 multitud de formatos de codificación de caracteres que se utilizan en la actualidad. Esto no evita, sin embargo, que los flujos de datos en forma de cadenas de caracteres sean muy habituales y se usen con frecuencia en diversos ámbitos de la informática. En Java, los caracteres se representan en formato Unicode de 16 bits (cada carácter ocupa 2 bytes), pero pueden ser escritos y leídos en otros formatos que dependen del país o de la cultura en la que nos encontremos. Por estos motivos, el lenguaje Java proporciona un conjunto de clases que permiten realizar la lectura/escritura de flujos de caracteres de manera sencilla, siguiendo un esquema muy similar al utilizado por los Streams. Estas clases se conocen como Readers y Writers. Los Readers y Writers disponen de una completa jerarquía de clases, análoga a la de los Streams, que permite realizar múltiples tipos de operaciones. Dentro de la jerarquía existen un conjunto de clases que van a ser de gran utilidad a lo largo de la práctica, en particular, las siguientes merecen atención: BufferedReader: Lee caracteres del flujo pero utilizando un buffer intermedio. Es decir, cuando le pedimos leer un carácter del flujo, probablemente leerá un conjunto de ellos y los introducirá en un buffer, sacándolos del mismo a medida que los vayamos leyendo. De este modo mejoran las prestaciones del acceso. Esta clase dispone de un método readline() que será de gran utilidad. PrintWriter: En esta clase podemos escribir caracteres hacia un flujo utilizando los populares métodos print() y println(), lo que facilitará enormemente el formateo del texto. Utilizando la funcionalidad ofrecida por BufferedReader y PrintWriter escribe dos programas en Java que realicen lo siguiente: Programa 1: EscritorHTTP.java Este programa crea un PrintWriter que llamaremos salida y que está asociado a un fichero que denominaremos httpheader.txt. El programa escribirá lo siguiente en el fichero:... salida.print("get " + args[0] + " HTTP/1.1\r\n"); salida.print("host: " + args[1] + "\r\n"); salida.print("connection: close\r\n"); salida.print("\r\n");... Programa 2: LectorHTTP.java Este programa crea un BufferedReader asociado al fichero que acabamos de crear. Desde ese fichero, lee líneas y trata de recuperar la información relativa al recurso y al host sobre el que se estableció la petición HTTP (es decir, debe recuperar los argumentos args[0] y args[1] que se especificaron en la llamada a EscritorHTTP.java. Prueba a escribir este programa Java por ti mismo. Lectura y escritura de objetos Una funcionalidad muy interesante que se proporciona en el lenguaje Java es la posibilidad de escribir/leer un objeto completo a/desde un Stream. En la práctica, esto se traduce en que el objeto es transformado en una serie de bytes (es serializado) que pueden ser enviados a

4 un Stream de salida o leídos desde un Stream de entrada. Esta funcionalidad permite, por ejemplo, volcar un objeto sobre un fichero del disco y recuperarlo más tarde en el mismo estado en el que se depositó. Para poder leer y escribir objetos en un Stream se utilizan dos clases del paquete java.io: ObjectInputStream ObjectOutputStream Para que un objeto pueda ser "serializado" sobre un Object Stream, es necesario que el objeto implemente la interfaz Serializable (también definida en el paquete java.io). Los detalles de por qué esto es necesario son irrelevantes en nuestra asignatura. Lo único que debemos tener en cuenta a la hora de hacer que un objeto pueda ser enviado/recibido a través de un Object Stream son las siguientes indicaciones: Podemos definir la clase del objeto del modo habitual. Por ejemplo: public class miclase{ public ArrayList<Integer> arraydeenteros; Por defecto, al serializar un objeto de esa clase, se "serializan" todos los miembros de la misma, exceptuando aquellos que hayan sido precedidos de la palabra clave transient. Así, por ejemplo, si en la clase de ejemplo no queremos serializar el ArrayList de enteros (porque podría ser grande) deberíamos hacer: public class miclase{ Una vez definida la clase, hacemos que esta implemente la interfaz Serializable, para que pueda ser serializada. public class miclase implements Serializable { Es aconsejable añadir el siguiente atributo a la clase cuando se hace que esta implemente Serializable public class miclase implements Serializable { private static final long serialversionuid = ;//Hay que proporcionar un valor

5 El atributo serialversionuid es un mecanismo para el establecimiento de un número de serie a cada clase serializable. Este mecanismo permite que una clase serializable pueda evolucionar y convivir con versiones anteriores que puedan estar serializadas en ficheros u otros soportes. El valor que toma este atributo depende de los métodos y miembros definidos para la clase. Para calcularlo, hay que utilizar la herramienta serialver que se encuentra en el mismo directorio en el que está el compilador javac. Para hacerlo, sigue las instrucciones siguientes: Escribe la clase serializable sin incorporar el atributo serialversionuid Compila la clase serializable Ejecuta la herramienta serialver indicando el nombre de la clase serializable Copia serialversionuid obtenido en el fichero fuente la clase serializable Recompila la clase serializable Si quieres conocer más detalles sobre este misterioso atributo serialversionuid, puedes empezar leyendo el siguiente artículo: Ahora has aprendido a trabajar con Streams, Readers y Writers, escribe un programa en Java que realice lo siguiente: Define una clase Persona que almacene: nombre, apellidos, DNI, y edad. Realiza un programa que pueda leer los datos relativos a personas desde la entrada estándar System.in Cada persona que se lea, se debe almacenar en un HashMap, donde la llave será el DNI Permite que el programa serialice en un fichero ese HashMap y termine Cuando el programa vuelva a arrancar debe poder recuperar los datos introducidos previamente (recuperando el objeto previamente serializado)