La manera más cómoda y habitual de crear ficheros de texto es hacerlo línea a línea con la clase PrintWriter

FileWriter fichero = null;
PrintWriter escritor = null;
 
try { 
    fichero = new FileWriter("archivo.txt");
    escritor = new PrintWriter(fichero) ;
    escritor.println("Esto es una linea del fichero");
} catch (IOException ioe) {
    ioe.printStackTrace() ;
} finally {
    if (fichero != null)
        try {
            fichero.close();
        } catch (IOException ioe) { . . . }

Para realizar la operación de lectura de un fichero de texto línea a línea utilizaremos la clase BufferedReader, recorriendo el fichero mientras haya líneas en él.

En el ejemplo que se muestra, cada línea se muestra por pantalla, pero hay que tener en cuenta que podríamos almacenarlas todas en un solo String para almacenar su contenido o bien cargarlo en la pantalla para su visualización (y quizás posterior edición).

File fichero = null;
FileReader lector = null;
BufferedReader buffer = null;
 
try {
    buffer = new BufferedReader(new FileReader(new File("archivo.txt")));
    String linea = null;
    while ((linea = buffer.readLine()) != null)
        System.out.println(linea);
} catch (FileNotFoundException fnfe) {
    fnfe.printStackTrace();
} catch (IOException ioe) {
    ioe.printStackTrace();
} finally {
    if (buffer != null)
        try {
            buffer.close();
    } catch (IOException ioe) { . . . }
}

La serialización es el proceso por el que un objeto Java se convierte en una secuencia de bytes, es decir, en un fichero. Es la manera más cómoda y rápida de almacenar en fichero la información de una aplicación Java. Si, por ejemplo, tenemos una serie de objetos como una colección (un ArrayList, por ejemplo) y queremos almacenar toda esa información en un fichero, la forma más sencilla será la de serializar dicho ArrayList, lo que conllevará que se serialice todo su contenido.

Si más adelante queremos recuperar esa información, podremos deserializar la colección desde el fichero y volver a trabajar con los datos.

Simplemente tendremos que tener en cuenta que las clases que nosotros nos hayamos definido deben implementar el interfaz Serializable para que pueda ser serializadas en un fichero. Así, si tuvieramos una clase Producto que queremos que luego sea serializada, haríamos lo siguiente:

public class Producto implements Serializable {
    private static final long serialVersionUID = 1L;
    private String nombre;
    private float precio;
 
    public Producto(String nombre, float precio) {
        this.nombre = nombre;
        this.precio = precio;
    }
 
    public String getNombre() { return nombre; }
    public void setNombre(String nombre) { this.nombre = nombre; }
 
    public float getPrecio() { return precio ; }
    public void setPrecio(float precio) { this.precio = precio; }
}

Las clases Java como ArrayList, String, y otras, ya están definidas como Serializable por lo que no tendremos que preocuparnos por ellas a la hora de serializar nuestra colección de productos a un fichero.

Si suponemos que listaProductos es, por ejemplo, una colección de productos, podemos serializar el objeto en un fichero llamado productos.dat, de forma que podrá ser recuperado en otra ejecución de la misma ejecución, habiendo almacenado así los datos en el disco duro. Es lo que se conoce como persistencia.

. . .
ObjectOutputStream serializador = null;
try {
    serializador = new ObjectOutputStream(new FileOutputStream("productos.dat"));
    serializador.writeObject(listaProductos);
} catch (IOException ioe) { 
    . . .
} finally {
    if (serializador != null)
        try {
            serializador.close();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }
. . .

En el momento en que quiera recuperar esos datos almcenados en productos.dat, sólo tengo que realizar la operación contraria y podré recuperar la colección original y seguir trabajando con ella.

. . .
List<Producto> listaProductos = null;
ObjectInputStream deserializador = null;
try {
    deserializador = new ObjectInputStream(new FileInputStream("productos.dat"));
    listaProductos = (ArrayList<Producto>)deserializador.readObject();
} catch (FileNotFoundException fnfe ) {
    fnfe.printStackTrace();
} catch (ClassNotFoundException cnfe ) { 
    cnfe.printStackTrace();
} catch (IOException ioe) { 
    ioe.printStackTrace();
} finally {
    if (deserializador != null)
        try {
            deserializador.close();
        } catch (IOException ioe) { 
            ioe.printStackTrace();
        }
}
. . .

© 2019 Santiago Faci