Vamos a ver cómo podemos de una manera ultra simple, guardar y leer información en ficheros desde Java utilizando la Serialización. No hace falta ningún tipo de conversión ni parsear campo a campo. La API de Java tiene mecanismos que nos hacen todo el trabajo y sólo necesitaremos crear la infraestructura para poder leer y escribir en fichero. Incluso, podremos escribir y leer directamente un ArrayList de nuetro objeto creado. Suena fácil y simple, no? Vamos a verlo.
Para empezar, tenemos la clase Persona que implementa Serializable.
public class Persona implements Serializable {
private String nombre;
private String apellido;
private int edad;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public Persona() {
}
}
Por otro lado, vamos a crearnos una clase aparte para tratar con los ficheros. Ésta clase contendrá el método de leer y el método de escribir. El funcionamiento es muy sencillo. Trataremos siempre con un ArrayList de Personas. Se lo pasaremos como parámetro a la función de escribir en fichero. Por otro lado, la función de leer de fichero nos devolverá un ArrayList de Personas con las personas introducidas en el fichero. Y nos olvidamos de cómo se lee y escribe el fichero o de qué formato tenga. Así de fácil.
public class FicherosIO {
public static final String FILE_NAME = "usuarios.dat";
public void escribirFichero(ArrayList<Persona> usuarios) {
ObjectOutputStream out = null;
try {
out = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
out.writeObject(usuarios);
out.close();
} catch (IOException ex) {
System.out.println(ex.getMessage());
} finally {
if (out != null) {
try {
out.close();
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
}
}
public ArrayList<Persona> leerFichero() {
// comprobar si el fichero existe, si no existe, lo creamos
File f = new File(FILE_NAME);
if (!f.exists()) {
try {
f.createNewFile();
} catch (IOException ex) {
Logger.getLogger(Fichero.class.getName()).log(Level.SEVERE, null, ex);
}
}
ObjectInputStream in = null;
ArrayList<Persona> lista;
try {
//primero se leen los datos que se almacenaron en el fichero; los datos de entrada
in = new ObjectInputStream(new FileInputStream(FILE_NAME));
lista = (ArrayList<Persona>) (in.readObject());
return lista;
} catch (Exception e) {
System.out.println(e.getMessage());
return new ArrayList<Persona>();
} finally {
//hay que asegurarse de cerrar el fichero para que los dados realmente se guarden
if (in != null) {
try {
in.close();
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
}
}
}
Por último, recordad que existe un "peligro" y es que si tenemos un fichero ya creado y modificamos la clase guardada, es decir, la clase Persona, Java se armará un lio con la versión de las clases y no será capaz de leer la lista de Personas del fichero, ya que no reconocerá su definición de la clase Persona, como la que se encuentra en el fichero. Por lo tanto, este sistema tiene esta debilidad. Las clases deben permanecer inmodificables una vez los ficheros han sido escritos con una versión.
