PDF de programación - El paquete java.io

El paquete java.io.

Manejo de las I/O.

Leo Suarez

[email protected]

http://www.javahispano.com

Julio 2001

El paquete java.io
Manejo de las I/O

El paquete java.io. Manejo de las I/O.
En este artículo presentamos el paquete que el API estándar de Java nos proporciona para gestionar las
operaciones de I/O tanto del sistema como desde/a ficheros.
Como sabemos, Java es un lenguaje orientado a red, cuyo potencial radica en todo aquello que tenga
que ver con la ejecución de aplicaciones a través de la red y, por tanto, este paquete se ajusta
perfectamente a esta condición permitiendo la gestión de ficheros desde sitios remotos.
Evidentemente, Java va mucho más allá del típico println(), cuyo uso más normal y natural es el de
hacer los "debugging" de la aplicación que estemos creando.

Por último, para los diseñadores de applets, recalcar que Java nos permite escribir sobre un fichero si
previamente hemos autentificado y/o firmado nuestro applet.

Índice.
Los streams.
Los streams predefinidos.
Lectura de consola.
Ejemplo.
Imprimir a consola.
Ejemplo.
Lectura y escritura de ficheros.
Propiedades del fichero. La clase File (Ejemplo).
Byte Stream.
ByteArrayInputStream.
ByteArrayOutputStream.
FileInputStream.
FileOutputStream.
Filtered Byte Stream.
DataInputStream.
DataOutputStream.
BufferedInputStream.
BufferedOutputStream.
Combinación de las clases.
Lectura de datos crudos o raw data (Ejemplo).
Carga de un fichero desde un applet (Ejemplo).
Character Stream.
Serialización.
La interface Serializable.
La interface Externalizable.
La interface ObjectInput.
ObjectInputStream.
La interface ObjectOutput.
ObjectOutputStream.
Serialización de un objeto (ejemplo).
Conclusión.
Bibliografía.

3

Leo Suarez
http://www.javahispano.com

Los streams.
Cualquier programa realizado en Java que necesite llevar a cabo una operación de I/O lo hará
a través de un stream. Un stream, cuya traducción literal es "flujo", es una abstracción de
todo aquello que produzca o consuma información. Podemos ver a este stream como una
entidad lógica. La vinculación de este stream al dispositivo físico la hace el sistema de entrada
y salida de Java. Se ve pues la eficacia de esta implementación pues las clases y métodos de
I/O que necesitamos emplear son las mismas independientemente del dispositivo con el que
estemos actuando, luego, el núcleo de Java, sabrá si tiene que tratar con el teclado, el monitor,
un sistema de ficheros o un socket de red liberando a nuestro código de tener que saber con
quién está interactuando.



Java2 define dos tipos de streams:

• Byte streams : Nos proporciona un medio adecuado para el manejo de entradas y

salidas de bytes y su uso lógicamente está orientado a la lectura y escritura de datos
binarios. El tratamiento del flujo de bytes viene gobernado por dos clases abstractas
que son InputStream y OutputStream. Cada una de estas clases abstractas tienen
varias subclases concretas que controlan las diferencias ente los distintos dispositivos
de I/O que se pueden utilizar. Así mismo, estas dos clases son las que definen los
métodos que sus subclases tendrán implementados y, de entre todas, destacan las
clases read() y write() que leen y escriben bytes de datos respectivamente.

• Character streams : Proporciona un medio conveniente para el manejo de entradas y
salidas de caracteres. Dichos flujos usan codificación Unicode y, por tanto, se pueden
internacionalizar. Una observación: Este es un modo que Java nos proporciona para
manejar caracteres pero al nivel más bajo todas las operaciones de I/O son orientadas a
byte. Al igual que la anterior el flujo de caracteres también viene gobernado por dos
clases abstractas: Reader y Writer. Dichas clases manejan flujos de caracteres
Unicode. Y también de ellas derivan subclases concretas que implementan los
métodos definidos en ellas siendo los más destacados los métodos read() y write()
que, en este caso, leen y escriben caracteres de datos respectivamente.

En ambos casos, los métodos son sobrecargados por las clases derivadas de ellos.

4

El paquete java.io
Manejo de las I/O

Los streams predefinidos.
Para comprender un poco mejor cómo funciona el paquete de I/O, veamos como trabaja
realmente la clase System.
System define tres campos que son in, out y err que corresponden a la entrada estandar, la
salida estandar y la salida estandar de errores. System.in es un objeto de tipo InputStream
mientras que los otros dos son de tipo PrintStream. La pregunta que ahora te harás es ¿cómo
es posible que si yo uso la clase Sytem para mandar texto , por ejemplo a la salida, sea de tipo
Byte? Pues bien, esto se soluciona haciendo un “wrapping” (envoltorio) de la clase para
convertirla a un flujo de caracteres. Veamoslo en el siguiente ejemplo:


Lectura de consola.
La entrada de consola, como sabemos, la obtenemos leyendo de System.in. Para conseguir un
flujo de caracteres envolvemos dicha clase en un objeto del tipo BufferedReader, el cual
soporta un flujo de entrada buferizado.
Atendiendo a las especificaciones de esta clase, el parámetro que se le pasa es el stream de
entrada que es de tipo Reader, el cual, como sabemos es abastracto por lo que recurriremos a
una de sus subclases, en nuestro caso será InputStreamReader que convierte bytes a
caracteres. Otra vez más, atendiendo a la especificación de esta última clase vemos que el
parámetro que se le pasa es de tipo InputStream, o sea, la entrada orientada a byte que en
nuestro caso es System.in. Ya está, ya hemos asociado un dispositivo físico (el teclado) a un
stream orientado a caracteres mediante el wrapping de la clase System con la clase
BufferedReader. Resumamos los pasos:

1. BufferedReader (Reader input); clase que recibe un flujo de caracteres de entrada.
2. InputStreamReader ( InputStream input2) ; clase que convierte de byte a carácter.
3. BufferedReader br = new BufferedReader(new InputStreamReader(System.in); br es un
Character Stream que se linka a la consola a traves de la clase System.in la cual hemos tenido
que wrappear para convertir de byte a char.

Ejemplo 1. Lectura de consola.
//En este ejemplo leemos de consola cadenas de caracteres.
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class LecturaStringConsola {
public static void main(String args[]) throws IOException {
String cadena;
BufferedReader br;
//Creamos un BufferedReader a trevés de System.in
br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Empieza a escribir, 'stop' para salir");
//leemos cadena de caracteres mediante readLine().
do {
cadena = br.readLine();
System.out.println(cadena);
} while(!cadena.equals("stop"));
}
}//Fin LecturaStringConsola


5

Leo Suarez
http://www.javahispano.com

Imprimir a consola.
Lo que siempre hacemos es imprimir mediante System.out pero en una aplicación más formal
haremos uso de la clase PrintWriter que soporta flujos de caracteres. Esta clase contiene los
métodos print() y println() para todos los tipos por lo que se podrán usar igual que lo
hacíamos con System.out. Si un argumento no es de un tipo simple, entonces, los métodos de
PrintWriter llaman al método toString() y luego imprimen el resultado.
Ejemplo 2. Imprimir a pantalla.

//En el siguiente ejemplo básico imprimimos a consola diferentes tipos de datos primitivos.

import java.io.PrintWriter;
public class Imprimir {
public static void main(String args[]) {
/*
El constructor toma como parámetros un objeto de tipo OutputStream del
cual deriva PrintStream, por tanto, ya tenemos
linkada la clase con el dispositivo de salida (la consola).
*/
PrintWriter pw = new PrintWriter(System.out, true);
pw.println("Imprime una cadena de texto");
int i = 15;
pw.println("Imprime un entero " + i);
double d = 6.8e-9;
pw.println("Imprime un double " + d);
}
}


Lectura y escritura de ficheros.
En Java, todos los ficheros son orientados a byte por lo que nos proporciona métodos para
leer y escribir desde/a un fichero. No obstante, también nos permite hacer “wrapping” de
dicho flujo orientado a byte para convertirlo a un objeto basado en caracteres.
Las dos principales clases que nos posibilitan trabajar con los ficheros son FileInputStream
y FileOutputStream las cuales crean un enlace entre el flujo de bytes y el fichero. Para abrir
un fichero simplemente le pasamos al constructor de estas clases el nombre de éste, luego con
los métodos read() y write() actuaremos sobre él y finalmente mediante el método close()
cerramos la sesión con el fichero. Más adelante se detallan un poco más estas clases y las
acompañamos de algunos ejemplos útiles.

ADVERTENCIA: No confundas las dos clases anteriores con la clase File. Ésta, para
empezar, no trabaja sobre un flujo de bytes sino que trata directamente con el fichero y con el
sistema de ficheros. Es decir, con esta clase no accedemos a los datos de los ficheros, está
orientada a obtener y/o manipular la información asociada a éste como, por ejemplo,
permisos, fechas, si es un fichero o un directorio, el path, etc... Así cuando creamos una
instancia de File, lo que estamos haciendo es establecer un enlace con un archivo o directorio
físico al que luego le podremos consultar todas sus propiedades. Lo recomendable, para poder
acceder a los datos del fichero y a sus propiedades es crear una instancia a la que le pasamos
un objeto File de la siguiente manera:


6

El paquete java.io
Manejo de las I/O

File f = new File(“ruta_del_fichero”); instancia del descriptor del
fichero.
FileInputStream fis = new FileInputStream( f ); instancia de la clase que
nos permite leer los datos.

Ejemplo 3. Obtención de las propiedades de un fichero.
/*
En este ejemplo presentamos algunos de los métodos que la clase File nos
proporciona para conocer los detalles de un fichero.
*/
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLE