Streams
Definición
Un Streams es un medio utilizado para leer datos de una fuente y para escribir datos en un destino. Tanto la fuente
como el destino pueden ser archivos, sockets, memoria, cadena de caracteres, y también procesos.
Los Streams se caracterizan por ser unidireccionales, es decir que un Stream se utilizara solo para leer, solo para
escribir, pero no ambas acciones al mismo tiempo.
Para utilizar una Stream, el programa a realizar deberá construir el Stream relacionándolo directamente con una
fuente o con un destino, dependiendo si se necesita leer o escribir información.
La acción de leer información de una fuente es conocida también como input, y la acción de escribir información es
un destino es conocida como output. Dentro de Java, todas las clases utilizadas tanto para el input como para el output
están incluidas en el paquete Java.io
Algoritmo de Lectura
Para obtener información, un programa deberá abrir un stream sobre una fuente y leer la información de forma
secuencial.
Independientemente del tipo de información, el algoritmo de lectura es siempre el mismo.
Abrir un Stream
Mientras haya mas información
{ Leer información }
Cerrar Stream
Algoritmo de Escritura
Para escribir información, un programa deberá abrir un stream sobre un destino y escribir la información de forma
secuencial.
Independientemente del tipo de información, el algoritmo de escritura es siempre el mismo.
Abrir un Stream
Mientras haya mas información
{ Escribir información }
Cerrar Stream
Tipos de Streams
Organización
La tecnología Java contiene distintos tipos de Streams, lo cual están organizados en dos grandes grupos:
· Streams orientados a Carácter (Character Streams)
· Streams orientados a Byte (Byte Streams)
Streams orientados a Carácter
Los Streams orientados a Carácter operan con caracteres como unidad de trabajo. Los caracteres a leer están
formados por 2 bytes (es decir 16 bits por carácter).
Son utilizados para leer y escribir información que esta almacenada en forma de texto, como por ejemplo archivos de
extensión txt, ini, csv, etc.
La Superclase utilizada para leer streams orientados a carácter es la clase Reader. A partir de esta clase - la cual es
abstracta – heredan todas las clases concretas que se utilizan para leer información en forma textual.
Por otra parte, la Superclase utilizada para escribir streams orientados a carácter es la clase Writer. A partir de esta
clase - la cual es abstracta – heredan todas las clases concretas que se utilizan para escribir información en forma
textual.
Streams orientados a Byte
Los Streams orientados a Byte operan con bytes como unidad de trabajo. Los bytes a leer se leen de forma unitaria
(es decir 8 bits por byte).
Son utilizados para leer y escribir información que esta almacenada en forma binaria, como por ejemplo archivos de
extensión jpeg, png, xls, etc.
La Superclase utilizada para leer streams orientados a byte es la clase InputStream. A partir de esta clase - la cual es
abstracta – heredan todas las clases concretas que se utilizan para leer información en forma binaria.
Por otra parte, la superclase utilizada para escribir streams orientados a byte es la clase OutputStream. A partir de
esta clase - la cual es abstracta – heredan todas las clases concretas que se utilizan para escribir información en forma
binaria.
Que es un File Stream
Los File Stream son los streams utilizados para lectura y escritura de (particularmente) archivos, es una categoría que
agrupa tanto a los streams orientados a carácter como a los streams orientados a byte.
En general se utilizan en conjunto con un objeto del tipo File, que es una representación abstracta de un archivo. La
clase File modela tanto archivos como directorios. Para su instanciación se deberá importar java.io.File.
Ejemplo de archivo:
File archivo = new File ("un_path/un_fichero.txt");
File archivo = new File (C://Usuarios//XXXX//Mis Documentos//MiArchivo.txt”);
File archivo = new File (“MiArchivo.txt/MiAnimacion.gif”); // Carpeta Raiz
Ejemplo de directorio:
File directorio = new File (“Carpeta Nueva”);
directorio.mkdir();//Se crea el directorio en la carpeta raíz
Lectura de un Archivo de Texto
La clase FileReader es una clase concreta utilizada para generar streams orientados a carácter, y es la encargada de
realizar la lectura de archivos en forma de texto. Para su instanciación se deberá importar java.io.FileReader y se
deberán tratar las excepciones chequeadas IOException y FileNotFoundException.
A continuación, se presenta un ejemplo de lectura de un archivo llamado fuente.txt:
/* Para que funcione correctamente deberá:
tener un archivo fuente.txt en la carpeta raíz */
// Define el archivo a usar
File archivoEntrada = new File("fuente.txt");
// Instancia un FileReader que se encargara de leer del archivo
FileReader lector = new FileReader(archivoEntrada);
// Declara una variable que contendrá el caracter a leer
int unCaracter;
// Lee el archivo e informa
while ( (unCaracter = lector.read()) != -1)
System.out.print((char)unCaracter);
// Cierra el archivo
lector.close();
Escritura de un Archivo de Texto
La clase FileWriter es una clase concreta utilizada para generar streams orientados a carácter, y es la encargada de
realizar la escritura de archivos en forma de texto. Para su instanciación se deberá importar java.io.FileWriter y se
deberá tratar la excepción chequeada IOException.
A continuación, se presenta un ejemplo de escritura de un archivo llamado destino.txt:
// Instancia un objeto File de salida
File archivoSalida = new File("destino.txt");
// Instancia un FileWriter que se encargara de escribir
FileWriter escritor = new FileWriter(archivoSalida);
// Construye una cadena de caracteres a ser guardada en el archivo
String info = "Soy la informacion!";
// Escribe el archivo con la informacion
for (int i=0; i<info.length(); i++)
escritor.write(info.charAt(i));
// Cierra el stream
escritor.close();
// Informa que el archivo ha sido escrito
System.out.println("El archivo ha sido escrito...");
Lectura y Escritura de Archivos Binarios
La clase FileInputStream es una clase concreta utilizada para generar streams orientados a byte y es la encargada de
realizar la lectura de archivos en forma binaria.
La clase FileOutputStream es una clase concreta utilizada para generar streams orientados a byte, y es la encargada
de realizar la escritura de archivos en forma binaria.
Para su instanciación se deberá importar java.io.FileInputStream y java.io.FileOutputStream y se deberá tratar las
excepciones chequeadas IOException y FileNotFoundException.
A continuación, se presenta un ejemplo de lectura de un archivo llamado fuente.gif y la escritura de dicho contenido
es un archivo llamado destino.gif. La clase Copiador presentada a continuación lee la imagen, y genera un duplicado de
la misma:
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Copiador {
public static void main(String[] args) throws IOException{
/* Para que funcione correctamente deberá:
tener un archivo logo.gif en la carpeta raíz */
// Instancia un objeto File de entrada y otro de salida
File archivoEntrada = new File("logo.gif");
File archivoSalida = new File("destino.gif");
// Instancia un FileInputStream y un FileOutputStream que se encargaran de leer y escribir archivos
respectivamente
FileInputStream lector = new FileInputStream(archivoEntrada);
FileOutputStream escritor = new FileOutputStream(archivoSalida);
// Instancia una variable que contendrá el byte a leer
int unByte;
// Informa que se está copiando el archivo
System.out.println("\n\tEl archivo está siendo copiado…");
// Lee el archivoEntrada y guarda la informacion en el archivoSalida
while ( (unByte = lector.read()) != -1)
escritor.write(unByte);
// Cierra los archivos
lector.close();
escritor.close();
// Informa que se ha copiado el archivo
System.out.println("\tEl archivo ha sido copiado con éxito…\n");
}}
Que son los Buffers
Los buffers son una alternativa a las clases básicas de entrada y salida. Son subclases de las clases básicas
correspondientes a la clase Reader, Writer, InputStream y OutputStream.
Cumplen el mismo objetivo que dichas clases, pero son eficientes ya que tienen como objetivo guardar en un buffer
los caracteres leídos / por escribir para lograr una mejora sustancial en la lectura / escritura.
Son utilizados como wrappers (envoltorios) para envolver las clases básicas.
La clase BufferedReader
La clase BufferedReader es una clase que hereda de la clase Reader y se utiliza para envolver a otras subclases del tipo
Reader, tales como la clase FileReader.
Entre los métodos mas utilizados se encuentra el método readLine(), que permite leer un conjunto de caracteres
retornado en forma de String, en lugar de leer carácter a carácter.
Para su instanciación se deberá importar java.io.BufferedReader y se deberá tratar las excepciones chequeadas
IOException y FileNotFoundException.
La clase BufferedReader puede ser utilizada de la siguiente manera:
// Instancia un objeto File de entrada
File archivoEntrada = new File("fuenteBuffer.txt");
// Construye un BufferedReader
BufferedReader lectorMejorado = new BufferedReader (new FileReader(archivoEntrada));
// Defino variables
boolean eof = false;
String lineaLeida = "";
// Lee el archivoEntrada de forma eficiente e imprime los datos en pantalla
while ( !eof )
// Lee una linea entera
lineaLeida = lectorMejorado.readLine();
// Imprime la linea en pantalla
if( lineaLeida != null )
System.out.println( lineaLeida );
// Si llego al final del archivo, termina la ejecución
else
eof = true;
// Cierra el FileReader
lectorMejorado.close();
La clase BufferedWriter
La clase BufferedWriter es una clase que hereda de la clase Writer y se utiliza para envolver a otras subclases del tipo
Writer, tales como la clase FileWriter.
Entre los métodos mas utilizados se encuentra el método write (String s, int offset, int length), que permite escribir
un conjunto de caracteres en lugar de escribir carácter por carácter.
Adicionalmente posee un método denominado newLine() que se utiliza para escribir en el stream la representación
de una nueva línea, es decir la tecla “enter”, entendiendo que cada sistema operativo puede representarla con distintos
caracteres.
Para su instanciación se deberá importar java.io.BufferedWriter y se deberá tratar la excepciones chequeada
IOException.
La clase BufferedWriter puede ser utilizada de la siguiente manera:
// Instancia un objeto File de salida
File archivoSalida = new File (“destinoBuffer.txt");
// Define el contenido a grabar en el archivo
String linea1 = "Soy la línea #1";
String linea2 = "Yo soy la línea #2!";
String linea3 = "Y yo la línea #3!!!";
// Construye un BufferedWriter
BufferedWriter escritorMejorado = new BufferedWriter (new FileWriter(archivoSalida));
// Escribe el archivo de salida a través del BufferedWriter
escritorMejorado.write(linea1, 0, linea1.length());
escritorMejorado.newLine();
escritorMejorado.write(linea2, 0, linea2.length());
escritorMejorado.newLine();
escritorMejorado.write(linea3, 0, linea3.length());
// Cierra el BufferedWriter
escritorMejorado.close();
La clase BufferedInputStream
El objetivo de la clase BufferedInputStream es el mismo que el de la clase BufferedReader, la diferencia radica en que el
tratamiento de la información es a nivel bytes, y no a nivel caracteres.
Para su instanciación se deberá importar java.io.BufferedInputStream y se deberá tratar las excepciones chequeadas
IOException y FileNotFoundException.
La clase BufferedOutputStream
El objetivo de la clase BufferedOutputStream es el mismo que el de la clase BufferedWriter, la diferencia radica en que el
tratamiento de la información es a nivel bytes, y no a nivel caracteres.
Para su instanciación se deberá importar java.io.BufferedOutputStream y se deberá tratar las excepciones chequeadas
IOException y FileNotFoundException.
Copiador Mejorado:
import java.io. *;
public class CopiadorMejorado {
public CopiadorMejorado() {
public static void main(String[] args) throws IOException {
/* Para que funcione correctamente deberá:
tener un archivo nvierno en la carpeta imágenes de muestra de Windows */
// Instancia un objeto File de entrada y otro de salida
File archivoEntrada = new File("C:\\Documents and Settings\\All Users\\Documentos\\Mis imágenes\\Imágenes de
muestra\\Invierno.jpg");
File archivoSalida = new File("C:\\Documents and Settings\\All Users\\Documentos\\Mis imágenes\\Imágenes de
muestra\\destino.jpg");
BufferedInputStream lectorMejorado = new BufferedInputStream(new FileInputStream(archivoEntrada));
BufferedOutputStream escritorMejorado = new BufferedOutputStream(new FileOutputStream(archivoSalida));
int unByte;
System.out.println("\n\tEl archivo está siendo copiado…");
while ((unByte = lectorMejorado.read()) != -1) {
escritorMejorado.write(unByte); }
lectorMejorado.close();
escritorMejorado.close();
System.out.println("\tEl archivo ha sido copiado con éxito....\n");
La clase PrintWriter
Es una de las clases mas usadas para el manejo de archivos, ya que posee los métodos print (String) y println (String),
idénticos a los de System.out, y en este caso no hace falta hacer una llamada al método newLine().
La clase PrintWriter se puede utilizar de la siguiente manera:
PrintWriter pw = new PrintWriter(new FileWriter(“MiArchivo.txt”));
for (int i = 0; i < 10; i++)
pw.println("Linea " + i);
if (null != pw)
pw.close();
