Java SE, persistencia en ficheros

Hola jabatos:

Cuando la capa de datos consiste en un almacenamiento en ficheros, entonces emplearemos la java io biblioteca. Esta API incluye las clases necesarias para las labores de entrada y salida relacionadas con ficheros.

Los flujos de entrada y salida de datos los podemos dividir en flujos de datos raw (bytes) o datos de caracteres unicode. Nos centraremos en estos últimos.

Los flujos de caracteres se pueden leer mediante las clases de tipo Reader, y se pueden escribir y/o modificar mediante clases tipo Writer.

Para leer un fichero de manera eficiente podemos utilizar las clases FileReader y BufferedReader; para escritura, podemos utilizar FileWriter y BufferedWriter. La utilización de buffers optimizará los flujos de entrada y salida, por ejemplo, permitiendo leer y/o escribir de línea en línea en lugar de hacerlo de carácter en carácter.

He aquí algo de código que muestra la diferencia en una lectura:

Ejemplo con BufferedReader
try {
   FileReader reader=new FileReader("file.txt");
   BufferedReader buff=new BufferedReader(reader);
   try {
      String lineRead=buff.readLine();
      while (lineRead!=null) {
         // lo que corresponda hacer con la lectura de línea
      }
   } catch (IOException ex1) {
   } finally {
      buff.close();
   }
} catch (IOException ex2) {
}

Ejemplo sin BufferedReader
try {
   FileReader reader=new FileReader("file.txt");
   try {
      int charRead=reader.read();
      while (charRead!=-1) {
         // lo que corresponda hacer con el carácter leído
      }
   } catch (IOException ex1) {
   } finally {
      reader.close();
   }
} catch (IOException ex2) {
}

La diferencia de utilizar buffer y de no hacerlo es, no solo la optimización de los procesos de E/S, sino un mejor manejo de la información. Sin el buffer, tendremos que comprobar la longitud de las líneas, y procesar los caracteres uno a uno hasta encontrar un fin de línea. Ni es óptima la lectura ni es óptimo el manejo. En el caso de escritura/reescritura, las ventajas del buffer son incluso mayores.

Los objetos StringReader y StringWriter nos sirven para crear objetos String con la misma metodología con las que crearíamos objetos FileReader o FileWriter. Por lo tanto hablaríamos de leer/escribir en memoria en lugar de hacerlo en ficheros.

Normalmente, cuando operamos con ficheros hemos de asegurarnos de:

• Comprobar que el fichero existe.
• Es legible o reescribible, o ejecutable, etc., o sea, manipulable.
• Capturar las excepciones que pudieran producirse.
• Trabajar con buffers, que optimizan las operaciones I/O.

Si quisiéramos borrar un fichero, podemos utilizar:

try {   
   Files.delete(path+file);
} catch (NoSuchFileException x) {
} catch (DirectoryNotEmptyException x) {
} catch (IOException x) {
}

Podemos comprobar si existe un fichero mediante el método exists():

File fichero=new File("fichero.txt");
if (!fichero.exists()) {
  try {
fichero.createNewFile();
 } catch (IOException e) {
 }
}

En este ejemplo, si el fichero "fichero.txt" no existe procede a crearlo.

Los objetos persistidos solo crean campos con los datos que se almacenan. Los métodos y constructores no serán persistidos. Si algún objeto no es serializable, debe marcarse como "transient" para evitar que se provoque una excepción al persistirlo.

Podemos serializar objetos mediante las clases FileOutputStream y ObjectOutputStream.writeObject(). La lectura usa las clases FileInputStream y ObjectInputStream.readObject(). En el caso de la lectura hay que hacer un casting, porque se recibe un objeto de clase object.

En el ejemplo JavaSE: aplicación MVC - III se puede ver un caso práctico del manejo de ficheros de caracteres según lo expuesto en este post.

Anterior tema                                                                                         Siguiente tema