Universidad Nacional de Trujillo

Ingeniera de Sistemas
Tema: Funciones stream
Docente: Mg. Vidal Melgarejo,
Zoraida Yanet
Alumno: Rivera Romn, Eduardo Daniel
Ciclo: V
Trujillo-Per
P g i n a | 1

ndice

ImputStreampag. 2
SequenceInputStream..pag. 2
PipedInputStreampag. 3
FileInputStream.pag. 3
FilterInputStream.pag. 4
DataInputStream..pag. 4
PushbackInputStreampag. 4
BufferedInputStream.pag. 5
LineNumberInputStream......................................................................pag. 5
ByteArrayInputStream...pag. 6
StringBufferInputStreampag. 6
OutputStreampag. 7
FileOutputStreampag. 7
PipedOutputStream..pag. 7
ByteArrayOutputStream.pag. 8
FilterOutputStream.pag. 8
DataOutputStream.pag. 9
PrintStream..pag. 9
BufferedOutputStreampag. 10
Redaer(PipedReader,FileReader,etc)....pag. 11
Writer(PipedWriter,FileWriter,etc).pag. 13
Bibliografiapag. 17
P g i n a | 2

I. InputStream:
La clase abstracta InputStream declara los mtodos para leer datos
desde una fuente concreta y es la clase base de la mayor parte de los
flujos de entrada en java.io.
Hay varias clases que derivan de InputStream y redefinen el mtodo
read para darle una implementacin distinta:
1) SequenceInputStream:
Cuando se tienen varios InputStreams que se desean procesar
seguidos se pueden concatenar mediante un SequenceInputStream.
De esta manera aparecen como un nico InputStream continuo.







2) P
i
p
e
d
InputStream:
Implementa los componentes de entrada de otro proceso en
ejecucin. Las tuberas se utilizan para canalizar la salida de un
programa hacia la entrada de otro.
Un PipedInputStream debe ser conectado a un PipedOutputStream.
Los canales de entrada y salida para tuberas son convenientes para
mtodos que producen una salida para ser utiliza como entrada de
otro mtodo. Por ejemplo, supongamos que estamos; escribiendo
una clase que implementa varias utilidades de texto, como la
ordenacin y la inversin del texto. Sera eficaz que la salida de uno
leInputStream f1, f2;
f1 = new FileInputStream(Datos1.dat);
f2 = new FileInputStream(Datos2.dat);
SequenceInputStream sis;
sis = new SequenceInputStream(f1, f2);

int dato;
while ((dato = sis.read()) != -1)
System.out.println(dato);

sis.close();

P g i n a | 3

de esos mtodos pudiera utilizarse como la entrada de otro. As
podramos concatenar una serie de esos mtodos para realizar
alguna funcin.

3) FileInputStream:
El FileInputStream redefine el mtodo read para leer el byte de un
fichero.















4) FilterInputStream:
Un filtro de entrada es un InputStream al cual se le asocia en su
constructor otro InputStream. Los filtros devuelven la informacin
que a su vez han ledo de su InputStream asociado, previa
realizacin de algn tipo de transformacin en la misma. De esta
manera cada filtro aade una funcionalidad adicional al
InputStream bsico. Se pueden encadenar varios filtros para
obtener varias funcionalidades combinadas.
a) DataInputStream:
FileInputStream
FileInputStream f;
f = new FileInputStream(Datos.dat);

int dato;
while ((dato = f.read()) != -1)
System.out.println(dato);

f.close();
P g i n a | 4

Permite leer tipos de datos primitivos, tales como int, float, double
e incluso lneas de texto.











b) PushbackInputStream:
Permite a otro flujo de entrada la capacidad de volver a colocar un
byte o array de bytes ledo otra vez en el flujo. La siguiente
operacin de lectura volver a leer el ltimo byte.
Los constructores son:
PushbackInputStream(InputStream in)
PushbackInputStream(InputStream in, int size)
Parmetros:
in - nombre del input stream.
size - tamao del input stream.






c) BufferedInputStream:
Almacena el acceso a los datos para mejorar la eficacia.
Los constructores son:
BufferedInputStream (InputStream in)
BufferedInputStream(InputStream in, int size)
Parmetros:
DataInputStream dis;
dis = new DataInputStream(new FileInputStream(A));

int i = dis.readInt();
double d = dis.readDouble();
String s = dis.readLine();

dis.close(); // Se cierra tambin el socio
P g i n a | 5

in nombre del input stream que se crea.
size tamao del buffer interno donde se almacena los
datos.






d) LineNumberInputStream:
Mantiene un contador sobre el nmero de lnea que se est
leyendo. Empieza por 0 y se incrementa en uno cuando se
encuentra el caracter \n o \r.
El constructor es:
LineNumberInputStream(InputStream in)
Parmetro:
in - nombre del input stream que es ledo.









5) ByteArrayInputStream:
El ByteArrayInputStream redefine el mtodo read para leer el byte
de un array que se le pase en el constructor.
Los constructores son:
ByteArrayInputStream(byte[] buf)
ByteArrayInputStream(byte[] buf, int offset, int length)
Parmetros:
buffer array de bytes que es ledo.
offset posicin del primer byte que se lee.
P g i n a | 6

length el nmero mximo de bytes que son ledos.

6) S
t
r
i
n
g
B
u
f
f
e
r
I
n
putStream:
Permite leer bytes desde un String. Esta clase no convierte
correctamente caracteres en bytes. La clase preferida para esto es
StringReader que veremos ms adelante.
El constructor es:
StringBufferInputStream(String s)
Parmetro:
s cadena que es leda

II. OutputStream:
Clase abstracta de la que derivan los dems flujos de salida.
1) FileOutputStream:
El FileOutputStream redefine el mtodo write para enviar el byte a
un fichero.
Los constructores son:
FileOutputStream(File file)
FileOutputStream(File file, boolean append )
FileOutputStream(FileDescriptor fdObj)
byte[] v = new byte[1024];
for (int i = 0; i < v.length; i++)
v[i] = i * 2;

ByteArrayInputStream ba;
ba = new ByteArrayInputStream(v);

int dato;
while ((dato = ba.read()) != -1)
System.out.println(dato);

ba.close();
P g i n a | 7

FileOutputStream(String name)
FileOutputStream(String name, boolean append)
Parmetros:
file archivo representado por el objeto File.
append Si es verdadero, los bytes escritos se aadirn al final del
archivo.









2) PipedOutputStream:
Manda bytes de datos a otro proceso en ejecucin (threat).
Los constructores son:
PipedOutputStream()
PipedOutputStream(PipedInputStream snk)
Parmetro:
snk - nombre del pipe input stream.




3) ByteArrayOutputStream:
El ByteArrayOutputStream redefine el mtodo write para enviar el
byte a un array dinmico (en memoria).
Los constructores son:
ByteArrayOutputStream()
ByteArrayOutputStream(int size)
Parmetro:
size Tamao que tendr el array cuando se cree.

FileOutputStream f;
f = new
FileOutputStream(Datos.dat);
for (int i = 0; i < 100; i++)
f.write(i);
f.close();
P g i n a | 8













4) FilterOutputStream:
Un filtro de salida es un OutputStream al cual se le asocia en su
constructor otro OutputStream (patrn Decorator)
Los filtros reenvan toda la informacin que reciben a su
OutputStream asociado, previa realizacin de algn tipo de
transformacin en la misma.
De esta manera cada filtro aade una funcionalidad adicional al
OutputStream que encapsula.
Se pueden encadenar varios filtros para obtener varias
funcionalidades combinadas.


a) DataOutputStream:
Permite a las aplicaciones escribir tipos primitivos de Java en un
flujo de salida de un modo portable. Se puede utilizar un
DataInputStream para leer los datos.
El constructor es:
DataOutputStream(OutputStream out)
Parmetro:
out - nombre del output stream asociado.
ByteArrayOutputStream ba;
ba = new ByteArrayOutputStream();
for (int i = 0; i < 100; i++)
ba.write(i);
ba.close();

// Con ba.toByteArray() accedemos al
array
// con los bytes escritos
P g i n a | 9













b) PrintStream:
Se pueden escribir representaciones de diversos datos de forma
conveniente. Los mtodos de esta clase no lanzan una excepcin
del tipo IOException, en su lugar establecen una bandera interna
que puede ser consultada mediante el mtodo checkError. La salida
estndar a la que se puede acceder a travs del atributo esttico
out de la clase System es de este tipo.
Los constructores son:
PrintStream(File file)
PrintStream(File file, String csn)
PrintStream(OutputStream out)
PrintStream(OutputStream out, boolean autoFlush)
PrintStream(OutputStream out, boolean autoFlush, String
encoding)

PrintStream(String fileName)
PrintStream(String fileName, String csn)
Parmetros:
file - fichero usado como destino del print stream.
csn - nombre del charset soportado, por ejemplo, UTF-8, US-
ASCII, etc.
DataOutputStream dos;
dos = new DataOutputStream(new
FileOutputStream(A));

dos.writeInt(i);
dos.writeDouble(3.14);
dos.writeChars(Hola);

dos.close(); // Se cierra tambin el socio
P g i n a | 10

out - es el output stream donde se envan los datos.
autoFlush el buffer es vaciado siempre que se escribe un byte.
enconding - nombre del charset soportado.
fileName - nombre del archivo









c) BufferedOutputStream:
Esta clase implementa un flujo de salida con buffer, de forma que
una aplicacin puede escribir bytes en el flujo de salida subyacente
sin que se tenga que hacer llamadas para que se escriba cada byte (
se pueden almacenar para ser escritos en bloque ).
Los constructores son:
BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out, int size)
Parmetros:
out nombre del output stream donde se escriben los datos.
size tamao del buffer interno que se utiliza.


III. Reader:
las clases que trabajan con la entrada de caracteres se heredan de la
clase Reader que est definida como abstracta. Las clases que extienden
a Reader para la lectura de caracteres son:
1) CharArrayReader:
Lee de un array de caracteres.
Los constructores:
PrintStream ps;
ps = new PrintStream(new FileOutputStream(A));
ps.println(1);
ps.println(3.14);
ps.println(Hola);
ps.close(); // Se cierra tambin el socio
P g i n a | 11

CharArrayReader(char[] buf)
CharArrayReader(char[] buf, int offset, int length)
Parmetros:
buf array de caracteres
offset posicin del primer caracter ledo
length - cantidad de caracteres a leer.

2) FileReader:
Lee caracteres de un fichero.
Los constructores son:
FileReader(File file)
FileReader(FileDescriptor file)
FileReader(String file)
Parmetro:
file - archivo que se va a utilizar

3) PipedReader:
Lee caracteres de un pipe de comunicacin entre hilos.
Los constructores son:
PipedReader()
PipedReader(int pipeSize)
PipedReader(PipedWriter src)
Parmetros:
pipeSize tamao del buffer interno del pipe.
src nombre del pipeWriter al cul se asocia el pipeReader


4) StringReader:
Lee caracteres de un String.
El constructor es:
StringReader(String s)
Parmetro:
s String del cual se leern los caracteres.

P g i n a | 12

5) InputStreamReader:
Permite asociar un Reader a un input stream leyendo del ltimo.
Los constructores son:
InputStreamReader(InputStream in)
InputStreamReader(InputStream in, Charset cs)
InputStreamReader(InputStream in, CharsetDecoder dec)
InputStreamReader(InputStream in, String charsetName)
Parmetros:
in - nombre del input stream
cs nombre del objeto Charset.
dec nombre del objetoCharsetDecoder.
charsetName - nombre del charset soportado en formato
String.

6) BufferedReader:
Lee caracteres de un fichero, almacenando los caracteres para que la
lectura sea correcta.
Los constructores son:
BufferedReader(Reader in)
BufferedReader(Reader in, int sz)
Parmetros:
in - objeto de la clase Reader
sz tamao del buffer interno





7) LineNumberReader:
Lee caracteres de un fichero almacenndolos y permitiendo
consultar el nmero de lneas ledas.
Los constructores son:
LineNumberReader(Reader in)
LineNumberReader(Reader in, int sz)
P g i n a | 13

Parmetros:
in - objeto de la clase Reader
sz - tamao del buffer interno.


8) PushBackReader:
Permite volver a poner en el flujo caracteres ledos.
Los constructores son:
PushbackReader(Reader in)
PushbackReader(Reader in, int size)
Parmetros:
in - objeto de la clase Reader
sz tamao del buffer interno.


IV. Writer:
La clase de la que heredan las clases de salida que trabajan con
caracteres es la clase Writer. Las clases utilizadas son:
1) CharArrayWriter:
Escribe en un array de caracteres.
Los constructores son:
CharArrayWriter()
CharArrayWriter(int initialSize)
Parmetro:
initialSize da un tamao inicial al array de caracteres.



2) FileWriter:
Escribe en un fichero.
Los constructores son:
FileWriter(File file)
FileWriter(File file, boolean append)
FileWriter(FileDescriptor fd)
P g i n a | 14

FileWriter(String fileName)
FileWriter(String fileName, boolean append)
Parmetros:
file nombre del objeto File
append - valor booleano. Si es true, los datos se escriben al final
del fichero.
fileName nombre del fichero.
fd nombre del FileDescriptor asociado al objeto FileWriter

3) PipedWriter:
Escribe caracteres de un pipe de comunicacin entre hilos ( threats ).
Los constructores son:
PipedWriter()
PipedWriter(PipedReader snk)
Parmetro:
snk - nombre del PipedReader que est asociado.

4) StringWriter:
Escribe caracteres en un String.
Los constructores son:
StringWriter()
StringWriter(int initialSize)
Parmetro:
initialSize Tamao del buffer utilizado para almacenar
caracteres.





5) OuputStreanWriter:
Escribe caracteres en un String.
Los constructores son:
StringWriter()
P g i n a | 15

StringWriter(int initialSize)
Parmetro:
initialSize Tamao del buffer utilizado para almacenar
caracteres.


6) BufferedWriter:
Escribe caracteres en un flujo de salida (output stream), almacena
los caracteres para que puedan ser manipulados de una forma
adecuada, bien como caracteres, arrays o cadenas ( string ).
Los constructores son:
BufferedWriter(Writer out)
BufferedWriter(Writer out, int sz)
Parmetros:
out nombre del output stream
sz - tamao del buffer utilizado


7) PrintWriter:
Permite escribir tipos primitivos y objetos a un flujo de salida
orientado a caracteres.
Los constructores son:
PrintWriter(File file)
PrintWriter(File file, String csn)
PrintWriter(OutputStream out)
PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter(String fileName)
PrintWriter(String fileName, String csn)

PrintWriter(Writer out)
PrintWriter(Writer out, boolean autoFlush)
Parmetros:
file - nombre del objeto File que se usa como destino.
csn mapa de caracteres ( charset ) soportado.
P g i n a | 16

out output stream de caracteres
autoFlush si es verdadero se vaciar el buffer de salida.
fileName nombre del archivo que se utiliza como destino.

























Bibliografa:
http://www2.uah.es/jcaceres/cursos/java/archivos/temas/curs
oJava_10.pdf
P g i n a | 17

http://www.unirioja.es/cu/fgarcia/sd/pub/teo/02-Java-IO.pdf
http://www.lab.dit.upm.es/~lprg/material/apuntes/io/streams.
htm