Tema 15: Entrada/Salida

Antonio J. Sierra
 Índice
1. Introducción. Flujos.
2. Estructura y clases del paquete java.io
 Introducción
• El paquete java.io define la Entrada/Salida
en términos de stream (o flujos).
• Un flujo es una secuencia ordenada de datos que
contienen fuente/destino.
• Los flujos son abstracciones que producen o
consumen información.
– Relacionado con un dispositivo físico.
– Mismas clases y métodos de E/S a cualquier
dispositivo físico.
• Abstrae de los detalles del Sistema Operativo.
 Clasificación de los flujos
• Hay dos tipos de flujos: de caracteres y de bytes.
• Los flujos de caracteres
– Unicode (16 bits).
– Texto (caracteres legibles como código fuente …).
• Los flujos de bytes
– byte (8 bits).
– Datos binarios (imagen, …).
– No transportan adecuadamente los caracteres.
• Casi todo flujo de entrada tiene su correspondiente de
salida.
• La mayoría de flujos de caracteres tiene su equivalente
de byte.
 Clases del paquete java.io
• Consta de clases generales con una
clasificación de bytes y caracteres.
• Lectura/Escritura de valores primitivos y
cadenas de texto.
• Clases e interfaces para interactuar con
archivos.
• Serialización de objetos.
• Excepciones: IOException.
 Clasificación de los flujos
• Filter: Operaciones de filtrado y construcción filtros encadenados.
• Buffered: No necesitan acceder al sistema de archivos en cada
invocación.
• Piped: Diseñados por parejas.
• ByteArray: usan una matriz de bytes.
• CharArray: usan una matriz de chars.
• String:usan una cadena de caracteres.
• Print: impresión en formato legible.
• LineNumberReader: cuenta líneas.
• SequenceInputStream: da un flujo de varios.
• Pushback: envía datos de retorno.
• StreamTokenizer: divide un flujo en tokens.
 Flujos de bytes
• Clases Abstractas
– InputStream
• Métodos para leer bytes.
• Es superclase de la mayoría de bytes de entrada.
– OutputStream
• Análoga a InputStream.
• Proporciona métodos para escribir en un destino.
DataOutput DataInput

ObjectOutput ObjectInput

OutputStream InputStream

ObjectOutputStream ObjectInputStream
ByteArrayOutputStream SequenceInputStream
ByteArrayInputStream
PipedOutputStream
PipedInputStream
FileOutputStream
FileInputStream
FilterOutputStream FilterInputStream

DataOutputStream DataInputStream
BufferedInputStream
BufferedOutputStream
PrintStream PushbackInputStream
/* Recuenta el numero de bytes de un fichero.
Se proporciona el nombre como argumento en
linea de comandos. Sino se proporciona fichero se lee
de la entrada estándar (System.in) */
package InputOutput;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Ejemplo1{

public static void main(String args[]){
InputStream in = null;
int total = 0;
try{
if(args.length == 0){
in = System.in;
}else{
in = new FileInputStream(args[0]);
}
while( in.read() != -1)
total++;
in.close();
System.out.println(total);
}catch(FileNotFoundException e){
System.out.println("fichero no encontrado "+e);
}catch(IOException e){
System.out.println(e);
}
}
}
/*
Programa que copia su entrada en su salida,

Ejemplo
transformando un valor particular en otro.
Con valores proporcionados desde linea de comandos.
*/
package InputOutput;
import java.io.IOException; >java InputOutput.Ejemplo2 a b
aaaaaaaaaaaaaaaaaaaaaaaa
public class Ejemplo2{ bbbbbbbbbbbbbbbbbbbbbbbb
public static void main(String args[]){
try{
byte desde = (byte)args[0].charAt(0);
byte hacia = (byte)args[1].charAt(0);
fjfjfjfjfjsjsjsjajaaaaa
int b = 0; fjfjfjfjfjsjsjsjbjbbbbb
^Z
while( (b = System.in.read()) != -1)
System.out.write( (b == desde) ? hacia : b);
}catch(IOException e){
System.out.println(e);
}catch(IndexOutOfBoundsException e){
System.out.println(e);
}
}
}
 Flujos de caracters
• Clases abstractas Reader y Writer.
– Métodos similares a InputStream y
OutputStream.
• Se diseñaron después de los flujos de bytes
– Dan soporte a las operaciones con caracteres
Unicode.
 Writer Reader

BufferedWriter BufferedReader
LineNumberReader
CharArrayWriter
CharArrayReader
FilterWriter FilterReader
PipedWriter PushbackReader
PipedReader
StringWriter
OutputStreamWriter StringReader
InputStreamReader
FileWriter
FileReader
PrintWriter
 OutputStreamWriter y
InputStreamReader
• Realizan conversión entre flujos Unicode y flujos de bytes
usando una codificación (o una por defecto).
• InputStreamReader, recibe bytes y produce
caracteres Unicode.
• OutputStreamWriter, recibe caracteres y bytes.
• Por defecto, usan la codificación de la plataforma.
• FileReader y FileWriter son subclases
– Ayudan a la lectura y escritura de archivos locales usando la
codificación Unicode.
• No existen ReaderInputStream ni
WriterOutputStream.
package InputOutput;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.Reader;

public class Ejemplo3{

public static void main(String args[]){
Reader in = null;
int cr = 0;
int total = 0;
int espacio = 0;
try{

if( args.length == 0){

in = new InputStreamReader(System.in);
}else{
in = new FileReader(args[0]);
}
for(total = 0; (cr = in.read()) != -1 ; total++){
if(Character.isWhitespace((char)cr))
espacio++;
}
in.close();
System.out.println(total + " caracteres, " + espacio + " espacios");
}catch(FileNotFoundException e){
System.out.println(e);
}catch(IOException e){
System.out.println(e);
}
}
}
 Filter
• FilterInputStream FilterOutputStream
FilterReader FilterWriter.
• Los flujos de entrada contienen algún otro flujo de entrada
que se usa como fuente de datos básica, posiblemente
transformando los datos o proporcionando funcionalidades
adicionales.
• FilterInputStream por sí sobreescribe todos los
métodos de InputStream.
• Las subclases deberían sobreescribir algunos de estos
métodos y podrían proporcionar métodos y campos
adicionales.
 ByteArray, CharArray y
String
• Uso de array de bytes(char) o String como
fuente o destino de los flujos.
• ByteArrayInputStream
• ByteArrayOutputStream
• CharArrayReader
• CharArrayWriter
• StringReader
• StringWriter
 Print
• PrintStream añade funcionalidades para
otro flujo de salida, para imprimir la
representación de varios valores de datos de
forma apropiada.
• PrintWriter imprime representaciones
formateadas de objetos para flujos de salida
de texto.
 Buffered
• Almacena los datos en un bufer.
• BufferedInputStream, BufferedOutputStream,
BufferedReader y BufferedWriter.
• BufferedInputStream añade funcionalidades para otro flujo
entrada, la habilidad para buferar la entrada y para soporta mark y los
métodos de reset.
• BufferedOutputStream. Esta clase implementa un flujo de
salida buferado.
• BufferedReader lee texto de un flujo de caracteres de entrada,
buferando los caracteres para proporcionar una lectura eficiente de los
caracteres, arrays y líneas.
• BufferedWriter escribe texto para un flujo de salida de
caracteres, buferando los caracteres para proporcionar una escritura
eficiente de un solo caracteres, array y cadenas.
 Piped
• PipedInputStream, PipedOutputStream,
PipedReader y PipedWriter.
• PipedInputStream un flujo de entrada conducido
debería conectarse a un flujo de salida conducido. El flujo de
entrada proporciona bytes de datos que son escritos en un
flujo de salida conducido.
• PipedOutputStream es un flujo de salida conectado a
su correspondiente de entrada para crear un conducto de
comunicación.
• PipedReader es un flujo de entrada de caracteres
conducidos.
• PipedWriter es un flujo de caracteres de salida
conducido
 LineNumberReader
• Es un flujo de entrada de caracteres buferados que
mantiene el número de líneas.
• Esta clase define los métodos void
setLineNumber(int) y int getLineNumber()
para configurar y obtener la línea actual respectivamente.
• Por defecto, la línea comienza en 0. Este número se
incrementa al leer y puede modificarse con
setLineNumber(int).
• Se considera que una línea termina mediante el carácter
nueva línea ('\n'), un retorno de carro ('\r'), o un retorno
de carro seguido inmediatamente de un ('\n').
 /* Este programa imprime el número de línea cuando se encuentra un carácter especificado */
C:\F_Telematica\Texto\Tema15>java InputOutput.Ejemplo4 i .\InputOutput\Entrada.txt
'i 'en linea 2
package InputOutput;
C:\F_Telematica\Texto\Tema15>
import java.io.IOException;
import java.io.FileReader;
import java.io.LineNumberReader;
import java.io.FileNotFoundException ;

public class Ejemplo4{

public static void main(String args[]){

if( args.length != 2){

throw new IllegalArgumentException("Son necesarios dos argumentos");
}
try{
int igual = args[0].charAt(0);
FileReader archivoEn = new FileReader (args[1]);
LineNumberReader in = new LineNumberReader(archivoEn);
int cr;
boolean seguir = true;

while((cr = in.read()) != -1 && seguir){

if(cr == igual){
System.out.println("'" + (char)cr
+" 'en linea "+ in.getLineNumber());
seguir = false;
}
}
in.close();
if(seguir)
System.out.println("No encontrado");

}catch(FileNotFoundException e){
System.out.println(e);
}catch(IOException e){
System.out.println(e);
}
}
}
 Pushback
• Permite enviar de vuelta caracteres después de leerlos.
• Métodos:
– void unread(char[] cbuf)
– void unread(char[] cbuf, int off, int len)
– void unread(int c)
package InputOutput;

import java.io.IOException;
import java.io.FileInputStream;
import java.io.PushbackInputStream;
import java.io.FileNotFoundException ;
/*busca la secuencia de caracteres iguales
public class Ejemplo5{
public static void main(String args[]){ más largos*/
int max = 0; /*Secuencia más larga encontrada*/
int b; /*byte actual de la secuencia*/
>java InputOutput.Ejemplo5 Entrada.txt
int cnt, b1, maxB = -1;
FileInputStream input = null;
43 veces de f
PushbackInputStream in = null;

try{
input = new FileInputStream(args[0]);
in = new PushbackInputStream( input );
do{
b1 = in.read();
for(cnt = 1 ; (b = in.read()) == b1; )
cnt++;
if( cnt > max ){
max = cnt;
maxB = b1;
}
in.unread(b); /*devuelve el byte al flujo*/
}while(b != -1);

input.close();
in.close();
System.out.println(max + " veces de "+ (char)maxB);
}catch(FileNotFoundException e){
System.out.println(e);
}catch(IOException e){
System.out.println(e);
}
}
}
 DataInput y DataOutput
• Los flujos Data soportan entrada/salida
binaria de los tipos de datos primitivos
(boolean, char, byte, short,
int, long, float, y double) así
como para los String.
• Todos estos flujos implementan las
interfaces DataInput o DataOutput,
para la entrada y salida respectivamente.
 Ejemplo
• Primero, el programa define algunos valores:
static final String dataFile = "invoicedata";

static final double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 };

static final int[] units = { 12, 8, 13, 29, 50 };
static final String[] descs = { "Java T-shirt",
"Java Mug",
"Duke Juggling Dolls",
"Java Pin",
"Java Key Chain" };
• Luego se abre un flujo de salida. Ya que un DataOutputStream puede sólo crearse como una envolvente para un
flujo existente.
out = new DataOutputStream(new
BufferedOutputStream(new FileOutputStream(dataFile)));

• Se escribe en el flujo de salida.

for (int i = 0; i < prices.length; i ++) {
out.writeDouble(prices[i]);
out.writeInt(units[i]);
out.writeUTF(descs[i]);
}
 File
• FileInputStream, FileOutputStream,
FileReader y FileWriter.
• FileInputStream obtiene bytes de entrada de un
fichero en un sistema de ficheros.
• FileOutputStream, es un flujo de salida para escribir
datos a un File o a un FileDescriptor.
• FileReader, clase para leer ficheros de caracteres.
• FileWriter, clase para escribir ficheros de caracteres.
 RandomAccessFile
• Son archivos de acceso aleatorio.
– Se comporta como un gran array de bytes almacenados
en el sistema de archivos.
– Con un puntero de archivo.
– Leen bytes desde donde indican el punterio y lo dejan
donde acaba
– Pueden ser de lectura y escritura.
• No es subclase de InputStream,
OutputStream, Reader y
Writer.
 Serialización
• Transforma un objeto en un flujo de datos, con la
posibilidad de reconstruirlo posteriormente el objeto.
• Uso: transferencia en la red, guardar en una Base de Datos
• Clases e interfaces asociadas:
– Serializable
– ObjectOutputStream
– ObjectInputStream
– ObjectOutput
– ObjectInput
– Externalizable