Streams de Datos - Flujo de Entrada/Salida

En java todos los datos se escriben y se leen, entran y salen usando Streams. Un stream es un "flujo, corriente" es una ruta de datos similar a el flujo o corriente de agua que transporta un río, solo que trasnportamos datos. Los streams es la manera que java tiene para comunicarse, estos están implementados dentro del paquete "java.io"

Existen de 2 tipos:

• --> De Entrada (InputStream) desde una fuente a un programa java como destino.
• <-- De Salida (OutputStream) nuestro programa es el origen, envia datos a un destino.

El procedimiento para crear y usar streams de datos de entrada o salida es muy similar:

1. Ceamos un archivo "File"
2. Creamos un archivo "File-Stream" de entrada o salida.
3. Crear un Stream lector o escritor.
4. Creamos y asociar un Buffer (filtro) a el Stream lector/escritor.
5. Leemos o escribimos datos desde el filtro con los métodos especificos( read() write() ).
6. Cerramos el buffer

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

Los streams desde luego están muy ligados a las "Exceptions", y tenemos que tratarlas con el bloque try-catch. Contamos con una super-clase IOException para manejar excepciones, y sub-clases como FileNotFoundExpection para cuando intentamos leer o escribir un archivo que no está disponible o no se puede acceder a el, y EOFEception (EOF = End Of File) para cuando se produce el final inesperado de un archivo del que se estaba leyendo o escribiendo.

El tipo más común es el Stream File que son usados para intercambiar bytes generalmente con nuestro disco duro, entre otros dispositivos.

---

InputStream - Flujo de Entrada

En el siguiente ejemplo leeremos un archivo de texto usando dentro de nuestro bloque try-catch la creación de un objeto FileInputStream y le pasamos el nombre y/o la ruta donde se encuentra (en este caso use un parametro archivo que debe existir), luego creamos el objeto de entrada InputStreamReader con el parametro del objeto File, y posteriormente creamos el BufferedReader, el filtro para el objeto de entrada llamado "reader".
Después hay un String que tomará el valor de cada linea que el buffer obtenga con el método "readLine()", y el ciclo while se ejecutará hasta que la obtención de alguna linea sea nulo porque se haya llegado al final del archivo de texto.
Pasamos a cerrar el buffer para liberar espacio en memoria con el método "close()" y capturamos las excepciones que puedan surgir como que el archivo no se encontrado (FileNotFoundException) y muestra ese error por pantalla junto con un mensaje o algún otro error que se pueda dar (IOException) y simplemente hara lo mismo.

1. import java.io.File;
2. import java.io.FileInputStream;
3. import java.io.InputStreamReader;
4. import java.io.BufferedReader;
5. import java.io.IOException;
6. import java.io.FileNotFoundException;
7.  
8. public class EscribirArchivo {
9.     public static void main(String[] args) {
10.         try {
11.             File archivo = new File("c:\\archivoPrueba.txt");
12.             FileInputStream inputStream = new FileInputStream(archivo);
13.             InputStreamReader reader = new InputStreamReader(inputStream);
14.             BufferedReader bufferedReader = new BufferedReader(reader);
15.            
16.             String linea;
17.             while ((linea = bufferedReader.readLine()) != null) {
18.                 System.out.println(linea);
19.             }
20.             bufferedReader.close();
21.            
22.         } catch (FileNotFoundException e) {
23.             System.out.println("Error el archivo no existe" + e.getStackTrace());
24.         } catch (IOException e) {
25.             System.out.println("No es posible leer el archivo" + e.getStackTrace());
26.         }
27.     }
28. }

Para que el programa funcione perfectamente hay que tener un archivo previamente con el nombre indicado en la dirección indicada de lo contrario actuará el catch de FileNotFound.

---

OutputStream - Flujo de Salida

Para escribir un archivo el procedimiento es igual salvo que habrá que tener cuidado de que el archivo no sea sobreescrito! Para lo cual existen 2 constructores de FileOutputStream:

• FileOutputStream(string) donde el String es el nombre de nuestro archivo File.
• FileOutputStream(String, boolean) idem anterior y el boolean verdadero continua escribiendo desde el final, falso sobreescribe el archivo perdiendo el contenido anterior.

1. import java.io.File;
2. import java.io.FileOutputStream;
3. import java.io.OutputStreamWriter;
4. import java.io.BufferedWriter;
5. import java.io.IOException;
6. import java.io.FileNotFoundException;
7.  
8. public class EscribeArchivo {
9.     public static void main(String[] args) {
10.         try {
11.             File archivo = new File("c:\\archivoPrueba.txt");
12.             FileOutputStream outputStream = new FileOutputStream(archivo, true);
13.             OutputStreamWriter writer = new OutputStreamWriter(outputStream);
14.             BufferedWriter bufferedWriter = new BufferedWriter(writer);
15.            
16.             bufferedWriter.write("NUEVO CONTENIDO DEL ARCHIVO");
17.             bufferedWriter.append("CONTINUA COLOCANDO UNA NUEVA LINEA");
18.             bufferedWriter.flush();
19.             bufferedWriter.close();
20.         } catch (FileNotFoundException e) {
21.             e.printStackTrace();
22.         } catch (IOException e) {
23.             e.printStackTrace();
24.         }  
25.     }
26. }

El método write(String) pertenece a la clase padre "Write" de bufferedWriter el cual escribe el string del parametro.
flush() vacia el contenido del Stream.
Close() cierre el flujo de entrada vaciándolo previamente por lo cual el método flush no es muy necesario en este ejemplo.
append(CharSequence csq) es otro método heredado de "Write" el cual escribe una secuencia de caracteres.
BufferedWriter ademas cuenta con el método newLine() que escribe un separador de línea. no es necesariamente un solo salto de línea ('\ n') y varios métodos write() con diferentes parámetros.