Tema 15: Entrada/Salida

1. Tema 15: Entrada/Salida Antonio J. Sierra

2. Índice 1. Introducción. Flujos. 2. Estructura y clases del paquete java.io

3. 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.

4. 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.

5. 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.

6. 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.

7. 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.

8. DataOutput DataInput ObjectInput ObjectOutput OutputStream InputStream ObjectInputStream ObjectOutputStream SequenceInputStream ByteArrayOutputStream ByteArrayInputStream PipedOutputStream PipedInputStream FileOutputStream FileInputStream FilterOutputStream FilterInputStream DataInputStream DataOutputStream BufferedInputStream BufferedOutputStream PushbackInputStream PrintStream

9. /* 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); } } }

10. Ejemplo>java InputOutput.Ejemplo2 a baaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbfjfjfjfjfjsjsjsjajaaaaafjfjfjfjfjsjsjsjbjbbbbb^Z /* 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; 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); } } }

11. 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.

12. Writer Reader BufferedReader BufferedWriter LineNumberReader CharArrayWriter CharArrayReader FilterReader FilterWriter PushbackReader PipedWriter PipedReader StringWriter StringReader OutputStreamWriter InputStreamReader FileWriter FileReader PrintWriter

13. 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.

14. 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); } } }

15. 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.

16. 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

17. 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.

18. 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.

19. Piped • PipedInputStream, PipedOutputStream, PipedReadery 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

20. 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').

21. /* 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 C:\F_Telematica\Texto\Tema15> package InputOutput; 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); } } }

22. 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)

23. /*busca la secuencia de caracteres iguales más largos*/>java InputOutput.Ejemplo5 Entrada.txt43 veces de f package InputOutput; import java.io.IOException; import java.io.FileInputStream; import java.io.PushbackInputStream; import 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; 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); } } }

24. 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 DataInputo DataOutput, para la entrada y salida respectivamente.

25. 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]); }

26. 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.

27. 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.

28. 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