Programación Orientada a

Objetos

Anexo 5
Streams
Temario
 Streams
 El package java.io
 Streams de bytes y de caracteres
 Streams de bajo y alto nivel
 Leyendo y escribiendo
 Sockets

2
Streams
 Los Streams son interfaces que permiten ver de una
manera común los diferentes elementos de entrada /
salida (archivos, teclado/pantalla, sockets, etc.)
 Un stream de entrada:

 Un stream de salida:

3
El Package java.io
 Las clases de entrada / salida del
paquete java.io:
 ocultan la complejidad de las operaciones
de bajo nivel
 aíslan al programador de los detalles
específicos del sistema operativo
 proveen una manera consistente de
representar la entrada / salida

4
El Package java.io
 Las clases de streams del paquete java.io se
encuentran divididas en 4 jerarquías de
clases, dependiendo de si son de entrada o
salida, y del tipo de datos sobre el que
operan (bytes o caracteres)

Lectura Escritura

Operan sobre bytes InputStream OutputStream

Operan sobre Reader Writer

caracteres

5
 Streams Byte v/s Character

Streams de Bytes Streams de Caracteres

 Métodos operan  Métodos operan
sobre (arreglos de) sobre (arreglos de)
bytes caracteres
 Contiene bytes de  Contiene caracteres
8-bit
Unicode de 16-bit
 Implementado por
clases InputStream  Implementado por
y OutputStream clases Reader y
 No manejan Writer
buffers  Manejan buffers
6
 Reader y InputStream

 Clases abstractas para leer caracteres y bytes

 Reader permite leer streams de caracteres
 InputStream permite leer streams de bytes

 Métodos básicos Reader:

 int read()
 int read(char[] cbuf)
 abstract int read(char[] cbuf, int off, int len)

 Métodos básicos InputStream:

 abstract int read()
 int read(byte[] bbuf)
 int read(byte[] bbuf, int off, int len) 7
 Writer y OutputStream

 Clases abstractas para escribir caracteres y bytes

 Writer permite escribir streams de caracteres
 OutputStream permite escribir streams de bytes

 Métodos básicos Writer:

 void write(int c)
 void write({char[]|String} cbuf)
 abstract void write({char[]|String} cbuf, int off, int len)

 Métodos básicos OutputStream:

 abstract void write(int b)
 void write(byte[] bbuf)
 void write(byte[] bbuf, int off, int len) 8
Streams de Caracteres

9
Streams de Bytes

10
 Streams Conectados a Datos
 Streams conectados directamente a fuentes o
destinos de información (en gris en las jerarquías
anteriores)
Clases Fuente o destino de datos
FileReader, FileWriter, Archivos
FileInputStream,
FileOutputStream
PipedReader, PipedWriter, Pipes: un thread lee en un PipedReader
PipiedInputStream, lo que otro escribe en un PipedWriter
PipedOutputStream
CharArrayReader, CharArrayWriter Arreglos de caracteres
StringReader, StringWriter Strings
ByteArrayInputStream, Arreglos de bytes
ByteArrayOutputStream

11
 Encadenamiento de Streams
 Streams que operan sobre otros streams, agregando
funcionalidad, convirtiendo información, etc. (en blanco en las
jerarquías anteriores)
Clases
FilterReader, FilterWriter, FilterInputStream,
FilterOutputStream
BufferedReader, BufferedWriter,
BufferedInputStream, BufferedOutputStream
LineNumberReader, LineNumberInputStream
InputStreamReader, OutputStreamWriter
PushbackReader, PushbackInputStream
SequenceInputStream
PrintWriter, PrintStream
DataInputStream, DataOutputStream
ObjectInputStream, ObjectOutputStream
Descripción
Clases base para la implementación del patrón de
diseño Decorator; los métodos simplemente delegan
los requerimientos en el stram “conectado”.
Manejan buffers. BufferedReader agrega además un
método readLine().
Agregan el método getLineNumber().
Proveen conversión entre bytes y caracteres.
Agregan métodos unread().
InputStream que lee desde una secuencia de objetos
InputStream.
Agregan métodos para escribir objetos
formateadamente.
Proveen métodos para leer y escribir tipos primitivos.
Proveen manejo de serialización.
12
 Copiando un Archivo
import java.io.*;

public class Copy {

public static void main(String[] args) throws IOException {
FileReader in = new FileReader("c:/appserv/data.txt");
FileWriter out = new FileWriter("c:/appserv/out.txt");

int c;
while ((c = in.read()) != -1) {
out.write(c);
}

in.close();
out.close();
}
}
13
Leyendo de un Archivo
 El siguiente código permite leer por líneas de un
archivo:
FileReader fr = null;
BufferedReader br = null;
try {
fr = new FileReader("c:/appserv/epgtos.txt");
br = new BufferedReader(fr);
String s;
while ((s = br.readLine()) != null) {
...
}
} finally {
if (fr != null) {
fr.close();
}
}
14
Leyendo del Teclado
 El siguiente código permite leer por líneas lo que el
usuario escribe en el teclado:
InputStreamReader isr = new
InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
try {
System.out.print("Ingrese su nombre: ");
String name = br.readLine( );
System.out.print("Ingrese su dirección: ");
String address = br.readLine( );
} catch (IOException e) {
System.out.println("IOException");
}

15
PrintWriter
 Escribe texto y números en formato de texto, en
métodos print() y println()
 El constructor de PrintWriter recibe como parámetro
un objeto OutputStream, Writer, File, o String (el
nombre de un archivo)
FileWriter fw = new FileWriter("C:/appserv/emp.dat");
PrintWriter pw = new PrintWriter(fw);
String nombre = "Andrea Ramírez";
double sueldo = 1500000;
pw.print(nombre);
pw.print("");
pw.print(sueldo);
pw.close();
fw.close();

16
Excepciones
 El paquete java.io contiene un conjunto
de excepciones, todas derivadas de
IOException:
 EOFException
 FileNotFoundException
 InterruptedIOException
 IOException
 SecurityException

17
Clase File
 Provee una abstracción de los nombres del
archivo o directorio en el sistema de archivos

 Provee métodos útiles para la manipulación

de nombres de archivos

 getName()  list()
 getPath()  exists()
 lastModified()  isFile()
 mkdir()  isDirectory()
 delete()
18
Close
 Los streams ocupan recursos del sistema
operativo

 Al terminar de usar un stream, hay que

cerrarlo utilizando su método close()

 Al cerrar un archivo se realiza un flush()

19
Resumen
 El paquete java.io tiene dos jerarquías de
streams: una para leer/escribir caracteres
(clases Reader y Writer), otra para
leer/escribir bytes (clases InputStream y
OutputStream)
 Existen streams conectados directamente a
fuentes y destinos de información, y streams
que se encadenan a otros

20