Sie sind auf Seite 1von 4

http://www.ingenieriasystems.

com

Leer y escribir objetos en ficheros - Java

La lectura y escritura de objetos en un fichero binario requiere el uso de las clases


FileOutpusStream y ObjectOutputStream. La clase ObjectOutputStream permite
escribir objetos en un fichero utilizando el mtodo writeObject(Object o). Los datos que
se almacenan en el fichero de salida tienen un formato binario distinto de los ficheros de
texto.
El mtodo close() de la clase ObjectOutputStream cierra el fichero de datos.
Para escribir objetos utilizando la clase ObjectOutputStream es necesario codificar los
objetos dentro del flujo de salida. A la codificacin de los objetos dentro de un flujo de
entrada o salida se le denomina serializacin. Para que los objetos de una clase sean
serializables es necesario implementar la interfaz Serializable de Java.
Para leer objetos almacenados en un fichero binario se utiliza el mtodo readObject() de
la clase ObjectInputStream. Despus de leer el objeto del fichero se debe convertir a la
clase a la que pertenece.
Cuando se utilizan los flujos ObjectInputStream y ObjectOutputStream de Java es
necesario atrapar los errores de ejecucin que se producen mientras se lee o escribe el
fichero de datos con los flujos de entrada y salida. Para atrapar los errores de ejecucin
o excepciones, se utilizan las sentencias try y catch. Las excepciones que se producen
durante la ejecucin de las sentencias definidas en el cuerpo del try se atrapan con catch.
Para escribir un objeto de la clase Persona en un fichero binario, es necesario indicar
que esta clase es serializable, es decir, que sus objetos se codifican dentro de los
flujos de entrada y salida de Java. Para indicar que la clase Persona es serializable se
modifica su declaracin indicando que implementa la interfaz Serializable.
?
1
2

public class Persona implements java.io.Serializable {


}

La declaracin completa de la clase Persona, con la implementacin de la interfaz


Serializable, su mtodo constructor y sus mtodos get y set.
?
1
2
3
4
5
6
7
8
9
10
11
12

public class Persona implements java.io.Serializable {


private String dni;
private String nombre;
private String apellidos;
public Persona(String dni, String nombre, String apellidos) {
this.dni = dni;
this.nombre = nombre;
this.apellidos = apellidos;
}
public String getDNI() {
return this.dni;
}
public String getNombre() {
return this.nombre;
}

http://www.ingenieriasystems.com

13
14
15
16
17
18
19
20
21
22
23

public String getApellidos() {


return this.apellidos;
}
public String getAtributos() {
return this.getDNI() + " " + this.getApellidos() + ", " +
this.getNombre();
}
}

Para escribir un objeto de la clase Persona en un fichero de texto se utilizan las clases
FileOutputStream y ObjectOutputStream. Se crea una instancia de la clase
FileOutputStream para inicializar la instancia objetoSalida de ObjectOutputStream que
escribe en el fichero binario Objetos.dat.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

String nombreFichero = "c:\\Objetos.dat";


try {
FileOutputStream ficheroSalida = new
FileOutputStream(nombreFichero);
ObjectOutputStream objetoSalida = new
ObjectOutputStream(ficheroSalida);
// se escriben dos objetos de la clase Persona
objetoSalida.writeObject(new Persona("55287188B",
"Mara", "Ruiz Ramos"));
objetoSalida.writeObject(new Persona("40302010A",
"Juan", "Gonzlez Lpez"));
objetoSalida.close();
} catch (FileNotFoundException e) {
System.out.println("El fichero no existe!");
} catch (IOException e) {
System.out.println(e.getMessage());
} catch (Exception e) {
System.out.println(e.getMessage());
};

Para leer los objetos almacenados en el fichero binario se utilizan las clases
FileInputStream y ObjectInputStream. Se crea una instancia de la clase FileInputStream
para inicializar la instancia objetoEntrada de ObjectInputStream.
?
1
2
3
4
5
6
7

try {
FileInputStream ficheroEntrada = new
FileInputStream(nombreFichero);
ObjectInputStream objetoEntrada = new
ObjectInputStream(ficheroEntrada);
// se leen dos objetos de la clase Persona
Persona p1 = (Persona)objetoEntrada.readObject();
Persona p2 = (Persona)objetoEntrada.readObject();
// se cierra el flujo de objetos objetoEntrada

http://www.ingenieriasystems.com

8
9
10
11
12
13
14
15
16
17
18
19
20

objetoEntrada.close();
System.out.println("DNI\t Nombre");
System.out.println(p1.getAtributos());
System.out.println(p2.getAtributos());
} catch (FileNotFoundException e) {
System.out.println("El fichero no existe!");
} catch (IOException e) {
System.out.println(e.getMessage());
} catch (Exception e) {
System.out.println(e.getMessage());
};

La salida por la consola:


DNI Nombre
55287188B Ruiz Ramos, Mara
40302010A Gonzlez Lpez, Juan
Las sentencias try y catch se utilizan para atrapar las excepciones que se producen
durante la ejecucin del programa: FileNotFoundException, IOException o Exception.
De esta forma se atrapan los errores que se producen cuando el fichero de datos no
existe o cuando hay un problema de lectura o escritura en el fichero.
Las excepciones son el mecanismo que proporciona Java para gestionar los errores de
ejecucin de una aplicacin.
La sentencia try-catch-finally tiene la siguiente sintaxis:
?
1
2
3
4
5
6
7
8
9
10
11

try {
sentencias-que-pueden-producir-una-excepcin;
} catch (Excepcin-tipo-1 e) {
sentencias-para-excepcin-tipo-1;
} catch (Excepcin-tipo-2 e) {
sentencias-para-excepcin-tipo-2;
} catch (Excepcin-tipo-3 e){
sentencias-para-excepcin-tipo-3;
} finally {
sentencias-que-se-ejecutan-si-hay-excepcin-o-no;
};

En una sentencia try-catch-finally, los bloques catch se pueden repetir tantas veces
como excepciones de distinto tipo se desee atrapar. El bloque finally es opcional y solo
puede aparecer una vez. Este bloque se ejecuta siempre.
El programa Java que escribe y lee objetos.

http://www.ingenieriasystems.com