0

ARCHIVOS DE ACCESO SECUENCIAL

Alumno: Villarroel Cruzado, José Wilson Helí

TECNOLOGÍA DE LA

PROGRAMACIÓN II

1

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

2

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

3

INTRODUCCIO N

Cualquier programa realizado en Java que necesite llevar a cabo una operación de I/O

lo hará a través de un stream. Un stream, cuya traducción literal es “flujo”, es una

abstracción de todo aquello que produzca o consuma información.

Podemos ver este stream como una entidad lógica. La vinculación de este stream al

dispositivo físico la hace el sistema de entrada y salida de Java. Se ve pues la eficacia de

esta implementación pues la clases y métodos y I/O que necesitamos emplear son las

mismas independientemente del dispositivo con el que estemos actuando, luego, el

núcleo de Java, sabrá si tiene que tratar con el teclado, el monitor, un sistema de

ficheros o un socket de red liberando a nuestro código de tener quien saber con quién

está interactuando.

BYTE STREAMS

Nos proporciona un medio adecuado para el manejo de entrada y salidas de bytes y su

uso lógicamente 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 métodos que sus subclases tendrán

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 método 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();

4

Subclases:

FileInputStream Define varios constructores de los cuales destacan el que le pasamos como un

parámetro 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 excepción

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 implementación de sus propios flujos de entrada de filtrado.

Básicamente sólo anula todos los métodos de InputSteam. Toma como instancia de

constructor a InputStream.

5

Subclases:

LineNumberInputStream Esta clase es un filtro de entrada que proporciona la funcionalidad de mantener un

registro del número de línea actual. Una línea es una secuencia de bytes que

terminan con un caracter de retorno de carro (‘\r’), un caracter de nueva línea (‘\n’)

o un carácter de retorno de carro seguido inmediatamente por un carácter de salto

de línea.

El número de línea comienza en 0 y se incrementa en 1 cuando una lectura

devolverá un carácter de nueva línea.

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 unByte = input.read(); int unInt = input.readInt(); float uFloat = input.readFloat(); double uDouble = input.readDouble(); //etc. 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

más grande. Esto suele ser mucho más rápido, 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 atrás los

bytes leídos en el flujo; éstos bytes entonces se leerán otra vez, en la próxima

llamada a read().

6

Ejemplo:

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

SequenceInputStream Combina dos o más 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 aplicación para crear un flujo de entrada en el que la lectura de

bytes son suministrados por el contenido de una cadena. Las solicitudes también se

pueden leer los bytes de un arreglo mediante el uso de un ByteArrayInputStream.

Sólo los primeros ocho bytes de cada carácter de la cadena se usa en esta clase.

ObjectInputStream Permite leer objetos Java desde InputStream del lugar de sólo 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 métodos de que sus subclases tendrán

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 operación 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.

7

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 sitúan 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

transformación 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 método

flush() con el cual aseguramos que los datos en el buffer de salida son

transferidos físicamente al dispositivo de escritura.

ObjectOutputStream Permite escribir primitivos de Java para OutputStream del lugar de sólo los

bytes. OutputStream es usado en un DataOutputStream y luego se puede escribir

primitivas a la clase.

8

CHARACTER STREAM

Aunque las clases orientadas al flujo de bytes nos proporcionan la suficiente

funcionalidad para realizar cualquier tipo de operación de entrada o salida, éstas no

pueden trabajar directamente con caracteres Unicode. Es por ello que fue necesaria la

creación 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 métodos que una

subclase debe implementar son leídos (char[], int, int) y close(). La mayoría de las

subclases, sin embargo, tienen prioridad sobre algunos de los métodos 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 carácter, se

lee un bloque más grande a la vez. Esto suele ser mucho más rápido, 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

números de línea. Esta clase define los métodos setLineNumber(int) y

getLineNumber() para establecer y obtener el número de línea actual,

respectivamente.

CharArrayReader Esta clase implementa un búfer 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.

9

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 implementación de sus propios lectores de filtrado.

Básicamente solo anula todos los métodos 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.

10

Writer Es una clase abstracta que escribe flujo de caracteres. Los únicos métodos que una

subclase puede implementar son write(char[], int, int), flush() y close(). La mayoría de

subclases, sin embargo, tienen prioridad sobre algunos de los métodos definidos

proporcionan una mayor eficiencia, funcionalidad adicional, o ambas cosas.

Subclases:

BufferedWriter Esta clase ofrece almacenamiento en un búfer del Writer. En lugar de escribir un

carácter a la vez, se escribe un bloque más grande. Esto suele ser mucho más rápido,

especialmente para el acceso a discos y grandes cantidades de datos.

CharArrayWriter Esta clase implementa un búfer de caracteres que se puede utilizar como un escritor. El

búfer crece automáticamente 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 carácter.

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

carácter. En otras palabras, está destinado a escribir solo texto.

FilterWriter Clase abstracta para escribir secuencias de caracteres filtrados. El propio FilterWriter

proporciona métodos 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.

11

StringWriter Un flujo de caracteres que recoge su salida en un búfer de cadena, que luego se puede

utilizar para construir una cadena. Cerrar una StringWriter no tiene ningún efecto. Los

métodos de esta clase se puede llamar después de que flujo se ha cerrado sin que

genere una excepción 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.

12

BIBLIOGRAFI A

http://www.slideshare.net/tacksuo/flujos-de-bytes-y-

cadenas?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