Prog. Ficheros

Entrada/Salida de información: Flujos

• Este punto sólo sirve de apoyo y para realizar ejercicios, a los apuntes de Jose Luis Comesaña.

Otros apuntes.

• En java, para entender el sistema de entrada/salida de información (es decir, como leer o escribir información desde o hacia cualquier dispositivo), es necesario entender el concepto de flujo.

Podemos definir flujo como una 'abstracción' que proporciona Java y que identifica a una secuencia de bytes desde un dispositivo de entrada hacia un dispositivo de salida.

A través de dichos flujos vamos a poder realizar lecturas y escrituras sobre diferentes dispositivos sin que el programador necesita saber nada acerca de ellos, ya que será el núcleo de Java el que se entenderá con el S.O. para realizar las operaciones correspondientes.

• En Java, dichos flujos están identificados por una jerarquía de clases que se encuentran en el paquete java.io:

Imagen obtenida de los apuntes de Jose Luis Comesaña

• Podemos dividir estas clases en dos grupos, en función del tipo de dato que van a leer:

• Clases que leen o escriben flujos de caracteres de 16 bits unicode. Estas son las clases abstractas Reader y Writer y todas las que deriven de ellas.
• Clases que leen o escriben flujo de bytes de 8 bits. Estas son las clases abstractas InputStream y OutputStream y todas las que deriven de ellas.

• Otra división de los flujos es de la dividirlos según vayamos a leer o a escribir datos:

• Salida (...output...)
• Entrada (...input...)

• Quizás podemos entender más claramente el concepto de flujo si nos fijamos cuando escribimos por teclado y desde nuestro programa guardamos dicha información o cuando mandamos escribir por consola un texto determinado.

En Java, las letras (información) que estamos tecleando llegan a nuestro programa a través de un 'flujo' de entrada, denominado 'flujo de entrada estándar' y posteriormente enviamos información a la consola a través de un 'flujo de salida estándar'. En caso de encontrar algún error también enviará un mensaje a la consola (como la salida) por medio de otro flujo de datos.

Estos flujos en Java los tenemos implementados en los objetos System.in, System.out y System.err.

Si observáis la definición de dichos objetos (son final y de clase) veréis que pertenecen a alguna de las clases de la jerarquía anterior.

• Bufferes (información obtenida de estos apuntes).

En la jerarquía anterior vemos que hay ciertas clases que implementan un buffer (BufferedReader, BufferedInputStream,...).

Recordar que un buffer es una zona de almacenamiento, que se utiliza de 'puente' entre un dispositivo de entrada y otro de salida, para aumentar la velocidad en las operaciones de lectura y escritura así como el rendimiento.

Si usamos sólo FileInputStream, FileOuputStream, FileReader o FileWriter, cada vez que hagamos una lectura o escritura, se hará físicamente en el disco duro.

Si escribimos o leemos pocos caracteres cada vez, el proceso se hace costoso y lento, con muchos accesos a disco duro.

Los BufferedReader, BufferedInputStream, BufferedWriter y BufferedOutputStream añaden un buffer intermedio.

Cuando leamos o escribamos, esta clase controlará los accesos a disco.

• Si vamos escribiendo, se guardarán los datos hasta que tenga bastantes datos como para hacer la escritura eficiente.
• Si queremos leer, la clase leerá muchos datos de golpe, aunque sólo nos dé los que hayamos pedido. En las siguientes lecturas nos dará lo que tiene almacenado, hasta que necesite leer otra vez.

Esta forma de trabajar hace los accesos a disco más eficientes y el programa correrá más rápido. La diferencia se notará más cuanto mayor sea el fichero que queremos leer o escribir.

• Veamos un sencillo ejemplo de cómo leer un archivo de texto.

Para ello, debemos hacer uso de la clase FileReader, que como comentamos antes, es una clase que sirve para leer caracteres.

Incorpora por tanto el método read.

Para leer un archivo siempre vamos a tener que realizar las siguientes operaciones:

• Abrir el archivo para iniciar la lectura.
• Leer del archivo hasta llegar al final del mismo.
• Cerrar el archivo.

En nuestro caso, debemos crear un objeto de la clase FileReader, en el que podemos observar como el constructor está sobrecargado, y en uno de ellos debemos enviar un String con la ruta y nombre del fichero a abrir.

• Al llamar al constructor ya nos abre el fichero para iniciar la lectura.
• Después debemos leer del fichero carácter a carácter utilizando el método read() hasta el final del mismo. Esto lo sabemos ya que el método read() devuelve el valor -1 cuando llega al final.
• Finalmente debemos cerrar el fichero con el método close().

• Puede suceder que tengamos excepciones debido a que el fichero no exista o no se pueda leer o que durante el proceso de lectura dejemos de tener acceso al mismo (FileNotFoundException y IOException).

 1         FileReader f = null;
 2         int c;
 3 
 4         try {
 5             f = new FileReader("/tmp/prueba.txt");
 6             while((c = f.read())!=-1) {
 7                 System.out.print((char)c);
 8             }
 9             
10             
11         } catch (FileNotFoundException ex) {
12             System.err.println("Fichero no encontrado");
13         } catch (IOException ex) {
14             System.err.println("Error al leer el contenido del fichero");
15         }
16         finally {
17             try {
18                 if (f != null)
19                     f.close();
20             } catch (IOException ex) {
21                 System.err.println("Error al leer cerrar fichero");
22             }
23         }

• Antes de la versión Java 7 era necesario cerrar un fichero de forma explícita (es decir, teníamos que llamar al método close()).

La llamada a dicho método se debe realizar en la sección finally.

• Indicar que a partir del JDK 7 podemos hacer uso de un nuevo recurso denominado try-with-resources.

Es una forma 'especial' de utilizar el try de tal forma que el cierre del flujo ya se realiza automaticamente tanto si todo se ejecuta de forma correcto como si hay una excepción y ya no tenemos que realizar una llamada a close(). Esto se puede hacer con cualquier objeto que implemente la interface AutoClosable.

 1         int c;
 2 
 3         try (FileReader f = new FileReader("/tmp/prueba.txt"){
 4             while((c = f.read())!=-1) {
 5                 System.out.print((char)c);
 6             }
 7             
 8             
 9         } catch (FileNotFoundException ex) {
10             System.err.println("Fichero no encontrado");
11         } catch (IOException ex) {
12             System.err.println("Error al leer el contenido del fichero");
13         }

• Indicar que la definición del objeto debe ir dentro del try y entre paréntesis (en el ejemplo FileReader f...).

• Si tenemos varios recursos, es mejor instanciarlos separadamente y separarlos con punto y coma, como por ejemplo:

1     String filePath = "/tmp/fichero.txt";
2     int bsize = 1024; /* tamaño del buffer */
3 
4     try (FileReader file = new FileReader(filePath);
5          BufferedReader br = new BufferedReader(file, bsize))
6     {
7         return read(br);
8     }

• Necesario cerrar el fichero.

Llamar al método close del 'flujo' que estemos utilizando siempre es necesario por los siguientes motivos:

• Si hemos abierto el fichero para leer, estamos haciendo uso de un recurso que está ocupando un espacio de memoria y que no quedará liberado hasta que se llame al método close().
• Si hemos abierto el fichero para escritura, cuando llamamos al método close() no solamente liberamos la memoria como pasaba en la lectura, sino que además se suelen enviar los datos modificados que quedan guardados en un buffer (espacio para guardar temporalmente información y que cuando está lleno se envío a disco para su escritura definitiva, permitiendo aumentar el rendimiento).

Veamos un ejemplo de escritura de una cadena de texto a un archivo:

 1         String cadena = "Esto es una cadena";
 2         FileWriter fw=null;
 3         try {
 4             fw = new FileWriter("/tmp/salida.txt");
 5             fw.write(cadena);
 6         } catch (IOException ex) {
 7             System.out.printf("Error:%s",ex.getMessage());
 8         }
 9         finally{
10             if (fw!=null){
11                 try {
12                     fw.close();
13                 } catch (IOException ex) {
14                     System.out.printf("Error:%s",ex.getMessage());
15                 }
16             }
17         }

Si quitamos las líneas de la 9 a la 16, podemos comprobar como la cadena de texto no se llega a escribir a texto.

Clases para lectura de caracteres

• Veamos ahora todas las clases de lectura de caracteres.

Como norma general debemos de tener en cuenta que los Reader van a permitir leer caracteres en base a alguna codificación y nos van a suministrar caracteres, mientras que los Stream van a leer bytes y nos suministran bytes.

• En casi todas las clases de lectura de datos vamos a encontrar los siguientes métodos:

• read(): Lee un solo byte.
• read(byte[] b): Lee de una sola vez los bytes indicados por el tamaño del array y devuelve el número de bytes leídos.
• read(byte[] b,int offset, int length): Lee de una sola vez el número de bytes indicado por length y los guarda en el array pero a partir de la posición indicada por offset. Hay que tener cuidado que la suma de length y offset no sobrepase el tamaño del array.

FileReader

• Deriva de InputStreamReader.

• Permite leer un fichero carácter a carácter o en bloque haciendo uso de un array.

• Un ejemplo de uso:

 1         int leido = 0;  // Nos devuelve el carácter leído
 2         String texto = ""; // Texto del fichero
 3         try (FileReader fr = new FileReader("/tmp/prueba.txt")){    // Abrimos con recursos, se cierra automaticamente
 4 
 5             while (leido != -1){
 6                 leido = fr.read(); 
 7                 if (leido != -1) {
 8                     texto += (char)leido;
 9                 }
10             }
11         
12         } catch (FileNotFoundException ex) {
13            System.err.printf("%nError:%s",ex.getMessage());
14         } catch (IOException ex) {
15            System.err.printf("%nError:%s",ex.getMessage());
16         }
17         System.out.print(texto);

• Línea 6: Al hacer un read() el método va a devolver el carácter leído o el valor -1 si llegó al final.
• Línea 8: Necesitamos convertir el número a un char.

• Veamos un ejemplo de lectura haciendo uso de un array:

 1         char[] buf = new char[5];   
 2         int leidos = 0;  // Nos va a servir saber cuantos caracteres fueron leídos del fichero
 3         try (FileReader fr = new FileReader("/tmp/prueba.txt")){    // Abrimos con recursos, se cierra automáticamente
 4 
 5             while (leidos != -1){
 6                 leidos = fr.read(buf);  // Me indica cuantos caracteres se han leído 
 7                 System.out.println(buf);
 8             }
 9         
10         } catch (FileNotFoundException ex) {
11            System.err.printf("%nError:%s",ex.getMessage());
12         } catch (IOException ex) {
13            System.err.printf("%nError:%s",ex.getMessage());
14         }

En este caso el resultado será bloques de 5 caracteres. Usamos println para que en la salida se pueda apreciar como vamos leyendo de 5 en 5.

BufferedReader

• Permite leer texto sobre un flujo de texto pero haciendo uso de un buffer intermedio haciendo que el rendimiento aumente.

• Normalmente las clases que implementan un buffer van a trabajar sobre otro flujo de entrada/salida, es como si envolvieran el flujo de entrada/salida original y añadieran una capa nueva con las funcionalidades del buffer.

• En nuestro caso, vamos a hacer que el buffer trabaje sobre un flujo FileReader como el visto en el caso anterior.

• Tendremos los siguientes métodos (a mayores de los visto en el FileReader):

• readLine(): Devuelve una línea entera del fichero.
• mark(): Permite establecer una marca en el fichero para en el momento que queramos, volver a situarnos en la posición marcada.
• reset(): Nos volvemos a posicionar en una posición marcada previamente.

• Veamos un ejemplo de su uso:

 1         String cadena = "";
 2         
 3         try (FileReader fr = new FileReader("/tmp/prueba.txt");
 4             BufferedReader bfr = new BufferedReader(fr)){
 5             
 6             while((cadena = bfr.readLine()) != null){
 7                 System.out.println(cadena);
 8             }
 9             
10             
11         } catch (FileNotFoundException ex) {
12            System.err.printf("%nError:%s",ex.getMessage());
13         } catch (IOException ex) {
14            System.err.printf("%nError:%s",ex.getMessage());
15         }

• Líneas 3 y 4: Para utilizar el BufferedReader necesitamos un flujo y creamos previamente un FileReader
• Línea 6: Llamamos al métod readLine() para leer una línea entera del fichero de texto.
• Línea 7: Fijarse que para mostrar el contenido necesitamos un 'println' ya que la cadena no guarda el salto de línea.

• Si quisiéramos guardar todo el contenido en una variable String tendríamos que poner algo parecido a esto (más adelante en este curso veremos el uso de la clase StringBuielder):

1             while((cadena = bfr.readLine()) != null){
2                 cadena += '\n';  // Salto de línea
3             }

Clase Scanner

• Esta clase ya la hemos utilizado durante el curso como forma de obtener información a través del teclado.

• No es una clase que represente un flujo sino que hace uso de las clases comentadas en el gráfico inicial.

• La ponemos en este punto porque vamos a ver como podemos utilizar otros flujos de entrada que no sea el teclado y cómo nos va a resultar muy útil para analizar archivos de texto y des componerlos en partes...

• Como primer ejemplo vamos a ver como leer un fichero línea a línea haciendo uso de la clase Scanner.

Haremos uso del método hasNextLine() para saber cuando se ha acabado de leer el fichero (podéis ver en el enlace de la clase que existen múltiples hasXXXXX disponibles).

 1         String salida="";
 2         
 3         try (FileReader fr = new FileReader("/tmp/prueba.txt");
 4             Scanner sc = new Scanner(fr)){
 5             
 6             while(sc.hasNextLine()){
 7                 salida +=sc.nextLine() + '\n'; 
 8             }
 9             
10             System.out.println(salida);
11             
12             
13         } catch (IOException ex) {
14            System.err.printf("%nError:%s",ex.getMessage());
15         }

• En este segundo ejemplo vamos a ver como analizar una línea de las leídas en el paso anterior.

Supongamos que disponemos de un archivo '.csv' (archivo de texto separado cada campo por un símbolo y cada línea por un salto de línea) con los siguientes datos:

Angel:23:981111111

Pedro:45:234232314

En este caso necesitamos enviar al Scanner la línea leída para que la pueda analizar (va en el constructor).

También haremos uso del método useDelimiter, para indicar cual es el carácter que separa cada uno de los campos de cada línea.

 1         String linea="";
 2         
 3         try (FileReader fr = new FileReader("/tmp/datos.txt");
 4             Scanner sc = new Scanner(fr)){
 5             
 6             while(sc.hasNextLine()){
 7                 linea = sc.nextLine();
 8                 Scanner scLinea = new Scanner(linea);
 9                 scLinea.useDelimiter(":");  // Indicamos cual es el caracter utilizado para saparar los campos
10                 if (scLinea.hasNext()){ // Preguntamos por si no viene bien formado o sin datos
11                     String nombre = scLinea.next();
12                     int edad = scLinea.nextInt();
13                     String telefono = scLinea.next();
14                     
15                     System.out.printf("%nNombre:%s,edad:%d,telefeno:%s",nombre,edad,telefono);
16                 }
17             }
18             
19         } catch (IOException ex) {
20            System.err.printf("%nError:%s",ex.getMessage());
21         }

• Esto mismo lo podemos realizar haciendo uso del método split de Java:

 1         String linea="";
 2         
 3         try (FileReader fr = new FileReader("/tmp/datos.txt");
 4             Scanner sc = new Scanner(fr)){
 5             
 6             while(sc.hasNextLine()){
 7                 linea = sc.nextLine();
 8                 String[] partes = linea.split(":");
 9                 if (partes.length == 3){
10                     System.out.printf("%nNombre:%s,edad:%s,telefeno:%s",partes[0],partes[1],partes[2]);
11                 }
12             }
13             
14             
15         } catch (IOException ex) {
16            System.err.printf("%nError:%s",ex.getMessage());
17         }

• Línea 8: Descomponemos la línea en partes (obteniendo un array de cadena)
• Línea 10: Fijarse como edad tiene que mostrarse con el %s ya que split devuelve todo en cadena. Sino daría un error de conversión.

Si quisiéramos convertir lo devuelto por split a un número deberemos tener cuidado y controlar la excepción java.lang.NumberFormatException de la forma:

1 try {
2    int edad = Integer.parseInt(partes[1]);
3 }
4 catch(java.lang.NumberFormatException ex){
5    System.err.println("Línea mal formada: ");
6 }

Comparativa entre utilizar Scanner o String.split.

CharacterArrayReader

• Permite leer caracteres sobre un flujo de caracteres.

Ejemplo de uso.

¿ Y para qué puede servir esto ? Pues en el caso de que necesitéis pasar a un componente un Reader.

InputStreamReader

• Permite leer un flujo de bytes convirtiéndolo a un flujo de caracteres, pudiendo especificar el juego de caracteres utilizado en la conversión.

• Si observáis el constructor, necesitamos un InputStream por lo que tenemos que hacer uso de las clases que derivan de InputStream, por ejemplo, FileInputStream.

 1         try (FileInputStream fis = new FileInputStream("/tmp/prueba.txt");
 2              InputStreamReader isr = new InputStreamReader(fis,"ISO-8859-1")){
 3             char c=0;
 4             String cadena="";
 5             do {
 6                 c = (char) isr.read();
 7                 cadena +=c;
 8             }while (c!='\n');
 9             System.out.printf("%n%s",cadena);
10             
11         } catch (IOException ex) {
12             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
13         }
14 ::

• En el ejemplo se está abriendo un archivo con el formato de caracteres ISO-8859-1.

• Podríamos poner como InputStream la entrada estándar 'System.in'.

StringReader

• Un flujo de caracteres cuyo origen es un String.

PipedReader

• Permite una comunicación entre una 'tubería' de entrada y otra de salida. En Java se suele utilizar para comunicar dos threads dentro del mismo programa, en el que uno de ellos escribe en una tubería (PipedWriter) y otro lee el contenido de la misma (PipedReader) en forma de caracteres.

Sus equivalentes leyendo y escribiendo bytes son PipedInputStream y PipedOutputStream.

Podéis consultar un ejemplo de uso en este enlace.

PushbackReader

• La clase FilterReader es abstracta y por tanto no se puede instanciar. La clase PushbackReader deriva de ella y es una clase que permite lectura de caracteres y además permite volver a 'meter' esos caracteres en el stream para volver a leerlos. Esto puede ser necesario si necesitamos leer un contenido de un fichero para determinar que tipo de contenido trae y después tratarlo en función de ese tipo de contenido. Para ello debemos de leer (método read) caracteres y después tendremos que volver a leerlos por lo que tendremos que llamar al método unread (buscar por unread en el enlace).

LineNumberReader

• Lee caracteres y permite 'saltar' a una línea determinada llamando al método setLineNumber.

StreamTokenizer

• Permite dividir un flujo de entrada en 'tokens' pudiendo reconocer palabras, números, identificadores, ciertos estilos de comentarios,...

Según la documentación será eliminada en el futuro, sólo se mantiene por compatibilidad y se recomienda hacer uso del método split de la clase String.

File

• La clase File es una representación abstracta (no clase abstracta :) ) de un fichero o un directorio.

• Podéis comprobar en el enlace de la clase la cantidad de métodos útiles que tenemos para el manejo de ficheros y directorios.

Por ejemplo, podemos hacer uso del método exists para determinar si un fichero/directorio existe antes de hacer uso del mismo (hasta ahora hacíamos uso de la excepción FileNotFoundException).

Podemos enviarlo como un flujo de entrada de un FileInputStream, FileOutputStream, FileReader, Scanner...

1         File fichero = new File("/tmp/fichero.txt");
2         if (!fichero.exists()){
3             System.err.println("El fichero no existe...");
4             try {
5                 fichero.createNewFile();
6             } catch (IOException ex) {
7                 System.err.println("El fichero no se puede crear:" + ex.getMessage());
8             }
9         }

Ejercicios propuestos

• Crea una clase de nombre TratamientoFicheros que conste de los siguientes métodos (no necesita instanciarse la clase para poder llamar a dichos métodos):

• leerFichero(String nombre): devolverá un string con las líneas pares del fichero leído. Se debe comprobar que el fichero exista antes de leerlo.

Clases para lectura de bytes

• Veamos ahora todas las clases de lectura de bytes.

Como norma general debemos de tener en cuenta que los Reader van a permitir leer caracteres en base a alguna codificación y nos van a suministrar caracteres, mientras que los Stream van a leer bytes que tendremos que convertir a caracteres.

FileInputStream

• Obtiene bytes de un fichero del sistema operativo.

• Si nos fijamos en el constructor, podemos utilizar una cadena para indicar el nombre del fichero a abrir, un descriptor o un objeto de la clase File.

• Si utilizamos una cadena debemos de controlar la excepción de que el fichero no exista (FileNotFoundException).

Veremos después el uso de la clase File.

• En casi todas las clases de lectura de datos vamos a encontrar los siguientes métodos:

• read(): Lee un solo byte.
• read(byte[] b): Lee de una sola vez los bytes indicados por el tamaño del array y devuelve el número de bytes leídos.
• read(byte[] b,int offset, int length): Lee de una sola vez el número de bytes indicado por length y los guarda en el array pero a partir de la posición indicada por offset. Hay que tener cuidado que la suma de length y offset no sobrepase el tamaño del array.

• Supongamos que tenemos creado un fichero /tmp/prueba.dat formado por números y queremos leerlo utilizando esta clase, dando como resultado la suma de todos ellos.

 1         int dato = 0,suma = 0;
 2         try (FileInputStream fis = new FileInputStream("/tmp/prueba.txt")){
 3             do {
 4                 dato = fis.read();
 5                 if (dato != -1){
 6                     suma += dato;
 7                 }
 8             }while(dato != -1);
 9             System.out.printf("La suma de todos los números es:%d",suma);
10 
11         } catch (FileNotFoundException ex) {
12             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
13         } catch (IOException ex) {
14             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
15         }

Debemos de fijarnos que esta clase va a leer bytes y debemos ser nosotros los que convirtamos al tipo de dato correcto.

• Veamos ahora otro ejemplo utilizando un array:

 1         byte[] buf = new byte[5];
 2         int numBytesLeidos = 0, suma = 0;
 3         try (FileInputStream fis = new FileInputStream("/tmp/prueba.dat")){
 4             do {
 5                 numBytesLeidos = fis.read(buf);
 6                 if (dato != -1){
 7                     for(int cont=0;cont<numBytesLeidos;cont++){
 8                        suma += buf[cont];
 9                     }
10                 }
11             }while(dato != -1);
12             System.out.printf("La suma de todos los números es:%d",suma);
13 
14         } catch (FileNotFoundException ex) {
15             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
16         } catch (IOException ex) {
17             Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
18         }

Entrada/Salida estándar

• Utilizando los conceptos vistos de salida y entrada estándar podemos hacer una redirección de la salida estándar (podríamos hacerlo con la salida de errores o la entrada estándar) a un fichero.

Para ello debemos hacer uso del método setOut() de la clase System.

 1         FileReader f = null;
 2         int c;
 3         PrintStream pStreamSalida=null;
 4         
 5         try {
 6             pStreamSalida = new PrintStream("/tmp/salida.txt");
 7             System.setOut(pStreamSalida);
 8             f = new FileReader("/tmp/prueba.txt");
 9             while((c = f.read())!=-1) {
10                 System.out.print((char)c);
11             }
12             
13             
14         } catch (FileNotFoundException ex) {
15             System.err.println("Fichero no encontrado");
16         } catch (IOException ex) {
17             System.err.println("Error al leer el contenido del fichero");
18         }
19         finally {
20             try {
21                 if (f != null)
22                     f.close();
23             } catch (IOException ex) {
24                 System.err.println("Error al leer cerrar fichero");
25             }
26         }

Cualquier System.out que hagamos después de redirigir la salida estándar será enviado al fichero "/tmp/salida.txt"

-- Ángel D. Fernández González -- (2017).