1. Entrada y salida de datos
• Intercambio de datos entre el programa y el exterior
• Diversidad de dispositivos (fichero, pantalla, red, …)
• Diversidad de formas de comunicación
❏ Modo de acceso: secuencial, aleatorio
❏ Información intercambiada: binaria, caracteres, líneas
Entrada y salida de datos • Flujo (Stream)
• Abstracción de cualquier fuente y/o destino de datos
Flujo (stream)
Fuente Datos Datos Destino
Java Entrada y Salida 1 Java Entrada y Salida 2
Flujos estándar Operación y flujos estándar en java
• Los programas se comunican con flujos y estos flujos • Lectura y escritura
actúan como interfaz con el dispositivo o clase asociada Lectura Escritura
• Operación independiente del tipo de datos y del dispositivo Abrir un flujo Abrir un flujo
Mientras existan datos disponibles
Mientras existan datos disponibles
• Mayor flexibilidad (p.e. redirección, combinación) Leer datos Escribir datos
Cerrar el flujo
• Flujos estándar Cerrar el flujo
• Entrada estándar - habitualmente el teclado • Java tiene acceso a la entrada/salida estándar a través de
• Salida estándar - habitualmente la pantalla la clase java.lang.System
• Salida de error - habitualmente la pantalla • Los flujos estándar son campos estáticos de System
• Flujos
Dispositivo Dispositivo
Flujo entrada Flujo salida ❏ System.in implementa la entrada estándar
de entrada Programa de salida
(teclado)
Datos Datos
(pantalla, disco) ❏ System.out implementa la salida estándar
❏ System.err implementa la salida de error
Java Entrada y Salida 3 Java Entrada y Salida 4

2. Lectura y escritura en los flujos estándar Ejemplo - uso flujos estándar
• Los flujos se implementan en las clases del paquete java.io import java.io.*;
• System.out
class LecturaDeLinea {
• Instancia de la clase PrintStream - flujo de bytes de salida public static void main( String args[] ) throws IOException {
• Metodos de utilidad - impresión de datos int c;
❏ print(), println() int contador = 0;
❏ flush() vacía el buffer de salida escribiendo su contenido // se lee hasta encontrar el fin de línea
while( (c = System.in.read() ) != 'n' )
• System.in {
• Instancia de la clase InputStream - flujo de bytes de entrada contador++;
System.out.print( (char) c );
• Metodos }
❏ read() permite leer un byte de la entrada como entero System.out.println(); // Se escribe el cambio de línea
❏ skip(n ) ignora n bytes de la entrada System.err.println( "Contados "+ contador +" bytes en total." );
❏ available() número de bytes disponibles para leer en la entrada
}
• System.err - Funcionamiento similar a System.out }
Java Entrada y Salida 5 Java Entrada y Salida 6
Clasificación de flujos Paquete java.io - Flujos de caracteres
• Representación de la información
❏ Flujos de bytes
❏ Flujos de caracteres
• Propósito
❏ Entrada - (InputStream, Reader)
❏ Salida - (OutputStream, Writer)
❏ Entrada/Salida - (RandomAccessFile)
• Acceso
❏ Secuencial
❏ Directo o aleatorio - (RandomAccessFile)
• Por operación
❏ Transferencia de datos
❏ Transformación de los datos
Realizan algún tipo de procesamiento sobre los datos (p.e. buffering, conversiones, filtrados)
Java Entrada y Salida 7 Java Entrada y Salida 8

3. Paquete java.io - Flujos de bytes Paquete java.io
• InputStreamReader
• Lee bytes de un flujo InputStream y los convierte en caracteres
Unicode
• Métodos de utilidad
❏ read () lee un único caracter
❏ ready() indica cuando está listo el flujo para lectura
• BufferedReader
• Entrada mediante búfer, mejora el rendimiento
• Método de utilidad
❏ readLine() lectura de una línea como cadena
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader Teclado = new BufferedReader (isr);
String cadena = Teclado.readLine();
Java Entrada y Salida 9 Java Entrada y Salida 10
Combinación de flujos Ejemplo - combinación de flujos
• Los flujos se pueden combinar para obtener la
funcionalidad deseada import java.io.*;
class Eco {
public static void main (String[] args) throws IOException
InputStream InputStreamReader BufferedReader
{
BufferedReader entradaEstandar = new BufferedReader
Programa (new InputStreamReader(System.in));
Lee bytes y los pasa Utiliza un búfer para String mensaje;
Lee bytes
a caracteres Unicode mejorar eficiencia
de lectura de carateres System.out.println (”Introducir una linea de texto:");
mensaje = entradaEstandar.readLine();
System.out.println (”Introducido: "" + mensaje + """);
}
Flujos de transformación de datos }
Java Entrada y Salida 11 Java Entrada y Salida 12

4. La clase Teclado -- Javadoc La clase Teclado
package es.ucm.esi; // continuación de la clase teclado
import java.io.*; /** lee un numero entero desde la entrada estandar
/** * @return numero entero de tipo int
* <p><p> La clase <em>Teclado</em> permite hacer transparente la lectura sencilla * @exception excepciones No lanza ningun tipo de excepcion de estrada/salida
* de los tipos mas comunes de datos desde la entrada estandar */
*/ public static int leerInt() {
public class Teclado { int entero = 0;
/** variable de clase asignada a la entrada estandar del sistema */ boolean error = false;
public static BufferedReader entrada = do {
new BufferedReader(new InputStreamReader(System.in)); try {
error = false;
/** lee una cadena desde la entrada estandar entero = Integer.valueOf(entrada.readLine()).intValue();
* @return cadena de tipo String }catch (NumberFormatException e1) {
* @exception excepciones No lanza ningun tipo de excepcion de estrada/salida error = true;
*/ System.out.println("Error en el formato del numero, intentelo de nuevo.");
public static String leerString() { }catch (IOException e) {
String cadena=""; System.out.println("Error de E/S");}
try { } while (error);
cadena = new String(entrada.readLine()); return entero;
}catch (IOException e) { }
System.out.println("Error de E/S"); } } // final de la clase Teclado
return cadena; } // la clase Teclado continua
Java Entrada y Salida 13 Java Entrada y Salida 14
Java 1.1 - Ficheros de texto Java 1.1- Ejemplo Ficheros de texto
• FileReader import java.io.*;
public class FicheroTexto {
• Util para leer ficheros de texto public static void main(String args[]) {
❏ Constructor: FileReader(String nombreFichero) try { // escritura de datos
• FileWriter PrintWriter salida = new PrintWriter( new BufferedWriter(
new FileWriter("prueba.txt")));
• Util para escribir ficheros de texto salida.println("en un lugar de la mancha de cuyo");
• Constructores salida.println("nombre no quiero acordarme");
salida.close();
❏ FileWriter(String nombreFichero) -- reescribe // lectura de datos
❏ FileWriter(String nombreFichero, boolean añadirFinal) -- añade BufferedReader entrada =new BufferedReader(new FileReader("prueba.txt"));
• PrintWriter String s, s2 = new String();
while((s = entrada.readLine())!= null)
• Implementa un flujo de salida de caracteres s2 = s2 + s + "n";
• Métodos de utilidad System.out.println("Texto leido:" + "n" + s2);
entrada.close();
❏ print(), println(), close() } catch (java.io.IOException e) {}
}}
Java Entrada y Salida 15 Java Entrada y Salida 16

5. Ficheros de texto con datos numéricos Ficheros
import java.io.*;
public class FicheroTexto { • Clase File
public static void main(String args[]) {
int i=5; • Constructores
float f=5.5f; ❏ File(String ruta)
try { // escritura de datos
PrintWriter salida = new PrintWriter( new BufferedWriter( ❏ File(String ruta, String nombre)
new FileWriter("hola.txt"))); ❏ File(File directorio, String nombre)
salida.println("en un lugar de la mancha de cuyo");
salida.println(i); • Métodos
salida.println("nombre no quiero acordarme"); ❏ canRead() comprueba si el fichero se puede leer
salida.println(f);
salida.close(); ❏ canWrite() comprueba siel fichero se puede escribir
// lectura de datos ❏ delete() borra dicho fichero
BufferedReader entrada =new BufferedReader(new FileReader("hola.txt"));
❏ getPath() devuelve la ruta del fichero
String s, s2 = new String();
while((s = entrada.readLine())!= null) ❏ mkdir() crea un directorio con la ruta del objeto que lo recibe
s2 = s2 + s + "n"; ❏ isDirectory() comprueba si dicho fichero es un directorio
System.out.println("Texto leido:" + "n" + s2);
entrada.close(); • Constructores de otras clases
} catch (java.io.IOException e) {System.out.println("excepcion");}
}} ❏ FileReader(File fichero)
❏ FileWriter(File fichero)
Java Entrada y Salida 17 Java Entrada y Salida 18
Ejemplo - copia de ficheros Serialización de objetos
import java.io.*; • Serializar es almacenar objetos de forma permanente (p.e.
public class CopiaFicheros {
en un fichero o en un flujo de comunicación)
public static void main(String[] args) throws IOException { • No es necesario realizar conversiones
File ficheroEntrada = new File("original.txt");
File ficheroSalida = new File("copia.txt"); • Útil para portabilidad y para compartir objetos entre
aplicaciones
FileReader entrada = new FileReader(ficheroEntrada);
FileWriter salida = new FileWriter(ficheroSalida); • Flujos
int dato; • Clase ObjectOuputStream
❏ Método - writeObject()
while ((dato = entrada.read()) != -1)
❏ Ejemplo: flujoSalida.writeObjetct (objetoClase);
salida.write(dato);
• Clase ObjectInputStream
entrada.close(); ❏ Método - readObject()
salida.close(); ❏ Ejemplo: objetoClase = (Clase) flujoEntrada.readObject();
}
}
Java Entrada y Salida 19 Java Entrada y Salida 20

6. Interfaz de serialización Serialización: ejemplo
import java.io.*;
• Cualquier clase que desee poder serializar sus objetos public class Punto implements Serializable {
debe implementar el interfaz Serializable int x; int y;
public Punto(int x, int y) { this.x = x; this.y = y;}
• En esta implementación el objeto define como debe public String toString() { return “Punto[“ + x + ”,” + y + ”]”; }
almacenarse o recuperarse de un fichero
public class AplicacionSerializacion {
• Si se trata de serializar un objeto que no lo implementa se
obtiene la excepción NotSerializableException public static void main(String args[]) throws IOException, ClassNotFoundException {
Punto punto = new Punto(1, 5);
• No se serializan los miembros static o transient ObjectOutputStream ficheroObjetosSal = new ObjectOutputStream(
• Las clases que necesiten algún tratamiento especial en la new FileOutputStream("temp"));
ficheroObjetosSal.writeObject(punto);
serialización deben implementar estos dos métodos ficheroObjetosSal.close();
private void writeObject (java.io.ObjectOutputStream salida)
throws IOException ObjectInputStream ficheroObjetosEnt = new ObjectInputStream(
new FileInputStream("temp"));
private void readObject (java.io.ObjectInputStream entrada) Punto punt = (Punto) ficheroObjetosEnt.readObject();
throws IOException, ClassNotFoundException; ficheroObjetosEnt.close();
System.out.println( punt );}}
Java Entrada y Salida 21 Java Entrada y Salida 22
Serialización: ejemplo particularización
import java.io.*;
public class Punto implements Serializable {
int x; int y;
java.util.Date fecha; // fecha de creación del objeto
public Punto(int x, int y) {this.x= x; this.y= y; fecha= new java.util.Date();}
public String toString() {return "Punto[" + x + "," + y + "];" + fecha;}
private void writeObject (ObjectOutputStream salida)
throws IOException {
salida.writeInt(x);
salida.writeInt(y); // no se almacena la fecha de creación
}
private void readObject (ObjectInputStream entrada)
throws IOException, ClassNotFoundException {
x= entrada.readInt();
y = entrada.readInt();
fecha= new java.util.Date(); // se construye la fecha de creación
}}
Java Entrada y Salida 23