FLUJOS DE ENTRADA Y SALIDA

Los programas nos entregan informacin producto de las funciones que se le han definido,
esta debe provenir de alguna fuente de datos (discos, CD-RW, memoria) y seguramente
necesitaremos enviar esta informacin o datos hacia otro lugar para mostrarla o
almacenarla. Estos son los flujos (en ingls stream) de informacin.

"Un flujo es una ruta seguida por los datos de un programa. Un flujo de entrada enva datos
desde una fuente a un programa, y un flujo de salida enva datos desde un programa hacia
un destino".
En JAVA, un flujo es un objeto que sirve de intermediario entre el origen y el destino de los
datos. Esto tiene la ventaja que el programa leer y escribir en el flujo de informacin sin
importar el origen o el destino (la pantalla, un archivo, la memoria, Internet, etc.). Adems,
tampoco va a tener relevancia el tipo de dato que se encuentra en este objeto. Por otro lado,
esto significa un nuevo nivel de abstraccin pues al programa ya no le importa saber nada
acerca del dispositivo del cual vienen o al cual van los datos.
As, para leer informacin el programa tiene que abrir un flujo (objeto), de la misma manera
que tiene que hacerlo para escribirla o enviarla. Para ello JAVA contiene una serie de clases
que son parte del paquete java.io. Un programa que use flujos de entrada/salida (E/S)
deber importar el paquete: import java.io.*.
Existen dos tipos de flujos: los de Entrada, que sirven para leer datos, y los de Salida, que se
usan para guardar datos. En ambos casos, los flujos pueden ser flujos de bytes o flujos de
caracteres.
Los Flujos de Bytes, se utilizan para manejar bytes, enteros u otros tipos simples en el flujo,
con valores que van desde 0 a 255.
Los Flujos de Caracteres, manejan archivos de texto u otras fuentes de texto. Cualquier
clase de datos que comprenda texto debera utilizar este tipo de flujos.
1. Flujos de Entrada
La clase InputStream es la que se encarga de establecer el flujo de bytes de entrada de
informacin. Es una clase abstracta que es superclase de todas las subclases que
representan este flujo. En este sentido, el mtodo ms importante es read(), que son varios
mtodos sobrecargados que leen bytes ya sea individualmente o en conjunto.
Por otro lado, tenemos la superclase Reader, que al igual que la superclase InputStream lee
desde el origen, pero sus subclases leen caracteres, es decir, char en vez de byte.
2. Flujos de Salida
La clase OutputStream es la superclase de todas las clases que representan un flujo que se
encarga de escribir bytes un destino. Su mtodo ms importante es write()
Tambin, existen otra superclase que en vez de escribir o enviar bytes escribe caracteres:
Writer.
3. Flujo E/S Estndar
El paquete java.lang proporciona, por intermedio de la clase System tres flujos que son
abiertos una vez que el programa se carga en memoria para el uso de la salida estndar,
normalmente el monitor:
System.in, que es una subclase de la clase InputStream y que hace referencia a la entrada
estndar del sistema, normalmente el teclado. Se usa para leer datos introducidos por el
usuario.
System.out, que es subclase de PrintStream que a su vez es subclase de OutputStream y
que hace referencia a la salida estndar. Se utiliza para mostrar datos al usuario.
System.err, que es subclase de PrintStream que a su vez es subclase de OutputStream y
que hace referencia a la salida estndar. Se utiliza para mostrar mensajes de error al
usuario.
4. Flujo E/S desde y hacia Archivos
Una gran parte de la vida de una aplicacin en memoria, se dedicar a trabajar con archivos
o archivos, para intercambiar datos entre distintos dispositivos de almacenamiento, que se
utilizan refirindolos con una ruta de directorio y un nombre.
Las operaciones bsicas que se realizan con un archivo son: abrir el archivo, leer datos o
escribirlos y cerrar el archivo.
a. Flujos de Bytes.
Esta es la manera bsica de leer o escribir sobre un archivo. Para leer bytes se debe abrir
un flujo de entrada hacia el origen, y para escribir sobre l se abre un flujo de salida hacia el
destino.
Para crear el flujo de entrada del archivo se usa un objeto de la clase FileInputStream, a
cuyo constructor se le pasa como argumento una cadena que contiene la ruta del archivo y
su nombre, con su extensin, o slo el nombre del archivo si se encuentra en el directorio
actual de trabajo. Por ejemplo:
FileInputStream archivo = new FileInputStream("Ruta\Nombre.ext");
Una vez creado el flujo, se podrn leer bytes desde el flujo usando el mtodo read(), el cual
devuelve un valor entero que contiene la representacin del prximo byte en el flujo y
devuelve -1 cuando llega al final del flujo.
/* Lee los bytes desde un archivo */
import java.io.*;
public class EjemFile {

public static void main(String[] args) {
Scanner s = new Scanner(System.in);

String archivo = "";
int enteroByte = 0;

System.out.print("Ingrese el nombre del archivo: ");
archivo = s.nextLine();

try{
FileInputStream f = new FileInputStream(archivo);

enteroByte = f.read();

while (enteroByte != -1){
System.out.print((char)enteroByte);
enteroByte = f.read();
}

f.close();
}
catch (IOException e){
System.out.println(e);
}
}
}

Este programa lee bytes desde un archivo existente. La ruta y/o nombre del archivo se
ingresa por teclado. Se debe considerar la forma como cada sistema operativo maneja el
acceso a sus directorios; as si se trabaja con sistemas UNIX o Linux se usa la barra
inclinada normal (/) para separar los directorios, en cambio, es sistemas DOS y Windows se
usa la barra invertida (\), pero como representa la secuencia de escape se debe usar as: '\\'.
En este programa, se crea el flujo, se lee el archivo byte a byte y se imprimen hasta el fin del
archivo con el que se est trabajando.
Sin embargo, en este caso, estamos leyendo el archivo byte a byte. Sera una mejor
solucin, traer a memoria una mayor cantidad de informacin para trabajar con ella en vez
de ir leyendo cada vez desde el archivo, mejorando as la velocidad de ejecucin de la
aplicacin. Esto se hace a travs de un buffer, "...un lugar donde se pueden guardar datos
antes de ser utilizados por un programa...".
En el caso del flujo de entrada, el buffer se llena con datos que no se han utilizado an. Y
cuando el programa los requiera los encontrar en el buffer antes de ir a buscarlo a la fuente
origen (archivo fsico). La clase con la que se logra esto es: BufferedInputStream, que crea
un flujo de entrada almacenado en un buffer reservado para un objeto InputStream que se
le pasa como argumento y que, en este caso particular, ser un objeto FileInputStream.
Para leer datos desde la entrada del buffer se usa el mtodo read(), sin argumentos, el cual
devuelve un entero de de valor 0 a 255 que representa el byte ledo. Si llega al final del flujo
y no quedan datos devuelve un -1. Para ejemplificar, tomaremos el mismo ejemplo anterior y
le agregaremos una lnea y modificaremos otra:
...
try{
FileInputStream f = new FileInputStream(archivo);
BufferedInputStream buffer = new BufferedInputStream(f);

enteroByte = buffer.read();
...

En el caso de los flujos de salida, este se crea con la clase FileOutputStream, a la cual se
le pasa como argumento la ruta y el nombre del archivo. Si el archivo ya existe, se borrar
su contenido. En caso de no existir se crear, pero si existe, y se quiere agregar su
contenido al final del archivo existe el constructor FileOutputStream (String rutaArchivo,
[true/false]), que permite esta operacin cuando se pasa true como el argumento booleano.
Es el mtodo write(Entero) el que permite escribir valores enteros y bytes en el flujo. En este
caso, es necesario cerrar expresamente el flujo hacia el archivo mediante el uso del mtodo
close().
Como ejemplo, el siguiente programa toma la entrada por teclado y la enva a un archivo de
texto (datos.txt). Si el archivo no existe, lo crear, y si ya existe lo sobreescribir. La entrada
es por un flujo estndar la cual termina al presionar la tecla Enter (10):
import java.io.*;

public class EjemFileOut {

public static void main(String[] args) {
int letra;

System.out.print("Ingrese un texto: ");

try{
FileOutputStream f = new FileOutputStream("datos.txt");

do{
letra = System.in.read();
f.write(letra);
}while(letra != 10);

f.close();
}
catch (IOException e){
System.out.println(e);
}
}
}

Para hacer lo anterior, pero sin perder el contenido original del archivo si este ya existe, si no
que agregar la final los bytes que se escriben en el flujo, se escribe el programa
exactamente igual, pero se utiliza el constructor que permite agregar los enteros a partir del
final del archivo, para lo cual se reemplaza la siguiente lnea:
FileOutputStream f = new FileOutputStream("datos.txt", true);
Tambin se puede establecer un buffer para los flujos de salida a travs de la clase
BufferOutputStream, donde se pasa como argumento el objeto del flujo de salida
establecido para el archivo a escribir. Se usa el mtodo write(entero), para escribir bytes en
el archivo, que representen valores enteros de 0 a 255. Los datos se escriben en el flujo y
slo se escriben en el archivo cuando el buffer se llena o cuando se llama expresamente al
mtodo flush().



import java.io.*;

public class EjemFileOut {
public static void main(String[] args) {
int letra;

System.out.print("Ingrese un texto: ");

try{
FileOutputStream f = new FileOutputStream("datos.txt");
BufferOutputStream buffer = new BufferOutputStream(f);

do{
letra = System.in.read();
buffer.write(letra);
}while(letra != 10);

Buffer.flush(); // Vacia el buffer al archivo
f.close();
}
catch (IOException e){
System.out.println(e);
}
}
}













b. Flujos de Caracteres
Estos flujos se usan para trabajar con cualquier texto que represente un conjunto de
caracteres UNICODE, que incluye los caracteres ASCII. Pueden ser archivos de texto,
HTML, archivos fuentes, etc.
El flujo de entrada para un archivo de texto, se establece a travs de la clase FileReader.
Esta clase es subclase de InputStreamReader, la cual lee un flujo de bytes y los convierte a
enteros "que representan" valores de los caracteres UNICODE. El mtodo a utilizar es
read(), el cual devuelve enteros, que es necesario convertir a char para visualizar los
caracteres y devuelve -1 cuando se dejan de leer caracteres. Por ejemplo :
import java.io.*;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);

String archivo = "";
int enteroByte = 0;

System.out.print("Ingrese el nombre del archivo: ");
archivo = s.nextLine();

try{
FileReader f = new FileReader(archivo);
enteroByte = f.read();

while (enteroByte != -1){
System.out.print((char)enteroByte);
enteroByte = f.read();
}

f.close();
}
catch (IOException e){
System.out.println(e);
}
}
}
Al igual que en los casos anteriores, se puede usar un buffer para trabajar con los datos del
flujo de entrada en memoria y no directamente con el archivo. Para ello se utiliza la clase
BufferadReader, en donde se pasa como argumento un objeto Reader que sirve para
comunicarse con el archivo, en este caso, FileReader. Tambin tiene un mtodo read() otro
mtodo interesante es que se usa para leer una lnea entera del buffer: readLine(), que
devuelve un objeto String con la lnea y un valor null para la cadena cuando ya no quedan
ms lneas. Por ejemplo, el mismo programa anterior pero con modificaciones:
try{
FileReader f = new FileReader(archivo);
BufferedReader buffer = new BufferedReader(f);
String linea;

while (linea != null){
linea = buffer.readLine();
if (linea != null) System.out.print(linea + \n);
}
f.close();

El flujo se salida para escribir caracteres sobre archivos de texto, usa la clase FileWrite.
Con uno de sus constructores, FileWriter(String ruta_archivo), se reemplaza el contenido del
archivo original y lo reemplaza por el nuevo, si este exista; o en caso contrario; lo crea.
Ejemplo :
import java.io.*;
public class Main {

public static void main(String[] args) {
int letra;
System.out.print("Ingrese un texto: ");

try{
FileWriter f = new FileWriter("texto.txt");

do{
letra = System.in.read();
f.write(letra);
}while(letra != 10);

f.close();
}
catch (IOException e){
System.out.println(e);
}
}
}

Por otro lado, si no queremos perder el contenido de nuestro archivo tenemos el constructor
FileWriter(String ruta/archivo, boolean [true/false]), que escribe desde el final de un archivo
existente cuando se pasa como parmetro el valor boleano "true". Para esto se remplaza la
siguiente lnea:
FileWriter f = new FileWriter("texto.txt", true);
Finalmente, se puede utilizar un buffer para escribir nuestros caracteres en memoria y
despus mandarlos al archivo. Para establecer el buffer, se usa el constructor
BufferedWriter(Writer), donde "Writer" es el objeto que se crea para establecer el flujo.
Tambin tiene el mtodo write(), y el mtodo newLine(), que manda el o los caracteres de
"nueva lnea" segn la plataforma: en DOS retorno de carro ms salto de lnea , y en UNIX y
sistemas similares salto de lnea. Utilizar este mtodo es mejor pues el programa se hace
realmente multiplataforma. Se usa de la misma manera que lo hemos visto en los ejemplos
anteriores. Sin embargo, para poder utilizar el buffer se requiere tambin el mtodo flush(),
para vaciar el contenido del buffer en el archivo.
try{
FileWriter f = new FileWriter("texto.txt");
BufferedWriter buffer = new BufferedWriter(f);

do{
letra = System.in.read();
buffer.write(letra);
}while(letra != 10);

c. Flujos de atos
Los bytes y caracteres son datos tambin, pero por un archivo de datos entenderemos una
coleccin de informacin que se almacena en algn soporte magntico. Estos pueden ser
tipos primitivos u objetos. En el ltimo caso, se habla de un conjunto de registros, que
contienen los mismos campos, que pueden ser datos primitivos o un tipo definido por el
usuario, es decir otro objeto referenciado por el objeto que se almacena. En la POO, se
habla de objetos en vez de "registros" y de "atributos" en vez de campos.
Flujos de datos de ti!os !ri"itivos.
Muchas veces trabajar con bytes y caracteres puede llegar a ser muy restrictivo. JAVA
permite manejar flujos con los tipos primitivos, de modo que el manejo de ellos sea
transparente para la aplicacin.
Un flujo de entrada de datos de tipos primitivos, se hace con la clase DataInputStream, a la
cual se le pasa como argumento un objeto de flujo existente.
El flujo de salida, por su lado, es controlado por la clase DataOutputStream, que tambin
recibe como argumento un objeto de flujo, esta vez de salida.
Los mtodos de lectura y escritura para flujos de datos de tipos primitivos: boolean, byte,
short, int, long, float y double son:
Entrada Salida Significado
readBoolean() writeBoolean(boolean) Lee-escribe tipo boolean
readByte() writeByte(int) Lee tipo Byte - escribe tipo Byte un valor entero
writeBytes(String) Escribe una cadena como secuencia de bytes
readChar() writeChar(int) Lee tipo Char - Escribe como Char un valor entero
readChars(String) Lee una cadena como una secuencia de caracteres
readShort() writeShort(int) Lee tipo Short - Escribe como Short un valor entero
readInt() writeInt(Int) Lee - escribe tipo entero
readLong() writeLong(Long) Lee -escribe tipo long
readFloat() writeFloat(Float) Lee - escribe tipo float
readDouble() writeDouble(Double) Lee - escribe tipo double
readUTF(DataInput) writeUTF(String) Lee formato UTF-8 desde objeto DataInput - Escribe una
cadena en formato UTF-8

Cada mtodo devuelve un valor de retorno del mismo tipo sobre el que trabaja.
En el caso de readUTF() y writeUTF(), los datos obtenidos en el origen o escritos en el
destino, son convertidos a un formato portable entre distintos lenguajes y plataformas. En
este caso, se usa el estndar de caracteres UTF-8, que es un derivado de UNICODE.
Para trabajar con los flujos de datos primitivos, se debe crear un flujo asociado al origen o
destino de los datos, despus se asocia un objeto DataInputStream o DataOutputStream a
este flujo y se lee o escribe segn sea el caso. Por ejemplo estos 2 casos:
String cadena;
FileOutputStream f = new FileOutputStream("archivo.dat");
DataOutputStream d = new DataOutputStream(f);
d.writeUTF(cadena);

long dato;
FileInputStream f = new FileInputStream("enterosLong.dat");
DataInputStream d = new DataInputStream(f);
d.readLong(dato);

La extensin no es relevante, pero suele usarse ".dat", para indicar que se trata de un
archivo de datos binarios. A partir de ahora, utilizaremos la clase File, de cual hablaremos a
continuacin, con el objeto de identificar los archivos sobre los que se trabajaran. Primero
vamos a crear un archivo con datos de distinto tipo y despus lo leeremos.
Como ejemplo crearemos un programa, que ingrese registros en un archivo de datos y otro
que los lea y los muestre en pantalla.




import java.io.*;
public class Main {

public static void main(String[] args) throws IOException {
FileOutputStream f = new FileOutputStream("datos.dat",true);
DataOutputStream d = new DataOutputStream(f);

String cadena = "Esto esta que arde";
int entero = 22;

d.writeUTF(cadena);
d.writeInt(entero);

f.close();
}
}

Este programa permite ingresar el archivo de datos en el que vamos a guardar la
informacin. Crea el objeto File que nos permitir determinar si el archivo de datos existe o
no. Si no existe se crea. Si existe vamos a escribir a partir del final del mismo. Se crea el
stream de salida, y un objeto DataOutputStream que nos va permitir escribir los datos en el
archivo.
Para leer los datos guardados tenemos el siguiente programa :
import java.io.*;
public class Main {

public static void main(String[] args) throws IOException {
FileInputStream f = new FileInputStream("datos.dat");
DataInputStream d = new DataInputStream(f);

String cadena;
int entero;

try{
do{
cadena = d.readUTF();
entero = d.readInt();
System.out.println("Cadena: "+cadena+" entero:"+entero);
}while(true);
}
catch(EOFException e){
System.out.print("Fin del archivo");
}
f.close();
}
}

En la definicin del mtodo main, se usa la palabra reservada throws para sealar o indicar
que el mtodo en cuestin puede lanzar excepciones, en este caso, de la clase
IOException. Esto se hace para evitar tener que declarar, en cada caso que sta se
produzca, un try y un catch, que se produciran a nivel de la lectura de los datos contenidos
en el archivo. En estas situaciones, la excepcin no es atrapada en el mismo mtodo, no hay
un catch. Esto es simplemente un ejemplo para mostrar cmo evitar que se lancen
excepciones. Por otro lado, en los mtodos que eventualmente llamen a este tipo de
mtodos estn obligados a atrapar la excepcin.
Al igual que en el programa anterior, se declaran los objetos que hacen la lectura. Se crea
un objeto File con el objeto de verificar si el archivo existe y controlar la marca fin de archivo
(EOF). Si existe, se crean e inicializan los objetos del stream de entrada. Luego se leen los
datos del archivo y se ponen en pantalla. Finalmente, se cierra el flujo de datos.
Indudablemente, si queremos almacenar una coleccin de datos relacionados entre s, una
mejor y ms lgica solucin es el uso de objetos en vez del uso de bytes para ir guardando y
leyendo datos representados por tipos primitivos.
Flujo de datos con objetos
Esto se conoce como "Seriacin de Objetos". La idea es almacenar objetos con datos en un
archivo para hacerlos "persistentes", esto es que los datos no se pierdan cuando se deje de
usar al aplicacin en memoria principal. Ello porque la Memoria de Acceso Aleatorio (RAM) o
Principal, es voltil y los datos desaparecen una vez que ha terminado la aplicacin que los
controla. Se denomina "deseriacin" a la operacin de recuperar los datos desde el archivo
para usarlos en memoria.
Las clases que permiten estas operaciones son ObjectOutputStream, que permite escribir
en el flujo de salida, y ObjectInputStream, que permite reconstruir los objetos desde el flujo
de entrada. Ambas forman parte del paquete java.io. Actan sobre un flujo ya definido por
otro objeto. Por ejemplo :
//acta sobre el archivo
FileOutputStream f = new FileOutputStream("datos.dat");

//acta sobre los objetos
ObjectOutputStream obj = new ObjectOutputStream(f);

La seriacin es posible, slo cuando se implementa en la clase la interfaz Serializable. Que
tiene por objeto identificar los objetos serializables y no contiene ningn mtodo :
import java.io*;
public class MiClase implements Serializable {

Cuando un objeto tiene atributos que referencian a otros objetos, estos ltimos deben
escribirse tambin en el flujo. De esto se encarga el mtodo writeObject(), que recorre las
referencias recursivamente, escribiendo todos ellos. Por otro lado, el mtodo readObject(),
se encargar de recorrer recursivamente las referencias para recuperar los datos de los
objetos referenciados.
Como ejemplo, se crea una nueva clase denominada "Articulo", con sus respectivos
atributos y mtodos:
import java.io.Serializable;
public class Articulo implements Serializable {
private int cod;
private String nombre;
private int precio;
private boolean estado;

public Articulo(){}

public Articulo (int cod,String nombre,int precio,boolean estado){
this.cod = cod;
this.nombre = nombre;
this.precio = precio;
this.estado = estado;
}

public int getCod() { return cod; }
public boolean isEstado() { return estado; }
public String getNombre() { return nombre; }
public int getPrecio() { return precio; }
}

Se importa el paquete java.io para el uso de la interface "Serializable". Se definen dos
constructores: uno vaco por defecto y otro que recibe como argumentos los atributos de la
clase.
El siguiente programa, tiene por objetivo crear el archivo que va a seriar los objetos con
aquellos datos que ingresemos por teclado (objeto art). Si se abre el archivo de datos con un
editor de textos se ver que tiene un encabezado sealando, entre otras cosas, la clase de
objetos que almacena. Es por ello, que la seriacin se debe hacer en una sola sesin. Para
agregar objetos al archivo, o modificarlos o borrarlos, se usa la clase RandomAccessFile
del paquete java.io, que permite acceder a cualquier posicin (registro) dentro del archivo.
Luego en el mismo programa se realiza la lectura de los datos desde el archivo a travs del
objeto art2:


import java.io.*;
import java.util.Scanner;

public class Main {

public static void main(String[] args) throws IOException {
FileOutputStream f = new FileOutputStream("datos.dat");
ObjectOutputStream ob = new ObjectOutputStream(f);
Scanner ing = new Scanner(System.in);

/*
* Escritura del objeto hacia un archivo
*/
// Ingreso de datos
String cod, nom, pre, est;

System.out.print("Ingrese codigo: ");
cod = ing.nextLine();

System.out.print("Ingrese nombre: ");
nom = ing.nextLine();

System.out.print("Ingrese precio: ");
precio = ing.nextLine();

Articulo art = new Articulo(Integer.parseInt(cod),
nom,
Integer.parseInt(precio),
false);
ob.writeObject(art);

f.close();

/*
* Lectura del objeto desde un archivo
*/
Articulo art2 = new Articulo(); // Leer

FileInputStream f2 = new FileInputStream("datos.dat");
ObjectInputStream ob2 = new ObjectInputStream(f2);

try{
art2 = (Articulo)ob2.readObject();
}
catch(ClassNotFoundException e){
System.err.println("Clase no encontrada");
}

System.out.println("El codigo es: "+art2.getCod());
System.out.println("El nombre es: "+art2.getNombre());
System.out.println("El precio es: "+art2.getPrecio());

if(art2.isEstado())
System.out.println("Articulo Activo");
else
System.out.println("Articulo Desactivado");

f2.close();
}
}