====== Ficheros ======

===== Tipos de ficheros =====

Desde el punto de vista de un programador solamente distinguiremos entre dos tipos de ficheros:

  * **Ficheros de texto** cuando el contenido del fichero contenga exclusivamente caracteres de texto (podemos leerlo con un simple editor de texto)

^ Extensión  ^ Tipo de fichero        |
| .txt       | Fichero de texto plano |
| .xml       | Fichero XML   |
| .json       | Fichero de intercambio de información   |
| .props       | Fichero de propiedades   |
| .conf       | Fichero de configuración   |
| .sql       | Script SQL   |
| .srt       | Fichero de subtítulo   |

  * **Ficheros binarios** cuando no estén compuestos exclusivamente de texto. Pueden contener imágenes, videos, ficheros, . . . aunque también podemos considerar un fichero binario a un fichero de Microsoft Word en el que sólo hayamos escrito algún texto puesto que, al almacenarse el fichero, el procesador de texto incluye alguna información binaria

^ Extensión  ^ Tipo de fichero        |
| .pdf       | Fichero PDF |
| .jpg       | Fichero de imagen   |
| .doc, .docx       | Fichero de Microsoft Word   |
| .avi       | Fichero de video   |
| .ppt, .pptx       | Fichero de PowerPoint   |

A veces, en ficheros binarios, podremos encontrarnos con las extensiones //.bin// o //.dat// para hacer referencia a ficheros que contienen información binaria en un formato que no está ampliamente difundido. Serán simplemente ficheros que una aplicación determinada es capaz de leer/escribir de una forma específica solo definida para dicha aplicación.

===== System Properties =====

En cualquier caso, para el acceso a ficheros independientemente del tipo de los mismos, conviene conocer el funcionamiento de las [[https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html|System Properties]] de las que dispone Java en su API. Éstas permiten acceder a propiedades de la configuración del sistema y, entre otras, podemos encontrarnos con algunas muy interesantes relacionadas con este tema:
  * ''"file.separator"'' Obtiene el caracter, según el S.Operativo, para la separación de las rutas (''/'' ó ''\''). También se puede utilizar la constante ''File.separator''
  * ''"user.home"'' Obtiene la ruta de la carpeta personal del usuario (que dependerá del S.Operativo en casa caso)
  * ''"user.dir"'' Obtiene la ruta en la que se encuentra actualmente el usuario
  * ''"line.separator"'' Obtiene el caracter que separa las líneas de un fichero de texto (difiere entre Windows/Linux)

En el caso de que se quiera acceder al valor de alguna de estas propiedades debe hacerse utilizando la llamada al método ''System.getProperty(String)''

<code java>
System.out.println("La carpeta de mi usuario es " + System.getProperty("user.home"));
</code> 
===== Ficheros de texto ======

En esta parte vamos a trabajar con 3 tipos de ficheros de texto: 

  * **Ficheros de texto plano** que contendrán texto //libre// y donde podremos escribir sin respetar ningún tipo de formato
  * **Ficheros de configuración** que contendrán información de configuración para una aplicación. Tienen un formato específico y Java además proporciona una API para trabajar más cómodamente con ellos
  * **Ficheros XML** que contienen información y acompañada de etiquetas que le dan significado. Tienen unas reglas y formato más o menos definido y Java proporciona una API para trabajar con ellos

Existen más tipos de ficheros de texto también muy extendidos como //.json// y //.csv// pero no serán estudiados en esta parte.
==== Ficheros de texto plano =====

Los ficheros de texto son aquellos que únicamente contienen texto, por lo que pueden ser editados directamente con cualquier editor de texto plano (Bloc de Notas, notepad++, . . .). Se podría decir que son aquellos ficheros que podrían ser //leídos// por cualquier persona. Son aquellos que normalmente se almacenan con la extensión //.txt// pero también podríamos incluir los scripts SQL (//.sql//), ficheros de código Java (//.java//), ficheros de configuración (//.ini//, //.props//, //.conf//, . . .), . . .

También se incluyen en la categoría de ficheros de texto los que además incluyen información adicional (siempre en forma de texto) que permiten interpretar los datos del fichero de una manera u otra, añadiendo más información al mismo. Estos formatos son HTML, XML, JSON, . . .

En cualquier caso, desde Java siempre se podrán leer/escribir de la misma manera, según veremos a continuación. También veremos como pueden leerse/escribirse utilizando librerías aquellos ficheros de texto plano que contienen formato, como hemos comentado anteriormente, haciendo de esa forma mucho más fácil el trabajo.

=== Escribir ficheros de texto plano ===

<code java>
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) { . . . }
}
</code>

=== Leer ficheros de texto plano ===

<code java>
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) { . . . }
}
</code>

==== Ficheros de configuración ====

En la API de Java se incluyen librerías para trabajar con los ficheros de configuración. Puesto que todos siguen un mismo patrón, es la librería la que se encarga de acceder al fichero a bajo nivel y el programador sólo tiene que indicar a que propiedad quiere acceder o que propiedad quiere modificar, sin tener que añadir nada de código para leer o escribir el fichero tal y como hemos visto en el punto anterior.

Un ejemplo de fichero de configuración de esta librería de java sería el fichero que sigue:

<file properties configuracion.props>
# Fichero de configuracion
# Thu Nov 14 10:49:39 CET 2013

user=usuario
password=micontrasena
server=localhost
port=3306
</file>

=== Escribir ficheros de configuración ===

Así, si queremos generar, desde Java, un fichero de configuración como el anterior:

<code java>
. . .
Properties configuracion = new Properties();
configuracion.setProperty("user", miUsuario);
configuracion.setProperty("password", miContrasena);
configuracion.setProperty("server", elServidor);
configuracion.setProperty("port", elPuerto);
try {
  configuracion.store(new FileOutputStream("configuracion.props"), 
                                           "Fichero de configuracion");
} catch (FileNotFoundException fnfe ) { 
  fnfe.printStackTrace(); 
} catch (IOException ioe) { 
  ioe.printStackTrace();
}
. . .
</code>

=== Leer ficheros de configuración ===

A la hora de leerlo, en vez de tener que recorrer todo el fichero como suele ocurrir con los ficheros de texto, simplemente tendremos que cargarlo e indicar de qué propiedad queremos obtener su valor (''getProperty(String)'').

<code java>
. . .
Properties configuracion = new Properties();
try {
  configuracion.load(new FileInputStream("configuracion.props"));
  usuario = configuracion.getProperty("user");
  password = configuracion.getProperty("password");
  servidor = configuracion.getProperty("server");
  puerto = Integer.valueOf(configuration.getProperty("port"));
} catch (FileNotFoundException fnfe ) { 
  fnfe.printStackTrace();
} catch (IOException ioe) { 
  ioe.printStackTrace();
}
. . .
</code>

Para ambos casos, escribir y leer este tipo de ficheros, hay que tener en cuenta que, al tratarse de ficheros de texto, toda la información se almacena como si de un ''String'' se tratara. Por tanto, todos aquellos tipos ''Date'', ''boolean'' o incluso cualquier tipo numérico serán almacenados en formato texto. Así, habrá que tener en cuenta las siguientes consideraciones:

  * Para el caso de las fechas, deberán ser convertidas a texto cando se quieran escribir y nuevamente reconvertidas a ''Date'' cuando se lea el fichero y queramos trabajar con ellas
  * Para el caso de los tipos ''boolean'', podemos usar el método ''String.valueOf(boolean)'' para pasarlos a ''String'' cuando queramos escribirlos. En caso de que queramos leer el fichero y pasar el valor a tipo ''boolean'' podremos usar el método ''Boolean.parseBoolean(String)''
  * Para el caso de los tipos numéricos (''integer'', ''float'', ''double'') es muy sencillo ya que Java los convertirá a ''String'' cuando sea necesario al escribir el fichero. En el caso de que queramos leerlo y convertirlos a su tipo concreto, podremos usar los métodos ''Integer.parseInt(String)'', ''Float.parseFloat(String)'' y ''Double.parseDouble()'', según proceda
==== Ficheros XML ====

Los ficheros XML permiten el intercambio de información entre aplicaciones utilizando para ello un fichero de texto plano al que se le pueden añadir etiquetas para darle significado a cada uno de los valores que se almacenan.

Por ejemplo, el siguiente fichero XML podría ser el resultado de volcar una Base de Datos sobre productos de una compañia, de forma que dicha información podría ahora leerse desde otra aplicación e incorporarla. Se puede ver como a parte de los datos de dichos productos (sus nombres, precios, . . .) aparece otra información en forma de etiquetas (entre los caracteres ''<'' y ''>'') que permite dar significado a cada dato almacenado en el fichero. Así, podemos saber de qué estamos hablando y a qué corresponde cada valor.

Obviamente, tal y como ocurría con los ficheros de configuración, toda la información se tiene que pasar a texto para poder crear el fichero y reconvertida a su tipo original cuando se cargue de nuevo. Las mismas consideraciones que hemos tenido en cuenta antes nos servirán ahora (ver [[http://datos.codeandcoke.com/apuntes:ficheros#ficheros_de_configuracion|aqui]])

<file xml productos.xml>
<?xml version="1.0" encoding="UTF-8" standalone="no">
<xml>
<productos>
  <producto>
    <nombre>Cereales</nombre>
    <precio>3.45</precio>
  </producto>
  <producto>
    <nombre>Colacao</nombre>
    <precio>1.45</precio>
  </producto>
  <producto>
    <nombre>Agua mineral</nombre>
    <precio>1.00</precio>
  </producto>
</productos>
</xml>
</file>

La clase Java que definiría cada uno de los objetos que se representan por el fichero XML anterior, sería la siguiente:

<file java Producto.java>
public class Producto {
  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; }
}
</file>

=== Escribir ficheros XML ===

Si ahora queremos generar el fichero XML con toda la información de una colección de objetos //Producto//, podemos utilizar el siguiente código:

<code java>
. . .
documento = dom.createDocument(null, "xml", null);
Element raiz = document.createElement("productos");
documento.getDocumentElement().appendChild(raiz);
Element nodoProducto = null , nodoDatos = null ;
Text texto = null;

for (Producto producto : listaProductos) {
  nodoProducto = documento.createElement("producto");
  raiz.appendChild(nodoProducto);
  nodoDatos = documento.createElement("nombre");
  nodoProducto.appendChild(nodoDatos);
  texto = documento.createTextNode(producto.getNombre());
  nodoDatos.appendChild(texto);
  nodoDatos = documento.createElement("precio");
  nodoProducto.appendChild(nodoDatos);
  texto = documento.createTextNode(producto.getPrecio());
  nodoDatos.appendChild(texto);
}
. . .
</code>

=== Leer ficheros XML ===

Y si lo que queremos es leer un fichero XML y cargarlo como una colección Java de objetos //Producto//, el ejemplo siguiente muestra un breve ejemplo acerca de cómo acceder a la información de dicho fichero XML.

<code java>
. . .
NodeList productos = documento.getElementyByTagName("producto");
for (int i = 0; i < productos.getLength(); i++) {
  Node producto = productos . item ( i ) ;
  Element elemento = ( Element ) producto ;
  System.out.println(elemento.getElementsByTagName("nombre").item(0)
                     .getChildNodes().item(0).getNodeValue());
  System.out.println(elemento.getElementsByTagName("precio").item(0)
                     .gethildNodes().item(0).getNodeValue());
}
. . .
</code>
===== Ficheros binarios =====

<file java Producto.java>
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; }
}
</file>
==== Serialización de objetos ====

//Serializar// es el proceso por el cual un objeto en memoria pasa a transformarse en una estructura que pueda ser almacenada en un fichero (persistencia). Al proceso contrario le llamaremos //deserializar//.

Hay que tener en cuenta que durante el proceso de serialización, cada objeto se serializa a un fichero, por lo que si queremos almacenar todos los objetos de una aplicación, la idea más conveniente es tener todos éstos en alguna estructura compleja (y por comodidad dinámica) de forma que sea esta estructura la que serialicemos o deserialicemos para guardar o cargar los objetos de una aplicación. Estructuras como ''ArrayList'', ''Set'' ó ''HashMap'' son clases muy utilizadas para trabajar de esta manera. 

=== Serializar un objeto ===

<code java>
. . .
ObjectOutputStream serializador = null;
try {
  serializador = new ObjectOutputStream(new FileOutputStream("archivo.dat"));
  serializador.writeObject(listaProductos);
} catch (IOException ioe) { 
  . . .
} finally {
  if (serializador != null)
    try {
      serializador.close();
    } catch (IOException ioe) {
      ioe.printStackTrace();
    }
  }
. . .
</code>

=== Deserializar un objeto ===

<code java>
. . .
List<Producto> listaProductos = null;
ObjectInputStream deserializador = null;
try {
  deserializador = new ObjectInputStream(new FileInputStream("archivo.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();
  }
}
. . .
</code>

===== Paquete Java NIO 2 =====

No includo desde siempre, el paquete Java NIO 2, mejora las clases y métodos disponibles para trabajar con ficheros, sistemas de ficheros y todo lo relacionado con entrada/salida.

==== FileSystems ====

Es una factoría que permite acceder a un sistema de ficheros:
  * //static FileSystem getDefault()//: Devuelve el sistema de ficheros por defecto

==== FileSystem ====

Representa un sistema de ficheros

  * //Path getPath(String first, String. . . more)//: Convierte una ruta en un objeto Path
  * //String getSeparator()//: Devuelve el separador de diretorio del sistema de ficheros
  * //FileSystemProvider getProvider()//: Devuelve el proveedor del sistema de ficheros

==== Paths ====

Contiene métodos estáticos para obtener objetos Path a partir de cadenas 
  * //static Path get(String first, String... more)//

==== Path ====

Representa un fichero dentro del sistema de ficheros.
Podemos acceder al fichero y a su información a través de las propiedades y métodos de la clase
  * //boolean endsWith(String string)//
  * //boolean endsWith(Path path)//
  * //int getNameCount()//
  * //Path getParent()//
  * //boolean startsWith(String string)//
  * //File toFile()//
  * //String toString()//

==== Files ====

Contiene métodos estáticos que operan con ficheros y directorios
  * //static long copy(. . .)//
  * //static Path createFile(. . .)//
  * //static void delete(. . .)//
  * //static boolean deleteIfExists(Path path)//
  * //static Stream<String> lines(Path path)//
  * //static Stream<Path> list(Path dir)//
  * //static List<String> readAllLines(Path path)//
  * //static List<String> readAllLines(Path path, Charset cs)//
  * //static String readString(Path path)//
  * //static long size(Path path)//
  * //static Stream<Path> walk(Path start, int maxDepth, FileVisitOption... options)//
  * //static Stream<Path> walk(Path start, FileVisitOption. . . options)//

----

(c) 2019-{{date>%Y}} Santiago Faci