Entrada y salida de datos Entrada y salida de datos Flujos estándar

Entrada y salida de datos
Intercambio de datos entre el programa y el
exterior
Entrada y salida de datos
n
n
Diversidad de dispositivos (fichero, pantalla, red,
…)
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
Java
Entrada y Salida
1
Flujos estándar
n
n
2
n
n
Entrada estándar - habitualmente el
teclado
Salida estándar - habitualmente la pantalla
Salida de error - habitualmente la pantalla
Dispositivo
de entrada
(teclado)
Entrada y Salida
3
Operación y flujos estándar en
java
Lectura y escritura
Lectura
Abrir un flujo
Mientras existan datos disponibles
Leer datos
Cerrar el flujo
Java
Entrada y Salida
Flujos estándar
Operación independiente del tipo de datos y del
dispositivo
Mayor flexibilidad (p.e. redirección, combinación)
Java
Destino
Datos
Java
Flujos estándar
Los programas se comunican con flujos y
estos flujos actúan como interfaz con el
dispositivo o clase asociada
n
Datos
Datos
Java
Flujo salida
Programa
Datos
Dispositivo
de salida
(pantalla, disco)
Entrada y Salida
4
Operación y flujos estándar en
java
Java tiene acceso a la entrada/salida
estándar a través de la clase
java.lang.System
Escritura
Abrir un flujo
Mientras existan datos disponibles
Escribir datos
Cerrar el flujo
Entrada y Salida
Flujo entrada
5
n
n
Los flujos estándar son campos estáticos de
System
Flujos
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
6
1
Lectura y escritura en los
flujos estándar
Lectura y escritura en los
flujos estándar
Los flujos se implementan en las clases del
paquete java.io
System.out
n
n
Instancia de la clase PrintStream - flujo de bytes
de salida
Metodos de utilidad - impresión de datos
w print() escribe en el buffer
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
Lectura y escritura en los
flujos estándar
n
Instancia de la clase InputStream - flujo de bytes
de entrada
Metodos
w read() permite leer un byte de la entrada como entero
w skip(n ) ignora n bytes de la entrada
w available() número de bytes disponibles para leer en la
entrada
System.err - Funcionamiento similar a
System.out
Java
Entrada y Salida
Java
;
Entrada y Salida
8
Ejemplo - uso flujos estándar
System.in
n
class Salida {
public static void
main(String[]args){
int var=5;
System.out.print(var);
System.out.println(var);
System.out.print()"hola")
System.out.flush();
}
}
9
Streams
import java.io.*;
java.io.*;
import
class LecturaDeLinea
LecturaDeLinea {{
class
public static
static void
void main(
main( String
String args[]
args[] )) throws
throws
public
IOException {{
IOException
int
c;
int c;
int contador
contador == 0;
0;
int
// se
se lee
lee hasta
hasta encontrar
encontrar el
el fin
fin de
de línea
línea
//
while( (c
(c == System.in.read()
System.in.read() )) !=
!= '\n'
'\n' )) {{
while(
contador++;
contador++;
System.out.print( (char)
(char) cc );
);
System.out.print(
}}
System.out.println(); //
// Se
Se escribe
escribe el
el cambio
cambio de
de línea
línea
System.out.println();
System.err.println( "Contados
"Contados "+
"+ contador
contador +"
+" bytes
bytes en
en
System.err.println(
total."
);
total." );
}
}
}}
Java
Entrada y Salida
10
Clasificación de flujos
Representación de la información
w Flujos de bytes (InputStream, OutputStream)
w Flujos de caracteres ( Reader, Writer)
Los Streams son objetos de I/O con
operaciones para aceptar y mandar bytes
(ASCII).
Se utilizan para leer y escribir datos
independientemente de la plataforma.
Propósito
w Entrada - (InputStream, Reader)
w Salida - (OutputStream, Writer)
w Entrada/Salida - (RandomAccessFile)
Acceso
w Secuencial
w Directo o aleatorio - (RandomAccessFile)
Por operación
w Transferencia de datos
w Transformación de los datos
n
Java
Entrada y Salida
11
Realizan algún tipo de procesamiento sobre los datos (p.e.
buffering, conversiones, filtrados)
Java
Entrada y Salida
12
2
Paquete java.io - Flujos de
caracteres
Paquete java.io - Flujos de
bytes
Flujos que realizan
sólo transferencia
Flujos que realizan
transformación
Java
Entrada y Salida
13
Streams
Java
Entrada y Salida
14
Streams
Writer
Reader
BufferedWriter
BufferedReader
InputStreamReader
OutputStreamWriter
StringWriter
StringReader
FileWriter
FileReader
Java
Entrada y Salida
15
Paquete java.io
n
Lee bytes de un flujo InputStream y los convierte
en caracteres Unicode
Métodos de utilidad
w read () lee un único caracter
w ready() indica cuando está listo el flujo para lectura
n
16
InputStreamReader isr
isr == new
new
InputStreamReader
InputStreamReader(System.in);
InputStreamReader(System.in);
BufferedReader Teclado
Teclado == new
new BufferedReader
BufferedReader (isr);
(isr);
BufferedReader
String cadena
cadena == Teclado.readLine();
Teclado.readLine();
String
El método debe incluir throws IOException
BufferedReader
n
Entrada y Salida
Lectura de un String
InputStreamReader
n
Java
Entrada mediante búfer, mejora el rendimiento
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
static char
char damePrimerChar()
damePrimerChar() throws
throws
public
IOException {{
IOException
String
s=leeString();
String s=leeString();
return s.charAt(0);
s.charAt(0);
return
}}
public
public
String
String
return
return
}}
El método charAt() de la clase String devuelve el
carácter de la posición dada
Java
Entrada y Salida
El método parseInt( ) de la clase Integer convierte de
String a tipo int
19
Lectura de números en coma
flotante
public
public
String
String
Double
Double
return
return
}}
int dameEntero()
dameEntero() throws
throws IOException
IOException {{
int
s=leeString();
s=leeString();
Integer.parseInt(s);
Integer.parseInt(s);
Java
Entrada y Salida
20
Combinación de flujos
int dameDouble()
dameDouble() throws
throws IOException
IOException {{
int
s=leeString();
s=leeString();
a
=
Double.valueOf(s);
a = Double.valueOf(s);
a.doubleValue();
a.doubleValue();
Los flujos se pueden combinar para
obtener la funcionalidad deseada
InputStream
InputStreamReader
BufferedReader
Programa
El envoltorio Float tiene los correspondientes métodos
valueOf() y floatValue()
Lee bytes
Lee bytes y los pasa Utiliza un búfer para
a caracteres Unicode
mejorar eficiencia
de lectura de carateres
Flujos de transformación de datos
Java
Entrada y Salida
21
Ejemplo - combinación de
flujos
System.out.println(”Introducir
(”Introducir una
una linea
linea de
de texto:");
texto:");
System.out.println
mensaje == entradaEstandar.readLine();
entradaEstandar.readLine();
mensaje
System.out.println(”Introducido:\""+mensaje
(”Introducido:\""+mensaje ++ "\"");
"\"");
System.out.println
}}
}}
Entrada y Salida
Entrada y Salida
22
La clase Teclado -- Javadoc
import java.io.*;
java.io.*;
import
class Eco
Eco {{
class
public static
static void
void main
main (String[]
(String[] args)
args)
public
throws IOException
IOException
throws
{
{
BufferedReader entradaEstandar
entradaEstandar == new
new BufferedReader
BufferedReader
BufferedReader
(new InputStreamReader(System.in));
InputStreamReader(System.in));
(new
String mensaje;
mensaje;
String
Java
Java
23
package es.ucm.esi;
es.ucm.esi;
package
import java.io.*;
java.io.*;
import
/**
/**
<p><p> La
La clase
clase <em>Teclado</em>
<em>Teclado</em> permite
permite hacer
hacer transparente
transparente la
la lectura
lectura
** <p><p>
sencilla
sencilla
de los
los tipos
tipos mas
mas comunes
comunes de
de datos
datos desde
desde la
la entrada
entrada estandar*/
estandar*/
** de
public class
class Teclado
Teclado {{
public
/** variable
variable de
de clase
clase asignada
asignada aa la
la entrada
entrada estandar
estandar del
del sistema
sistema */
*/
/**
public static
static BufferedReader
BufferedReader entrada
entrada ==
public
new BufferedReader(new
BufferedReader(new InputStreamReader(System.in));
InputStreamReader(System.in));
new
/** lee
lee una
una cadena
cadena desde
desde la
la entrada
entrada estandar
estandar
/**
@return cadena
cadena de
de tipo
tipo String
String
**
@return
*
@exception
excepciones
No
lanza
ningun tipo
tipo de
de excepcion
excepcion
*
@exception excepciones No lanza ningun
de estrada/salida
estrada/salida
*/
de
*/
public static
static String
String leerString()
leerString() {{
public
String cadena="";
cadena="";
String
try {{
try
cadena == new
new String(entrada.readLine());
String(entrada.readLine());
cadena
}catch (IOException
(IOException e)
e) {{
}catch
System.out.println("Error
de E/S");
E/S"); }}
System.out.println("Error de
Java// la clase
Entrada
y Salida continua
24
return cadena;
cadena;
Teclado
return
}} //
la clase Teclado
continua
4
La clase Teclado
Ficheros de texto
// continuación
continuación de
de la
la clase
clase teclado
teclado
//
/** lee
lee un
un numero
numero entero
entero desde
desde la
la entrada
entrada estandar
estandar
/**
@return numero
numero entero
entero de
de tipo
tipo int
int
**
@return
@exception excepciones
excepciones No
No lanza
lanza ningun
ningun tipo
tipo de
de excepcion
excepcion de
de
**
@exception
estrada/salida */
*/
estrada/salida
public static
static int
int leerInt()
leerInt() {{
public
int entero
entero == 0;
0;
int
boolean error
error == false
false;;
boolean
do {{
try {{
do
try
error
=
false
error = false ;;
entero ==
entero
Integer.valueOf(entrada.readLine()).intValue();
Integer.valueOf(entrada.readLine()).intValue();
}catch
(NumberFormatException e1)
e1) {{
}catch (NumberFormatException
error == true;
true;
error
System.out.println("Error
en
el formato
formato del
del numero,
numero,
System.out.println("Error en el
intentelo de
de nuevo.");
nuevo.");
intentelo
}catch (IOException
(IOException e)
e) {{
}catch
System.out.println("Error de
de E/S");}
E/S");}
System.out.println("Error
while (error);
(error);
}} while
return entero;
entero;
return
Javala clase Entrada
y Salida
25
// final
final de
de
Teclado
}} }} //
la clase Teclado
Ficheros de texto
Util para leer ficheros de texto
w Constructor: FileReader(String nombreFichero)
FileWriter
n
n
Util para escribir ficheros de texto
Constructores
w FileWriter(String nombreFichero ) -- reescribe
w FileWriter(String nombreFichero , boolean añadirFinal) -añade
PrintWriter
n
n
Implementa un flujo de salida de caracteres
Métodos de utilidad
w print(), println(),
Java close()
Entrada y Salida
FileReader
FileInputStream
bytes
bytes
chars
File
chars
bytes
text
bytes
BufferedWriter
FileWriter
Java
FileOutputStream
Entrada y Salida
26
Ejemplo
FileReader
n
BufferedReader
text
27
Ejemplo Ficheros de texto
import java.i
java.io.*;
o.*;
import
public class
class FicheroTexto
FicheroTexto {{
public
public static
static void
void main(String
main(String args[])
args[]) {{
public
try
{
// escritura
escritura de
de datos
datos
try {
//
PrintWriter
salida
=
new
PrintWriter
new BufferedWriter(
BufferedWriter(
PrintWriter salida = new PrintWriter (( new
new FileWriter("prueba.txt")));
FileWriter("prueba.txt")));
new
salida.println("en
un
lugar
de
la
mancha
de
cuyo");
salida.println("en un lugar de la mancha de cuyo");
salida.println("nombre no
no quiero
quiero acordarme");
acordarme");
salida.println("nombre
salida.close();
();
salida.close
// lectura
lectura de
de datos
datos
//
BufferedReader entrada
entrada ==new
new BufferedReader(
BufferedReader(new
new
BufferedReader
FileReader
("prueba.
txt
"));
FileReader ("prueba. txt "));
String s,
s, s2
s2 == new
new String();
String();
String
while((s == entrada.readLine
entrada.readLine())!=
())!= null)
null)
while((s
s2 == s2
s2 ++ ss ++ "\
"\n";
n";
s2
System.out.println
.out.println("Texto
("Texto leido:"
leido:" ++ "\n"
"\n" ++ s2);
s2);
System
entrada.close();
entrada.close();
catch (java.i
(java.io.IOException
o.IOException e)
e) {}
{}
}} catch
Java
Entrada y Salida
29
}}
}}
import java.io.*;
public class BufferedConsole {
public static void main(java.lang.String[] args)
throws java.io.IOException {
BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(
new OutputStreamWriter (System.out));
System.out.println(“Dame unos caracteres o EXIT");
String s = br.readLine();
while (!s.equals("EXIT")) {
bw.write("s: " + s);
bw.newLine ();
s = br.readLine(); }
bw.close();
Java
Entrada y Salida
28
br.close(); }}
Ficheros de texto con datos
numéricos
import java.io.*;
java.io.*;
import
public class
class FicheroTexto
FicheroTexto {{
public
public static
static void
void main(String
main(String args[])
args[]) {{
public
int i=5;
i=5;
int
float f=5.5f;
f=5.5f;
float
try {{
// escritura
escritura de
de datos
datos
try
//
PrintWriter
salida == new
new PrintWriter(
PrintWriter( new
new
PrintWriter salida
BufferedWriter(
BufferedWriter(
new FileWriter("hola.txt")));
FileWriter("hola.txt")));
new
salida.println("en un
un lugar
lugar de
de la
la mancha
mancha de
de
salida.println("en
cuyo");
cuyo");
salida.println(i);
salida.println(i);
salida.println("nombre no
no quiero
quiero acordarme");
acordarme");
salida.println("nombre
salida.println(f);
salida.println(f);
salida.close();
salida.close();
Java
Entrada y Salida
30
5
Ficheros de texto con datos
numéricos
Ficheros
// lectura
lectura de
de datos
datos
//
BufferedReader entrada
entrada =new
=new
BufferedReader
BufferedReader(new FileReader("hola.txt"));
FileReader("hola.txt"));
BufferedReader(new
String s,
s, s2
s2 == new
new String();
String();
String
while((s == entrada.readLine())!=
entrada.readLine())!= null)
null)
while((s
s2 == s2
s2 ++ ss ++ "\n";
"\n";
s2
System.out.println("Texto leido:"
leido:" ++
System.out.println("Texto
"\n" ++ s2);
s2);
"\n"
entrada.close();
entrada.close();
catch (java.io.IOException
(java.io.IOException e)
e)
}} catch
{System.out.println("excepcion");}
{System.out.println("excepcion");}
}}
}}
Java
Entrada y Salida
n
Representa un nombre de ruta a un fichero
o a un subdirectorio del disco
Constructores
w File(String ruta)
w File(String ruta, String nombre)
w File(File directorio, String nombre)
Java
Entrada y Salida
32
Ejemplo - copia de ficheros
import java.io.*;
java.io.*;
import
Métodos
w canRead() comprueba si el fichero se puede leer
w canWrite() comprueba siel fichero se puede escribir
w delete() borra dicho fichero
w getPath() devuelve la ruta del fichero
w mkdir() crea un directorio con la ruta del objeto que lo
recibe
w isDirectory() comprueba si dicho fichero es un directorio
n
n
31
Ficheros
n
Clase File
Constructores de otras clases
w FileReader(File fichero), FileWriter(File fichero)
Java
Entrada y Salida
33
Serialización
Escritura de objeto a fichero
Object Output Stream Instance
Serializable
implements
writeObject()
Sample Object
Object Input Stream Instance
readObject()
Java
public class
class CopiaFicheros
CopiaFicheros {{
public
public static
static void
void main(String
main(String[]
[] args)
args) throws
throws
public
IOException
{
IOException {
File ficheroEntrada
ficheroEntrada == new
new File("original.txt");
File("original.txt");
File
File ficheroSalida
ficheroSalida == new
new File("copia.txt");
File("copia.txt");
File
FileReader entrada
entrada == new
new
FileReader
FileReader(ficheroEntrada);
(ficheroEntrada);
FileReader
FileWriter
salida
=
new
FileWriter(ficheroSalida);
FileWriter salida = new FileWriter(ficheroSalida);
int dato;
dato;
int
while ((dato
((dato == entrada.read())
entrada.read()) !=
!= -1)
-1)
while
salida.write(dato);
(dato);
salida.write
entrada.
close();
entrada. close();
salida.close();
salida.close();
}}
}}
Java
Entrada y Salida
34
Entrada y Salida
35
import java.io.*;
java.io.*;
import
class Main
Main{{
class
public static
static void
void main(String[]
main(String[] args){
args){
public
try {SampleObject
{SampleObject originalObj1
originalObj1 == new
new SampleObject();
SampleObject();
try
SampleObject
originalObj2
new SampleObject();
SampleObject();
SampleObject originalObj2 == new
originalObj1.setName("Mary Popins");
Popins");
originalObj1.setName("Mary
originalObj1.setAge(32);
originalObj1.setAge(32);
originalObj2.setName(“Popeye");
");
originalObj2.setName(“Popeye
originalObj2.setAge(42);
originalObj2.setAge(42);
FileOutputStream
fos
=
null;
FileOutputStream fos = null;
ObjectOutputStream oos
oos == null;
null;
ObjectOutputStream
fos == new
new FileOutputStream("SerializedObj.obj");
FileOutputStream("SerializedObj.obj");
fos
oos == new
new ObjectOutputStream
ObjectOutputStream(fos);
(fos);
oos
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:
e){System.out.println("Main: main():
main(): "" ++ e);
e);
}catch(Exception
Java
Entrada y Salida
36
}}
}} }}
6
Lectura de fichero a objeto
import java.io.*;
java.io.*;
import
class Main
Main{{
class
public static
static void
void main(String[]
main(String[] args){
args){
public
try
try {{
FileInputStream
fis
=
null;
FileInputStream fis = null;
ObjectInputStream ois
ois == null;
null;
ObjectInputStream
fis == new
new FileInputStream
FileInputStream("SerializedObj.obj");
("SerializedObj.obj");
fis
ois == new
new ObjectInputStream(fis);
ObjectInputStream(fis);
ois
SampleObject newObj1
newObj1 == (SampleObject)
(SampleObject) ois.readObject();
ois.readObject();
SampleObject
SampleObject newObj2
newObj2 == (SampleObject)
(SampleObject) ois.readObject();
ois.readObject();
SampleObject
ois.close();
ois.close();
System.out.println("SampleObject1
name:
System.out.println("SampleObject1 name: "" ++
newObj1.getName());
newObj1.getName());
System.out.println("SampleObject2 name:
name: "" ++
System.out.println("SampleObject2
newObj2.getName());
newObj2.getName());
}catch(Exception e){
e){
}catch(Exception
System.out.println("Main: main():
main(): "" ++ e);
e);
System.out.println("Main:
}}
Java
Entrada y Salida
37
}}
}}
7