Anda di halaman 1dari 7

Entrada y salida de datos

Intercambio de datos entre el programa y el


Entrada y salida de datos exterior
n Diversidad de dispositivos (fichero, pantalla, red,
…)
n Diversidad de formas de comunicación
w Modo de acceso: secuencial, aleatorio
w Información intercambiada: binaria, caracteres, líneas
Flujo (Stream)
n 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 Flujos estándar


Los programas se comunican con flujos y
estos flujos actúan como interfaz con el Flujos estándar
dispositivo o clase asociada n Entrada estándar - habitualmente el
n Operación independiente del tipo de datos y del teclado
dispositivo n Salida estándar - habitualmente la pantalla
n Mayor flexibilidad (p.e. redirección, combinación) n Salida de error - habitualmente la pantalla

Dispositivo Flujo entrada Flujo salida Dispositivo


de entrada Programa de salida
Datos Datos
(teclado) (pantalla, disco)

Java Entrada y Salida 3 Java Entrada y Salida 4

Operación y flujos estándar en Operación y flujos estándar en


java java
Lectura y escritura Java tiene acceso a la entrada/salida
estándar a través de la clase
java.lang.System
Los flujos estándar son campos estáticos de
Lectura Escritura
n
Abrir un flujo
Abrir un flujo
Mientras existan datos disponibles System
Mientras existan datos disponibles
Leer datos Escribir datos n Flujos
Cerrar el flujo
Cerrar el flujo w System.in implementa la entrada estándar
w System.out implementa la salida estándar
w System.err implementa la salida de error

Java Entrada y Salida 5 Java Entrada y Salida 6

1
Lectura y escritura en los Lectura y escritura en los
flujos estándar flujos estándar
class Salida {
Los flujos se implementan en las clases del public static void
paquete java.io main(String[]args){
System.out int var=5;
n Instancia de la clase PrintStream - flujo de bytes System.out.print(var);
de salida System.out.println(var);
n Metodos de utilidad - impresión de datos System.out.print()"hola") ;
w print() escribe en el buffer System.out.flush();
w println() escribe en el buffer y flush. Deja el cursor en la
siguiente línea. }
w flush() vacía el buffer de salida escribiendo su contenido }

Java Entrada y Salida 7 Java Entrada y Salida 8

Lectura y escritura en los


flujos estándar Ejemplo - uso flujos estándar
import java.io.*;
import java.io.*;
class LecturaDeLinea
LecturaDeLinea {{
System.in class
public static
public static void
void main(
main( String
String args[]
args[] )) throws
throws
n Instancia de la clase InputStream - flujo de bytes IOException {{
IOException
de entrada int c;
int c;
int contador
int contador == 0;0;
n Metodos // se
// se lee
lee hasta
hasta encontrar
encontrar el
el fin
fin de
de línea
línea
w read() permite leer un byte de la entrada como entero while( (c
while( (c == System.in.read()
System.in.read() )) !=
!= '\n'
'\n' )) {{
w skip(n ) ignora n bytes de la entrada contador++;
contador++;
w available() número de bytes disponibles para leer en la System.out.print( (char)
System.out.print( (char) cc );
);
entrada }}
System.out.println(); //
System.out.println(); // Se
Se escribe
escribe el
el cambio
cambio dede línea
línea
System.err - Funcionamiento similar a System.err.println( "Contados
System.err.println( "Contados "+
"+ contador
contador +" +" bytes
bytes en
en
System.out total."
total." ); );
}
}
}}
Java Entrada y Salida 9 Java Entrada y Salida 10

Streams Clasificación de flujos


Representación de la información
w Flujos de bytes (InputStream, OutputStream)
Los Streams son objetos de I/O con w Flujos de caracteres ( Reader, Writer)
operaciones para aceptar y mandar bytes Propósito
(ASCII). w Entrada - (InputStream, Reader)
w Salida - (OutputStream, Writer)
Se utilizan para leer y escribir datos w Entrada/Salida - (RandomAccessFile)

independientemente de la plataforma. Acceso


w Secuencial
w Directo o aleatorio - (RandomAccessFile)
Por operación
w Transferencia de datos
w Transformación de los datos
n Realizan algún tipo de procesamiento sobre los datos (p.e.
buffering, conversiones, filtrados)
Java Entrada y Salida 11 Java Entrada y Salida 12

2
Paquete java.io - Flujos de Paquete java.io - Flujos de
caracteres bytes

Flujos que realizan


sólo transferencia

Flujos que realizan


transformación

Java Entrada y Salida 13 Java Entrada y Salida 14

Streams Streams
Writer
Reader

BufferedWriter OutputStreamWriter StringWriter


BufferedReader InputStreamReader StringReader

FileWriter
FileReader

Java Entrada y Salida 15 Java Entrada y Salida 16

Paquete java.io Lectura de un String


InputStreamReader isr
InputStreamReader isr == new
new
InputStreamReader InputStreamReader(System.in);
InputStreamReader(System.in);
n Lee bytes de un flujo InputStream y los convierte BufferedReader Teclado
BufferedReader Teclado == new
new BufferedReader
BufferedReader (isr);
(isr);
en caracteres Unicode String cadena
String cadena == Teclado.readLine();
Teclado.readLine();
n Métodos de utilidad
w read () lee un único caracter
w ready() indica cuando está listo el flujo para lectura
El método debe incluir throws IOException
BufferedReader
n Entrada mediante búfer, mejora el rendimiento
n Método de utilidad
w readLine() lectura de una línea como cadena

Java Entrada y Salida 17 Java Entrada y Salida 18

3
Lectura de un Caracter Lectura de un Entero
public static
public static char
char damePrimerChar()
damePrimerChar() throws
throws public
public int dameEntero()
int dameEntero() throws
throws IOException
IOException {{
IOException {{
IOException String
String s=leeString();
s=leeString();
String s=leeString();
String s=leeString(); return
return Integer.parseInt(s);
Integer.parseInt(s);
return s.charAt(0);
return s.charAt(0);
}}
}}

El método charAt() de la clase String devuelve el El método parseInt( ) de la clase Integer convierte de
carácter de la posición dada String a tipo int

Java Entrada y Salida 19 Java Entrada y Salida 20

Lectura de números en coma


flotante Combinación de flujos
public
public int dameDouble()
int dameDouble() throws
throws IOException
IOException {{
String
String
Double
s=leeString();
s=leeString();
a = Double.valueOf(s);
Los flujos se pueden combinar para
Double a = Double.valueOf(s);
return
return a.doubleValue();
a.doubleValue(); obtener la funcionalidad deseada
}} InputStream InputStreamReader BufferedReader

Programa
Lee bytes Lee bytes y los pasa Utiliza un búfer para
El envoltorio Float tiene los correspondientes métodos a caracteres Unicode mejorar eficiencia
valueOf() y floatValue() de lectura de carateres

Flujos de transformación de datos

Java Entrada y Salida 21 Java Entrada y Salida 22

Ejemplo - combinación de
flujos La clase Teclado -- Javadoc
package es.ucm.esi;
es.ucm.esi;
import java.io.*;
import java.io.*; package
import java.io.*;
import java.io.*;
class Eco
class Eco {{ /**
/**
public static
public static void
void main
main (String[]
(String[] args)
args) ** <p><p>
<p><p> LaLa clase
clase <em>Teclado</em>
<em>Teclado</em> permite
permite hacer
hacer transparente
transparente lala lectura
lectura
throws IOException
throws IOException sencilla
sencilla
{ ** de
de los
los tipos
tipos mas
mas comunes
comunes de
de datos
datos desde
desde lala entrada
entrada estandar*/
estandar*/
{ public class
class Teclado
Teclado {{
public
BufferedReader entradaEstandar
BufferedReader entradaEstandar == new
new BufferedReader
BufferedReader /** variable
variable dede clase
clase asignada
asignada aa la
la entrada
entrada estandar
estandar del
del sistema
sistema */
*/
/**
(new InputStreamReader(System.in));
(new InputStreamReader(System.in)); public static
public static BufferedReader
BufferedReader entrada
entrada ==
String mensaje;
String mensaje; new BufferedReader(new
new BufferedReader(new InputStreamReader(System.in));
InputStreamReader(System.in));

/** lee
/** lee una
una cadena
cadena desde
desde lala entrada
entrada estandar
estandar
System.out.println(”Introducir
System.out.println (”Introducir una
una linea
linea de
de texto:");
texto:");
** @return cadena
@return cadena de de tipo
tipo String
String
mensaje == entradaEstandar.readLine();
mensaje entradaEstandar.readLine(); ** @exception excepciones No
@exception excepciones No lanza ningunlanza ningun tipo
tipo de
de excepcion
excepcion
System.out.println(”Introducido:\""+mensaje
System.out.println (”Introducido:\""+mensaje ++ "\"");
"\""); de estrada/salida
de estrada/salida */
*/
public static
static String
String leerString()
leerString() {{
}} public
String cadena="";
cadena="";
String
}} try {{
try
cadena == new
cadena new String(entrada.readLine());
String(entrada.readLine());
}catch (IOException
}catch (IOException e) e) {{
System.out.println("Error
System.out.println("Error de de E/S");
E/S"); }}
Java Entrada y Salida 23 return cadena;
cadena; Java// la claseEntrada y Salida continua 24
return }} // Teclado
la clase Teclado continua

4
La clase Teclado Ficheros de texto
// continuación
continuación de de la
la clase
clase teclado
teclado
// BufferedReader FileReader FileInputStream
/** lee
/** lee un
un numero
numero entero
entero desdedesde lala entrada
entrada estandar
estandar
** @return numero
@return numero entero
entero de de tipo
tipo int
int text bytes
** @exception excepciones
@exception excepciones No No lanza
lanza ningun
ningun tipo
tipo de
de excepcion
excepcion de
de
estrada/salida */
estrada/salida */
public static
public static intint leerInt()
leerInt() {{ bytes
int entero
entero == 0; 0; chars
int
boolean error
boolean error == false
false;; File
do {{
do try {{
try
error = false ;;
error = false chars
entero ==
entero bytes
Integer.valueOf(entrada.readLine()).intValue();
Integer.valueOf(entrada.readLine()).intValue(); text
}catch (NumberFormatException e1)
}catch (NumberFormatException e1) {{ bytes
error == true;
error true;
System.out.println("Error
System.out.println("Error en el en el formato
formato del
del numero,
numero,
intentelo de
intentelo de nuevo.");
nuevo."); BufferedWriter FileWriter FileOutputStream
}catch (IOException
}catch (IOException e) e) {{
System.out.println("Error de
System.out.println("Error de E/S");}
E/S");}
}} while
while (error);
(error);
return entero;
return entero;
Javala clase Entrada y Salida 25 Java Entrada y Salida 26
}} }} //
// final
final de de Teclado
la clase Teclado

Ficheros de texto Ejemplo


import java.io.*;
FileReader public class BufferedConsole {
n Util para leer ficheros de texto public static void main(java.lang.String[] args)
w Constructor: FileReader(String nombreFichero) throws java.io.IOException {
FileWriter BufferedReader br = new BufferedReader(
n Util para escribir ficheros de texto new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(
n Constructores new OutputStreamWriter (System.out));
w FileWriter(String nombreFichero ) -- reescribe System.out.println(“Dame unos caracteres o EXIT");
w FileWriter(String nombreFichero , boolean añadirFinal) -- String s = br.readLine();
añade
while (!s.equals("EXIT")) {
PrintWriter bw.write("s: " + s);
n Implementa un flujo de salida de caracteres bw.newLine ();
n Métodos de utilidad s = br.readLine(); }
w print(), println(), bw.close();
Java close() Entrada y Salida 27 Java Entrada y Salida 28
br.close(); }}

Ficheros de texto con datos


Ejemplo Ficheros de texto numéricos
import java.i
import java.io.*;
o.*;
import java.io.*;
import java.io.*;
public class
public class FicheroTexto
FicheroTexto {{
public static
static void
void main(String
main(String args[])
args[]) {{ public class
public class FicheroTexto
FicheroTexto {{
public
try { // escritura
escritura de de datos
datos public static
public static void
void main(String
main(String args[])
args[]) {{
try { //
int i=5;
int i=5;
PrintWriter salida = new PrintWriter (( new
PrintWriter salida = new PrintWriter new BufferedWriter(
BufferedWriter(
new FileWriter("prueba.txt")));
new FileWriter("prueba.txt"))); float f=5.5f;
float f=5.5f;
salida.println("en un lugar de la
salida.println("en un lugar de la mancha de cuyo");mancha de cuyo"); try {{
try // escritura
// escritura de
de datos
datos
salida.println("nombre no
salida.println("nombre no quiero
quiero acordarme");
acordarme"); PrintWriter salida == new
new PrintWriter(
PrintWriter( new
new
PrintWriter salida
salida.close();
salida.close (); BufferedWriter(
BufferedWriter(
// lectura
// lectura de de datos
datos new FileWriter("hola.txt")));
FileWriter("hola.txt")));
BufferedReader entrada
entrada ==new new BufferedReader(
BufferedReader(new new new
BufferedReader salida.println("en un un lugar
lugar de
de la
la mancha
mancha de
de
FileReader ("prueba. txt ")); salida.println("en
FileReader ("prueba. txt ")); cuyo");
String s,
String s, s2s2 == new
new String();
String(); cuyo");
while((s == entrada.readLine
entrada.readLine())!= ())!= null)
null) salida.println(i);
salida.println(i);
while((s
s2 == s2
s2 ++ ss ++ "\
"\n";
n"; salida.println("nombre no
salida.println("nombre no quiero
quiero acordarme");
acordarme");
s2
System.out.println
System .out.println("Texto
("Texto leido:"
leido:" ++ "\n" "\n" ++ s2);
s2); salida.println(f);
salida.println(f);
entrada.close();
entrada.close(); salida.close();
salida.close();
}} catch
catch (java.i
(java.io.IOException
o.IOException e) e) {} {}
}} Java Entrada y Salida 29 Java Entrada y Salida 30
}}

5
Ficheros de texto con datos
numéricos Ficheros
// lectura
// lectura dede datos
datos Clase File
BufferedReader entrada
BufferedReader entrada =new
=new
BufferedReader(new FileReader("hola.txt"));
BufferedReader(new FileReader("hola.txt")); n Representa un nombre de ruta a un fichero
String s,
String s, s2
s2 == new
new String();
String(); o a un subdirectorio del disco
while((s == entrada.readLine())!=
while((s entrada.readLine())!= null)
null) n Constructores
s2 == s2
s2 s2 ++ ss ++ "\n";
"\n";
w File(String ruta)
System.out.println("Texto leido:"
System.out.println("Texto leido:" ++
"\n" ++ s2);
"\n" s2); w File(String ruta, String nombre)
entrada.close();
entrada.close(); w File(File directorio, String nombre)
}} catch
catch (java.io.IOException
(java.io.IOException e) e)
{System.out.println("excepcion");}
{System.out.println("excepcion");}
}}
}}
Java Entrada y Salida 31 Java Entrada y Salida 32

Ejemplo - copia de ficheros


Ficheros
import java.io.*;
import java.io.*;
n Métodos
w canRead() comprueba si el fichero se puede leer public class
public class CopiaFicheros
CopiaFicheros {{
public static
public static void
void main(String
main(String[] [] args)
args) throws
throws
w canWrite() comprueba siel fichero se puede escribir
IOException
IOException { {
w delete() borra dicho fichero File ficheroEntrada
ficheroEntrada == new
new File("original.txt");
File("original.txt");
File
w getPath() devuelve la ruta del fichero File ficheroSalida
File ficheroSalida == new
new File("copia.txt");
File("copia.txt");
w mkdir() crea un directorio con la ruta del objeto que lo FileReader entrada
FileReader entrada == new
new
recibe FileReader(ficheroEntrada);
FileReader (ficheroEntrada);
w isDirectory() comprueba si dicho fichero es un directorio FileWriter salida = new FileWriter(ficheroSalida);
FileWriter salida = new FileWriter(ficheroSalida);
int dato;
int dato;
n Constructores de otras clases while ((dato
((dato == entrada.read())
entrada.read()) != != -1)
-1)
while
w FileReader(File fichero), FileWriter(File fichero) salida.write(dato);
salida.write (dato);
entrada. close();
entrada. close();
salida.close();
salida.close();
}}
Java Entrada y Salida 33 }} Java Entrada y Salida 34

Serialización Escritura de objeto a fichero


Object Output Stream Instance
import java.io.*;
import java.io.*;
Serializable class Main
Main{{
class
public static
public static void
void main(String[]
main(String[] args){args){
implements try {SampleObject
try {SampleObject originalObj1
originalObj1 == new new SampleObject();
SampleObject();
writeObject()
SampleObject originalObj2 == new
SampleObject originalObj2 new SampleObject();
SampleObject();
originalObj1.setName("Mary Popins");
originalObj1.setName("Mary Popins");
originalObj1.setAge(32);
originalObj1.setAge(32);
Sample Object originalObj2.setName(“Popeye");
originalObj2.setName(“Popeye ");
originalObj2.setAge(42);
originalObj2.setAge(42);
Object Input Stream Instance FileOutputStream fos = null;
FileOutputStream fos = null;
ObjectOutputStream oos
ObjectOutputStream oos == null; null;
fos == new
fos new FileOutputStream("SerializedObj.obj");
FileOutputStream("SerializedObj.obj");
oos == new
oos new ObjectOutputStream
ObjectOutputStream(fos); (fos);
readObject()
oos.writeObject(originalObj1);
oos.writeObject(originalObj1 );
oos.writeObject(originalObj2
oos.writeObject(originalObj2 ); );
oos.flush();
oos.flush();
oos.close();
oos.close();
}catch(Exception e){System.out.println("Main:
}catch(Exception e){System.out.println("Main: main(): main(): "" ++ e);
e);
Java Entrada y Salida 35 Java Entrada y Salida 36
}} }}
}}

6
Lectura de fichero a objeto
import java.io.*;
import java.io.*;

class Main
class Main{{
public static
public static void
void main(String[]
main(String[] args){ args){
try {{
try
FileInputStream fis =
FileInputStream fis = null; null;
ObjectInputStream ois
ObjectInputStream ois == null;
null;
fis == new
fis new FileInputStream
FileInputStream("SerializedObj.obj");
("SerializedObj.obj");
ois == new
ois new ObjectInputStream(fis);
ObjectInputStream(fis);
SampleObject newObj1
SampleObject newObj1 == (SampleObject)
(SampleObject) ois.readObject();
ois.readObject();
SampleObject newObj2
SampleObject newObj2 == (SampleObject)
(SampleObject) ois.readObject();
ois.readObject();
ois.close();
ois.close();
System.out.println("SampleObject1 name: "" ++
System.out.println("SampleObject1 name:
newObj1.getName());
newObj1.getName());
System.out.println("SampleObject2 name:
System.out.println("SampleObject2 name: "" ++
newObj2.getName());
newObj2.getName());
}catch(Exception e){
}catch(Exception e){
System.out.println("Main: main():
System.out.println("Main: main(): "" ++ e); e);
}} Java Entrada y Salida 37
}}
}}