Download Transparencias del Tema 15: Entrada/Salida

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
–
–
•
Los flujos de bytes
–
–
–
•
•
Unicode (16 bits).
Texto (caracteres legibles como código fuente …).
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
OutputStream
ObjectOutputStream
ByteArrayOutputStream
PipedOutputStream
FileOutputStream
FilterOutputStream
DataOutputStream
BufferedOutputStream
PrintStream
ObjectInput
InputStream
ObjectInputStream
SequenceInputStream
ByteArrayInputStream
PipedInputStream
FileInputStream
FilterInputStream
DataInputStream
BufferedInputStream
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,
transformando un valor particular en otro.
Con valores proporcionados desde linea de comandos.
*/
package InputOutput;
import java.io.IOException;
public class Ejemplo2{
public static void main(String args[]){
try{
byte desde = (byte)args[0].charAt(0);
byte hacia = (byte)args[1].charAt(0);
int b = 0;
Ejemplo
>java InputOutput.Ejemplo2 a b
aaaaaaaaaaaaaaaaaaaaaaaa
bbbbbbbbbbbbbbbbbbbbbbbb
fjfjfjfjfjsjsjsjajaaaaa
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
BufferedWriter
CharArrayWriter
FilterWriter
PipedWriter
StringWriter
OutputStreamWriter
FileWriter
PrintWriter
Reader
BufferedReader
LineNumberReader
CharArrayReader
FilterReader
PushbackReader
PipedReader
StringReader
InputStreamReader
FileReader
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
import
import
import
import
java.io.IOException;
java.io.InputStreamReader;
java.io.FileReader;
java.io.FileNotFoundException;
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;
import
import
import
import
C:\F_Telematica\Texto\Tema15>
java.io.IOException;
java.io.FileReader;
java.io.LineNumberReader;
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
import
import
import
java.io.IOException;
java.io.FileInputStream;
java.io.PushbackInputStream;
java.io.FileNotFoundException ;
public class Ejemplo5{
public static void main(String args[]){
int max = 0; /*Secuencia más larga encontrada*/
int b;
/*byte actual de la secuencia*/
int cnt, b1, maxB = -1;
FileInputStream input = null;
PushbackInputStream in = null;
/*busca la secuencia de caracteres iguales
más largos*/
>java InputOutput.Ejemplo5 Entrada.txt
43 veces de f
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