ARCHIVOS DE ACCESO

SECUENCIAL
Alumno: Villarroel Cruzado, Jos Wilson Hel

TECNOLOGA DE LA
PROGRAMACIN II

Contenido
InputStream .................................................................................................................................3
Ejemplo: ...................................................................................................................................3
Subclases: .................................................................................................................................4
FileInputStream ............................................................................................................................4
Ejemplo: ...................................................................................................................................4
PipedInputStream ........................................................................................................................4
Ejemplo: ...................................................................................................................................4
FilterInputStream .........................................................................................................................4
Subclases: .................................................................................................................................5
LineNumberInputStream..............................................................................................................5
DataInputStream ..........................................................................................................................5
Ejemplo: ...................................................................................................................................5
BufferedInputStream ...................................................................................................................5
PushbackInputStream ..................................................................................................................5
Ejemplo: ...................................................................................................................................6
SequenceInputStream ..................................................................................................................6
StringBufferInputStream ..............................................................................................................6
ObjectInputStream .......................................................................................................................6
OutputStream ..............................................................................................................................6
Subclases: .................................................................................................................................6
FileOutputStream .........................................................................................................................6
PipedOutputStream .....................................................................................................................7
Ejemplo: ...................................................................................................................................7
FilterOutputStream ......................................................................................................................7
Subclases: .................................................................................................................................7
DataOutputStream .......................................................................................................................7
BufferedOutputStream ................................................................................................................7
ObjectOutputStream ....................................................................................................................7
Reader ..........................................................................................................................................8
Subclases: .................................................................................................................................8
BufferedReader ............................................................................................................................8
Subclase: ..................................................................................................................................8
LineNumberReader ......................................................................................................................8

CharArrayReader ..........................................................................................................................8
InputStreamReader ......................................................................................................................8
Subclase: ..................................................................................................................................9
FileReader ....................................................................................................................................9
FilterReader ..................................................................................................................................9
Subclase: ..................................................................................................................................9
PushbackReader ...........................................................................................................................9
PipedReader .................................................................................................................................9
StringReader.................................................................................................................................9
Writer .........................................................................................................................................10
Subclases: ...............................................................................................................................10
BufferedWriter ...........................................................................................................................10
CharArrayWriter .........................................................................................................................10
OutputStreamWriter ..................................................................................................................10
Subclase: ................................................................................................................................10
FileWriter ...................................................................................................................................10
FilterWriter.................................................................................................................................10
PipedWriter ................................................................................................................................10
StringWriter ...............................................................................................................................11
PrintWriter .................................................................................................................................11

INTRODUCCION
Cualquier programa realizado en Java que necesite llevar a cabo una operacin de I/O
lo har a travs de un stream. Un stream, cuya traduccin literal es flujo, es una
abstraccin de todo aquello que produzca o consuma informacin.
Podemos ver este stream como una entidad lgica. La vinculacin de este stream al
dispositivo fsico la hace el sistema de entrada y salida de Java. Se ve pues la eficacia de
esta implementacin pues la clases y mtodos y I/O que necesitamos emplear son las
mismas independientemente del dispositivo con el que estemos actuando, luego, el
ncleo de Java, sabr si tiene que tratar con el teclado, el monitor, un sistema de
ficheros o un socket de red liberando a nuestro cdigo de tener quien saber con quin
est interactuando.

BYTE STREAMS
Nos proporciona un medio adecuado para el manejo de entrada y salidas de bytes y su
uso lgicamente est orientado a la lectura y escritura de datos binarios. El tratamiento
del flujo de bytes viene gobernado por dos clases abstractas que son InputStream y
OutputStream.
Cada una de estas clases abstractas tienen varias subclases concretas que controlan las
diferencias entre los distintos dispositivos de I/O que se pueden utilizar. As mismo,
estas dos clases son las que definen los mtodos que sus subclases tendrn
implementados y, de entre todas, destacan las clases read() y write() que leen y
escriben bytes de datos respectivamente.

InputStream
La clase InputStream es la clase base (superclase) de todos los flujos de entrada en el
API I/O de Java. Las aplicaciones que necesitan definir una subclase de InputStream
deben proporcionar un mtodo que devuelve el siguiente byte de entrada.

Ejemplo:
InputStream inputstream = new FileInputStream("c:\\dato\\input-text.txt");
int dato = inputstream.read();
while(dato != -1) {
hacerAlgo(dato); //hacer algo con el dato...
dato = inputstream.read();
}
inputstream.close();

Subclases:

FileInputStream
Define varios constructores de los cuales destacan el que le pasamos como un
parmetro String que contiene la ruta completa del fichero y otro al que le pasamos un
objeto de tipo File. En todos los casos, si el fichero no existe se debe lanzar la excepcin
FileNotFoundException.

Ejemplo:
InputStream input = new FileInputStream("c:\\dato\\input-text.txt");
int dato = input.read();
while(dato != -1) {
//hacer algo con el dato...
hacerAlgo(dato);
dato = input.read();
}
input.close();

PipedInputStream
La clase PipedInputStream hace que sea posible leer el contenido de un canal como
secuencia de bytes. Debe de estar relacionado con un PipedOutputStream.

Ejemplo:
InputStream input = new PipedInputStream(pipedOutputStream);
int dato = input.read();
while(dato != -1) {
//hacer algo con el dato
hacerAlgo(dato);
dato = input.read();
}
input.close();

FilterInputStream
Es una clase base para la implementacin de sus propios flujos de entrada de filtrado.
Bsicamente slo anula todos los mtodos de InputSteam. Toma como instancia de
constructor a InputStream.

Subclases:

LineNumberInputStream
Esta clase es un filtro de entrada que proporciona la funcionalidad de mantener un
registro del nmero de lnea actual. Una lnea es una secuencia de bytes que
terminan con un caracter de retorno de carro (\r), un caracter de nueva lnea (\n)
o un carcter de retorno de carro seguido inmediatamente por un carcter de salto
de lnea.
El nmero de lnea comienza en 0 y se incrementa en 1 cuando una lectura
devolver un carcter de nueva lnea.

DataInputStream
Esta clase permite leer los datos primitivos de Java desde InputStream del lugar de
los bytes. Pudiendo usar un InputStream en una clase DataInputStream y as leer los
primitivos de la clase.

Ejemplo:
DataInputStream input = new DataInputStream(
new FileInputStream("binary.data"));
int
int
float
double
//etc.

unByte
= input.read();
unInt
= input.readInt();
uFloat = input.readFloat();
uDouble = input.readDouble();

input.close();

BufferedInputStream
Ofrece un guardado a sus flujos de entrada. El Buffering (guarda un espacio en la
memoria) puede acelerar I/O bastante. En lugar de leer un byte, se lee un bloque
ms grande. Esto suele ser mucho ms rpido, especialmente para el acceso al disco
y grandes cantidades de datos.

PushbackInputStream
Es utilizado para analizar los datos de InputStream. A veces es necesario para leer
los primeros bytes para ver los siguientes, y poder determinar la forma de
interpretar el byte actual. En pocas palabras, te permite empujar hacia atrs los
bytes ledos en el flujo; stos bytes entonces se leern otra vez, en la prxima
llamada a read().

Ejemplo:
PushbackInputStream input = new PushbackInputStream(
new FileInputStream("c:\\dato\\input.txt"));
int dato = input.read();
input.unread(dato);

SequenceInputStream
Combina dos o ms clases InputStream en una sola. En primer lugar todos los bytes del
primer flujo de entrada se iteran y vuelven, luego siguen los bytes del segundo flujo de
entrada.

StringBufferInputStream
Esta clase permite una aplicacin para crear un flujo de entrada en el que la lectura de
bytes son suministrados por el contenido de una cadena. Las solicitudes tambin se
pueden leer los bytes de un arreglo mediante el uso de un ByteArrayInputStream.
Slo los primeros ocho bytes de cada carcter de la cadena se usa en esta clase.

ObjectInputStream
Permite leer objetos Java desde InputStream del lugar de slo bytes. Se puede usar un
InputStream en una clase ObjectInputStream y luego leer los objetos de la misma.

OutputStream
Cada una de estas clases abstractas tienen varias subclases concretas que controlan las
diferencias entre los distintos dispositivos de I/O que se pueden utilizar. As mismo,
estas dos clases son las que definen los mtodos de que sus subclases tendrn
implementados y, entre todas, destacan las clases read() y write() que leen y escriben
bytes de datos respectivamente.

Subclases:

FileOutputStream
Crea un OutputStream para enviar un flujo de bytes a un fichero. Igualmente al
constructor le podemos pasar la ruta completa del archivo o un objeto de tipo File.
Dado que esta operacin es de riesgo, la clase puede lanzar una SecurityException. As
mismo, se pueden lanzar las excepciones IOException y/o FileNotFoundException si,
por ejemplo, el fichero no se puede crear.

PipedOutputStream
La clase PipedOutputStream permite escribir en un canal de Java como un flujo de
bytes.

Ejemplo:
OutputStream output = new PipedOutputStream(pipedInputStream);
while(masDatos) {
int dato = getMasDatos();
output.write(dato);
}
output.close();

FilterOutputStream
Esta clase es la superclase de todas las clases que los flujos de salida del flujo. Estos
flujos se sitan en la parte superior del flujo de salida y existente (la secuencia de salida
subyacente) que utiliza como su disipador de base de datos, pero posiblemente la
transformacin de los datos a lo largo de la forma o proporcionar funcionalidad
adicional.

Subclases:

DataOutputStream
Esta clase hace lo inverso de DataInputStream. Escribe a un flujo de salida de
bytes con alguno de los tipos de datos primitivos de Java.

BufferedOutputStream
Esta clase es similar a OutputStream con la diferencia de que incorpora el mtodo
flush() con el cual aseguramos que los datos en el buffer de salida son
transferidos fsicamente al dispositivo de escritura.

ObjectOutputStream
Permite escribir primitivos de Java para OutputStream del lugar de slo los
bytes. OutputStream es usado en un DataOutputStream y luego se puede escribir
primitivas a la clase.

CHARACTER STREAM
Aunque las clases orientadas al flujo de bytes nos proporcionan la suficiente
funcionalidad para realizar cualquier tipo de operacin de entrada o salida, stas no
pueden trabajar directamente con caracteres Unicode. Es por ello que fue necesaria la
creacin de las clases para el tratamiento de caracteres.
Estas clases nacen de las clases abstractas: Reader y Writer.

Reader
Es una clase abstracta para leer flujos de caracteres. Los nicos mtodos que una
subclase debe implementar son ledos (char[], int, int) y close(). La mayora de las
subclases, sin embargo, tienen prioridad sobre algunos de los mtodos definidos, a fin
de proporcionar una mayor eficiencia, funcionalidad adicional, o ambas cosas.

Subclases:

BufferedReader
Proporciona el almacenamiento en su bufer del Reader. En lugar de leer un carcter, se
lee un bloque ms grande a la vez. Esto suele ser mucho ms rpido, especialmente
para el acceso a grandes cantidades de datos.

Subclase:

LineNumberReader
Aqu un flujo de caracteres de entrada de buffer que mantiene un registro de los
nmeros de lnea. Esta clase define los mtodos setLineNumber(int) y
getLineNumber() para establecer y obtener el nmero de lnea actual,
respectivamente.

CharArrayReader
Esta clase implementa un bfer de caracteres que se puede usar como un flujo de
caracteres de entrada.

InputStreamReader
Esta clase pretende envolver un InputStream, convirtiendo de este modo el flujo de
entrada de bytes basados en un caracter de Reader.

Subclase:

FileReader
Esta clase hace que sea posible leer el contenido de un archivo como una
consecuencia de caracteres. Funciona como la clase FileInputStream excepto que
el FileInputStream lee bytes, mientras que el FileReader lee caracteres.

FilterReader
Es una clase base para la implementacin de sus propios lectores de filtrado.
Bsicamente solo anula todos los mtodos de Reader.

Subclase:

PushbackReader
Un lector de caracteres del flujo que permite a los caracteres para ser empujado
de nuevo en el flujo.

PipedReader
La clase PipedReader hace que sea posible leer el contenido de un canal como una
consecuencia de caracteres. Como tal, funciona muy parecido a un PipedInputStream
excepto que PipedInputStream se basa en bytes y no en caracteres. En otras palabras, el
PipedReader est destinado a leer el texto.

StringReader
La clase StringReader permite convertir una cadena ordinaria en un lector.

Writer
Es una clase abstracta que escribe flujo de caracteres. Los nicos mtodos que una
subclase puede implementar son write(char[], int, int), flush() y close(). La mayora de
subclases, sin embargo, tienen prioridad sobre algunos de los mtodos definidos
proporcionan una mayor eficiencia, funcionalidad adicional, o ambas cosas.

Subclases:

BufferedWriter
Esta clase ofrece almacenamiento en un bfer del Writer. En lugar de escribir un
carcter a la vez, se escribe un bloque ms grande. Esto suele ser mucho ms rpido,
especialmente para el acceso a discos y grandes cantidades de datos.

CharArrayWriter
Esta clase implementa un bfer de caracteres que se puede utilizar como un escritor. El
bfer crece automticamente cuando los datos se escriben en la secuencia. Los datos
pueden ser recuperados utilizando ToCharArray() y toString().

OutputStreamWriter
La clase OutputStreamWriter pretender usar un OutputStream, convirtiendo de este
modo el flujo de salida de bytes basados en un carcter.

Subclase:

FileWriter
Permite escribir un archivo como una secuencia de caracteres. En ese sentido,
funciona de manera similar al FileOutputStream excepto que ste se basa en un
carcter. En otras palabras, est destinado a escribir solo texto.

FilterWriter
Clase abstracta para escribir secuencias de caracteres filtrados. El propio FilterWriter
proporciona mtodos predeterminados que pasan todas las solicitudes a la corriente
contenida.

PipedWriter
La clase PipedWriter permite escribir en un canal a Java como una secuencia de
caracteres. En ese sentido, el PipedWriter funciona como una clase PipedOutputStream
excepto que, se basa en caracteres.

10

StringWriter
Un flujo de caracteres que recoge su salida en un bfer de cadena, que luego se puede
utilizar para construir una cadena. Cerrar una StringWriter no tiene ningn efecto. Los
mtodos de esta clase se puede llamar despus de que flujo se ha cerrado sin que
genere una excepcin I/O.

PrintWriter
La clase PrintWriter le permite escribir datos formateados a un Writer subyacente. Por
ejemplo, escribiendo int, long, y otros datos primitivos con formato de texto, y no como
sus valores de bytes.

11

BIBLIOGRAFIA
http://www.slideshare.net/tacksuo/flujos-de-bytes-ycadenas?fb_action_ids=653385838065945&fb_action_types=slideshare%3Adownload
Tomado el 07.05.2014.

http://tutorials.jenkov.com/java-io/
Tomado el 07.05.2014

http://docs.oracle.com/javase/7/docs/api/java/io/PrintWriter.html
Tomado el 07.05.2014

12