Anexo Práctica 2: Entrada / Salida en Java 1.- Flujos de bytes (byte streams) 2.- Flujos de caracteres 3.- Utilidades para E/S de cadenas formateadas 4.- Flujos de E/S Estándar 5.- Flujos de datos 6.- Flujos de objetos Nota: en el directorio de prácticas y en PoliformaT puedes descargar los ficheros de código fuente de los ejemplos que aparecen en este anexo. Entrada / Salida en Java Un flujo de entrada/salida (I/O Stream) representa una secuencia de datos que pueden leerse desde un dispositivo de entrada o escribirse en un dispositivo de salida. Un stream puede manejar diferentes tipos de datos: bytes, caracteres, tipos primitivos, cadenas, e incluso objetos. En los paquetes java.io y java.util de la distribución de Java están incluidas las clases para el manejo de streams. A continuación se ilustra con ejemplos cómo leer/escribir de manera secuencial en un fichero utilizando distintos tipos de datos y cómo manejar la entrada/salida estándar (leer de teclado y escribir en pantalla). Para más información sobre E/S puede consultar los tutoriales de Java en http://java.sun.com. 1.- Flujos de bytes (byte streams) Las operaciones de entrada/salida pueden realizarse a nivel de byte (de 8 bits). Las clases que manejan los streams de bytes descienden de las clases abstractas InputStream y OutputStream. Estas clases implementan operaciones de E/S de bajo nivel. Aunque normalmente no se utilizan, es importante conocerlas porque el resto de streams de otros tipos de datos, se construyen sobre streams de bytes. Para leer bytes desde fichero se utiliza la clase java.io.fileinputstream. Algunos de los métodos esa clase son: FileInputStream (String nombrefichero): constructor que crea un objeto flujo de bytes para leer del fichero de nombre nombrefichero. FileInputStream (File f): constructor crea un objeto flujo de bytes para leer del fichero de descriptor f. int available(): bytes disponibles en el flujo. void close(): cierra el flujo de datos. int read(): devuelve el valor del byte (0 a 255) o -1 si no hay bytes disponibles. int read(byte[] barray): guarda los bytes leídos en el vector. int read(byte[] barray, int offset, int n): guarda en el vector los n bytes leídos a partir de offset. long skip(long n): elimina n bytes del flujo.
Para escribir bytes en fichero se utiliza java.io.fileoutputstream cuyos métodos son: FileOutputStream (String nombrefichero): crea un objeto flujo de bytes para escribir en el fichero de nombre nombrefichero. Si el fichero no existe lo crea, y si existe lo sobrescribe. FileOutputStream (String nombrefichero, boolean append): añade bytes al fichero si append vale true. FileOutputStream (File f): crea un objeto flujo de bytes para escribir en el fichero de descriptor f. Si el fichero no existe lo crea, y si existe lo sobrescribe. void close(): cierra el flujo de datos. void flush(): vuelca los datos almacenados en un búfer intermedio en el flujo de salida (para ciertas subclases). void write(int n): escribe el byte n en el flujo. void write(byte[] barray): escribe los bytes del vector en el flujo. void write(byte[] barray, int offset, int n): escribe los n bytes del vector, a partir del índice offset, en el flujo. A continuación se muestra un ejemplo, que copia el contenido del fichero entrada.txt en el fichero salida.txt leyendo byte a byte. La operación read() devuelve el siguiente byte en el archivo. El valor de retorno se utiliza para comprobar si quedan bytes en el archivo (si read() devuelve -1 es porque se ha alcanzado al final del archivo). import java.io.fileinputstream; import java.io.fileoutputstream; import java.io.ioexception; public class CopiarBytes { public static void main(string[] args) throws IOException{ FileInputStream entrada=null; FileOutputStream salida=null; entrada= new FileInputStream("entrada.txt"); salida= new FileOutputStream("salida.txt"); int c; while ((c=entrada.read())!=-1){ salida.write(c); catch(ioexception e) { finally{ if (entrada!=null){ entrada.close(); if (salida!=null){ salida.close(); En la programación de la E/S debe escribirse código para capturar la excepción IOException que puede producirse en caso de error en la E/S, (p.e. si la fuente de datos no está disponible, el fichero no existe, no tiene permisos de escritura, el disco está lleno, etc.). Por ello, en el ejemplo se ha marcado con un bloque try el código correspondiente a las operaciones read() y write(). Para asegurar que los streams se cierran se ha escrito la operación close() en un bloque finally.
2.- Flujos de caracteres Las clases que manejan flujos de caracteres transforman los bytes en caracteres según el juego de caracteres local (o el que el programador especifique). Todas ellas descienden de las clases abstractas Reader y Writer. Las que podemos considerar de propósito general son: java.io.inputstreamreader y java.io.outputstreamwriter. Los flujos de caracteres se definen sobre flujos de bytes. Así, para crear un flujo de caracteres sobre un fichero, es necesario que crear previamente un flujo de bytes sobre dicho fichero, como se muestra a continuación: InputStreamReader in = new InputStreamReader (new FileInputStream ( fichero )); Los métodos más usuales de InputStreamReader son: InputStreamReader(InputStream in): construye un flujo de caracteres de lectura a partir de un flujo de bytes, utilizando el juego de caracteres local. InputStreamReader(InputStream in, Charset cs): construye un flujo de caracteres de lectura a partir de un flujo de bytes. Permite especificar el juego de caracteres. int read(): lee un carácter. int read(char[] buf, int off, int n): lee n caracteres que almacena en el vector buf desde la posición off. Devuelve el núm. de caracteres leído o -1 si se llega al final del flujo. boolean ready(): indica si el buffer está listo o no (p.e. si está vacío) Y los de OutputStreamWriter: OutputStreamWriter(OutputStream in): construye un flujo de caracteres de escritura a partir de un flujo de bytes, utilizando el juego de caracteres local. OutputStreamWriter(OutputStream in, Charset cs): construye un flujo de caracteres de escritura a partir de un flujo de bytes. Permite especificar el juego de caracteres. void write(int c): escribe un carácter. void write(char[] buf, int off, int n): escribe n caracteres del vector buf desde la posición off. void write(string s, int off, int n): escribe n caracteres de la cadena s desde la posición off. void flush(): vuelca los datos en el flujo de salida. Aparte de estas clases, existen otras especializadas en el manejo de la entrada/salida con ficheros: java.io.filereader y java.io.filewriter (descendientes de InputStreamReader y OutputStreamWriter, respectivamente). Éstas transforman los bytes en caracteres utilizando el juego de caracteres local. El constructor tiene un único parámetro donde se indica el nombre del fichero. El resto de métodos son los heredados de InputStreamReader y OutputStreamWriter. A continuación se muestra un ejemplo, CopiarCaracteres, que es exactamente igual al ejemplo CopiarBytes. La única diferencia es que, en este caso, la variable entera c almacena un carácter (16 bits).
import java.io.filereader; import java.io.filewriter; import java.io.ioexception; public class CopiarCaracteres { public static void main(string[] args) throws IOException{ FileReader entrada=null; FileWriter salida=null; entrada= new FileReader("entrada.txt"); salida= new FileWriter("salida_car.txt"); int c; while ((c=entrada.read())!=-1){ salida.write(c); catch(ioexception e) { finally{ if (entrada!=null){ entrada.close(); if (salida!=null){ salida.close(); Una forma habitual de procesar un fichero de texto es línea a línea. El paquete java.io proporciona las clases BufferedReader y PrintWriter que están diseñadas para leer y escribir texto, independientemente del carácter terminador de línea ( \r, \n, \r\n ). La clase BufferedReader proporciona métodos para la lectura de caracteres y líneas. Utiliza un buffer de memoria lo que aumenta la eficiencia de las operaciones de lectura. Algunos métodos de la clase son: BufferedReader(Reader in): construye un flujo de caracteres de entrada con buffer a partir de un objeto Reader (InputStreamReader, FileReader, etc.) BufferedReader (Reader in, int sz): crea un flujo de entrada de caracteres con un buffer de tamaño sz. int read(): lee un carácter. int read(char[] buf, int off, int n): lee n caracteres que almacena en el vector buf desde la posición off. Devuelve el núm. de caracteres leído o -1 si se llega al final del flujo. String readline(): lee una línea hasta que encuentra el carácter terminador de línea (fin de línea \n, retorno de carro \r, o \r\n ). boolean ready(): indica si el buffer está listo o no (p.e. si está vacío) int skip(int n): salta n caracteres del buffer. La clase PrintWriter escribe texto formateado en un flujo de salida de caracteres. Los métodos de esta clase no generan excepciones. Utiliza el terminador de línea propio del sistema operativo. Algunos métodos de PrintWriter son: PrintWriter(Writer out): construye un flujo de caracteres de salida a partir de un objeto Writer (OutputStreamWriter, FileWriter, etc.)
print(tipo valor): escribe el valor pasado como parámetro. El método está sobrecargado: tipo puede ser cualquier tipo básico, objeto o cadena. println(tipo valor): igual que print, pero añade un terminador de línea. println(): escribe un terminador de línea. flush(): vacía el flujo de caracteres. boolean checkerror(): comprueba si se ha producido un error. El ejemplo siguiente procesa el fichero entrada.txt línea a línea. El método readline() devuelve null cuando alcanza el final del archivo. import java.io.filereader; import java.io.filewriter; import java.io.ioexception; import java.io.bufferedreader; import java.io.printwriter public class CopiarLineas { public static void main(string[] args) throws IOException{ BufferedReader entrada=null; PrintWriter salida=null; entrada= new BufferedReader(new FileReader("entrada.txt")); salida= new PrintWriter(new FileWriter("salida_lin.txt")); String l; while ((l=entrada.readline())!=null){ salida.println(l); catch(ioexception e) { finally{ if (entrada!=null){ entrada.close(); if (salida!=null){ salida.close(); Cada operación de E/S llevada a cabo por una clase que no utiliza buffer supone un acceso al dispositivo externo (disco, red, etc.). Las clases que utilizan un buffer de memoria pueden realizar las operaciones de lectura y escritura más eficientemente: Las operaciones de lectura acceden al dispositivo externo cuando el buffer de entrada está vacío. Las operaciones de escritura cuando el buffer de salida está lleno. BufferedReader y PrintWriter manejan flujos de caracteres con buffer. BufferedInputStream y BufferedOutputStream manejan flujos de bytes con buffer. Para vaciar el buffer de salida se utiliza la operación flush(). Algunos métodos realizan el vaciado del buffer cada vez que son invocados, p.e. el método println() de PrintWriter.
3.- Utilidades para E/S de cadenas formateadas La clase java.util.scanner permite divide la cadena de entrada en tokens separados por blancos (espacio en blanco, tabulador, terminadores de línea, ) o por el delimitador que especifique el programador. Un objeto de la clase Scanner se construye sobre un buffer de caracteres (BufferedReader). Puede procesar cada token como una cadena, pero también puede transformar el token en un tipo primitivo de Java. Los métodos Scanner(BufferedReader in): construye un objeto Scanner. hasnext(): devuelve cierto si quedan tokens en la cadena. next(): devuelve el siguiente token (String) hasnextdouble(), hasnextint(), : devuelven true si el siguiente token es del tipo esperado. nextdouble(), nextint(), : devuelven el siguiente token traducido al tipo indicado. usedelimiter(string s): modifica mediante una exp. regular el conjunto de delimitadores. uselocale(locale l): modifica el formato numérico local. A continuación se ilustra con dos ejemplo el funcionamiento de Scanner. En el primero se procesa cada token del fichero como una cadena, mostrando en pantalla cada token en una línea. El segundo suma todos los números reales que se encuentran en el fichero descartando aquellos tokens que no lo son. Para ello tiene en cuenta el formato numérico local (éste puede cambiarse con el método uselocale(), por ejemplo con s.uselocale(locale.us) se utilizaría el formato numérico US). import java.io.bufferedreader; import java.io.filereader; import java.util.scanner; public class EscaneaLínea { public static void main(string[] args) { Scanner s=null; s=new Scanner(new BufferedReader( new FileReader("entrada.txt"))); while (s.hasnext()){ System.out.println(s.next()); catch(ioexception e) { finally{ if (s!=null){ s.close();
import java.io.bufferedreader; import java.io.filereader; import java.util.scanner; public class EscaneaNumeros { public static void main(string[] args) { Scanner s=null; double suma=0, n; s=new Scanner(new BufferedReader( new FileReader("numeros.txt"))); while (s.hasnext()){ if (s.hasnextdouble()){ n=s.nextdouble(); suma+=n; System.out.println("double: " + n); else { System.out.println(s.next()); catch(ioexception e) { finally{ if (s!=null){ s.close(); System.out.println("Total= " + suma); Las clases PrintWriter (flujo de caracteres) y PrintStream (flujo de bytes) pueden escribir cadenas con formato utilizando el método format(). Debe indicarse una cadena de formato y una lista de argumentos. Por ejemplo: System.out.format( La raíz cuadrada de %d es %f. %n, 5, Math.sqrt(5)); Algunos tipos de especificadores de formato son: %d enteros %f reales %s cadenas %n terminador de línea (independiente de la plataforma) Los especificadotes de formato admiten elementos opcionales que de izquierda a derecha son: Índice del argumento con el que empareja el especificador de formato. Se utiliza en el caso de tener varios especificadores para un mismo argumento. Se utiliza en índice en la cadena de argumentos, empezando en 0, o el símbolo < que indica que se empareje el especificador con el argumento utilizado por el especificador previo. Flags: o +: número con signo o Carácter de relleno o -: alinea a la derecha o,: formato de número con separadores decimales locales. Anchura mínima, por defecto se alinea a la izquierda. Precisión: para reales es la precisión matemática, para cadenas es la anchura máxima. Se trunca por la derecha.
Por ejemplo, la siguiente instrucción imprime el número real PI dos veces. El segundo especificador indica que el argumento es el primero de la lista (1$), se escribirá con signo (+), carácter de relleno el 0, tamaño 20, y precisión 10: System.out.format ( %f, %1$+020.10f, Math.PI) La salida resultante sería: 3,141593, +0000000003,1415926536 4.- Flujos de E/S estándar Java soporta tres flujos estándar, que están ya definidos y que no necesitan ser abiertos: System.in Objeto de la clase InputStream. Representa el flujo de entrada estándar (teclado). El método System.in.read() lee el siguiente byte. System.out: Objeto de la clase PrintStream. Representa el flujo de salida estándar (pantalla). Los métodos sobrecargados System.out.print() y System.out.println() escriben cadenas de caracteres. System.err: Objeto de la clase PrintStream. Por tanto, tiene los mismos métodos que System.out. Representa el flujo de salida de error. Para leer una cadena desde la entrada estándar se define un flujo de caracteres (BufferedReader) sobre System.in, y se utiliza el método readline() para leer los caracteres introducidos por teclado: import java.io.bufferedreader; import java.io.inputstreamreader; public class LeerCadena { public static void main(string[] args) { BufferedReader in= new BufferedReader(new InputStreamReader(System.in)); String s=""; System.out.println("Escriba su nombre: "); try{ s=in.readline(); catch(exception E){ s = ""; System.out.println("Su nombre es: " + s); Si queremos leer un valor correspondiente a un tipo primitivo, hay que leer una cadena y transformarla al tipo deseado. Por ejemplo, para leer un entero de la entrada estándar, se transforma la cadena leída a entero con el método Integer.parseInt().
En caso de que la cadena no se corresponda con un valor entero se lanzará una excepción de formato (NumberFormatException). import java.io.bufferedreader; import java.io.inputstreamreader; public class LeerEntero { public static void main(string[] args) { BufferedReader in= new BufferedReader(new InputStreamReader(System.in)); String s=""; int edad=0; System.out.println("Escriba su edad: "); try{ edad=integer.parseint(in.readline().trim()); catch(numberformatexception e){ System.out.println("No es un entero."); catch (IOException e){ System.out.println("Error."); System.out.println("Su edad es: " + edad); 5.- Flujos de datos Los flujos de datos soportan la E/S binaria de valores de tipos primitivos (boolean, char, byte, short, int, long, float, double). La clase java.io.datainputstream permite la lectura de tipos primitivos que hayan sido previamente escritos con java.io.dataoutputstream. Algunos métodos de DataInputStream son: DataInputStream(InputStream in): construye un flujo de datos de entrada sobre un InputStream. boolean readboolean(): false si es 0, true en otro caso. byte readbyte(), char readchar(), String readutf(), double readdouble(), float readfloat() int readint(), long readlong(), short readshort() int skipbytes(int n) Los métodos de DataOutputStream son: DataOutputStream(OutputStream out): construye un flujo de datos de salida sobre un OutputStream. void writeboolean(boolean v). void writebyte(int v), void writebytes(string s)
void writechar(int c), void writechars(string s), writeutf(string s), void writedouble(int v), float writefloat(int v) void writeint(int v), void writelong(int v), void writeshort(int v) int size(): cantidad de bytes escritos en el buffer. La condición de fin de fichero se detecta con la interrupción EOFException. El programador debe preocuparse de que la lectura de los datos se realice en el mismo orden en el que estos se escribieron. A continuación se ilustra con un ejemplo que guarda en un fichero el contenido de dos vectores (uno de nombres y otro de edades), y después lee el contenido del fichero. import java.io.datainputstream; import java.io.dataoutputstream; import java.io.eofexception; import java.io.fileinputstream; import java.io.filenotfoundexception; import java.io.fileoutputstream; import java.io.ioexception; public class LeerYEscribirDatos { static void escribirfichero(string nombrefich, String nomb[], int ed[]) throws IOException { DataOutputStream salida = null; try{ salida = new DataOutputStream( new FileOutputStream(nombreFich)); for (int i=0;i<nomb.length;i++){ salida.writeutf(nomb[i]+'\n'); salida.writeint(ed[i]); salida.close(); catch(filenotfoundexception e){ System.out.println("No se puede crear el fichero"); System.exit(-1); catch (IOException e){ System.exit(-1); finally { if (salida!=null) salida.close(); static void leerfichero(string nombrefich) throws IOException{ DataInputStream entrada = null; try{ entrada = new DataInputStream(new FileInputStream(nombreFich)); while(true){ System.out.println("Nombre: " + entrada.readutf() + "Edad: " + entrada.readint());
catch (EOFException e){ System.out.println("Fin de archivo."); catch(filenotfoundexception e){ System.out.println("No se puede abrir el fichero"); System.exit(-1); catch (IOException e){ System.exit(-1); finally{ if (entrada!=null) entrada.close(); public static void main(string[] args) throws IOException{ String nombres[] ={"Pepe", "Ana","Laura", "Toni"; int edades[] ={21,23, 22, 21; escribirfichero("datos",nombres,edades); leerfichero("datos"); 6.- Flujos de objetos: Serialización Los flujos de objetos permiten hacer los objetos persistentes, es decir, almacenar objetos en archivos, para poder recuperarlos en otro momento. Las clases que manejan la entrada y salida de objetos son java.io.objectoutputstream y java.io.objectoutputstream, respectivamente. Para poder hacer persistentes los objetos de una clase, en la declaración de la misma debe indicarse que implementa la interfaz java.io.serializable. El flujo de objetos de salida, ObjectOutputStream, se define sobre FileOutputStream. Para escribir objetos se utiliza el método writeobject(object obj). El flujo de objetos de entrada, ObjectInputStream, se define sobre FileInputStream. La lectura de objetos debe realizase en el mismo orden en el que se escribieron. Para leer objetos se utiliza el método Object readobject(). Si el objeto leído no es del tipo esperado se lanza la excepción ClassNotFoundException. Cuando se escribe un objeto complejo, por ejemplo una colección que contiene referencias a otros objetos, se guardan todas esas referencias, para poder reconstruir el objeto en una lectura posterior. A continuación se muestra con un ejemplo cómo serializar una colección de objetos. Se utiliza la clase ArrayList para guardar los objetos de la colección. ArrayList ya implementa la interfaz Serializable, pero además los objetos que se guarden en el vector deben ser también serializables. En este caso, hay que modificar la definición de la clase Circulo así : class Circulo implements Serializable {
import java.util.arraylist; import java.io.fileinputstream; import java.io.fileoutputstream; import java.io.ioexception; import java.io.objectinputstream; import java.io.objectoutputstream; import Figuras.Circulo; public class Serializacion { static ArrayList v; static void GuardarVector(){ ObjectOutputStream objout = new ObjectOutputStream ( new FileOutputStream("prueba.dat")); objout.writeobject(v); objout.close(); System.out.println("Archivo guardado."); catch (IOException e) { System.out.println("Error guardando archivo: "); static void LeerVector(){ ObjectInputStream objin = new ObjectInputStream ( new FileInputStream("prueba.dat")); v= (ArrayList) objin.readobject(); objin.close(); System.out.println("Archivo leído."); catch (ClassNotFoundException e) { System.out.println("Error!"); catch (IOException ex) { System.out.println("Error abriendo archivo: "); public static void main(string[] args) { v = new ArrayList(); // ArrayList implementa Serializable for (int i=0;i<10;i++){ Circulo c = new Circulo(1,1,i); //La clase Circulo debe implementar Serializable v.add(c); GuardarVector(); v.clear(); //borra los elementos del array LeerVector(); for (int i=0;i<v.size();i++){ ((Circulo) v.get(i)).dibujar();