apuntes:ficheros
Differences
This shows you the differences between two versions of the page.
Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
apuntes:ficheros [2019/02/14 22:13] – Santiago Faci | apuntes:ficheros [2023/05/28 12:12] (current) – [Files] Santiago Faci | ||
---|---|---|---|
Line 1: | Line 1: | ||
====== Ficheros ====== | ====== Ficheros ====== | ||
- | \part*{Ficheros} | + | ===== Tipos de ficheros ===== |
- | \section{Acceso a ficheros | + | Desde el punto de vista de un programador solamente distinguiremos entre dos tipos de ficheros: |
- | \subsection{Crear ficheros | + | * **Ficheros |
- | La manera más cómoda y habitual | + | ^ Extensión |
+ | | .txt | Fichero | ||
+ | | .xml | Fichero XML | | ||
+ | | .json | Fichero de intercambio de información | ||
+ | | .props | ||
+ | | .conf | Fichero de configuración | ||
+ | | .sql | Script SQL | | ||
+ | | .srt | Fichero de subtítulo | ||
- | \begin{lstlisting}[language=java] | + | * **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 | ||
+ | | .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/ | ||
+ | |||
+ | ===== System Properties ===== | ||
+ | |||
+ | En cualquier caso, para el acceso a ficheros independientemente del tipo de los mismos, conviene conocer el funcionamiento de las [[https:// | ||
+ | * ''" | ||
+ | * ''" | ||
+ | * ''" | ||
+ | * ''" | ||
+ | |||
+ | En el caso de que se quiera acceder al valor de alguna de estas propiedades debe hacerse utilizando la llamada al método '' | ||
+ | |||
+ | <code java> | ||
+ | System.out.println(" | ||
+ | </ | ||
+ | ===== 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 ficheros de texto plano === | ||
+ | |||
+ | <code java> | ||
FileWriter fichero = null; | FileWriter fichero = null; | ||
PrintWriter escritor = null; | PrintWriter escritor = null; | ||
- | + | ||
- | try { | + | try { |
- | fichero = new FileWriter(" | + | fichero = new FileWriter(" |
- | escritor = new PrintWriter(fichero) ; | + | escritor = new PrintWriter(fichero) ; |
- | escritor.println(" | + | escritor.println(" |
} catch (IOException ioe) { | } catch (IOException ioe) { | ||
- | | + | |
} finally { | } finally { | ||
- | | + | if (fichero != null) |
- | try { | + | try { |
- | fichero.close(); | + | fichero.close(); |
- | } catch (IOException ioe) { . . . } | + | } catch (IOException ioe) { . . . } |
- | \end{lstlisting} | + | } |
- | + | </ | |
- | \subsection{Leer ficheros de texto} | + | |
- | Para realizar la operación de lectura de un fichero | + | === Leer ficheros |
- | 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 | + | < |
- | \verb String | + | |
- | + | ||
- | \begin{lstlisting}[language=java] | + | |
File fichero = null; | File fichero = null; | ||
FileReader lector = null; | FileReader lector = null; | ||
Line 40: | Line 85: | ||
try { | try { | ||
- | | + | |
- | String linea = null; | + | String linea = null; |
- | while ((linea = buffer.readLine()) != null) | + | while ((linea = buffer.readLine()) != null) |
- | System.out.println(linea); | + | System.out.println(linea); |
- | } catch (FileNotFoundException fnfe) { | + | } catch (FileNotFoundException fnfe) { |
- | fnfe.printStackTrace(); | + | fnfe.printStackTrace(); |
- | } catch (IOException ioe) { | + | } catch (IOException ioe) { |
- | ioe.printStackTrace(); | + | ioe.printStackTrace(); |
} finally { | } finally { | ||
- | | + | |
- | try { | + | try { |
- | buffer.close(); | + | buffer.close(); |
- | } catch (IOException ioe) { . . . } | + | } catch (IOException ioe) { . . . } |
} | } | ||
- | \end{lstlisting} | + | </ |
- | \section{Serialización} | + | ==== Ficheros de configuración ==== |
- | La serialización es el proceso por el que un objeto | + | En la API de Java se incluyen librerías para trabajar con los ficheros |
- | cómoda y rápida | + | |
- | colección (un \verb ArrayList , por ejemplo) y queremos almacenar toda esa información | + | |
- | serializar dicho \verb ArrayList , lo que conllevará que se serialice todo su contenido. | + | |
- | Si más adelante queremos recuperar esa información, | + | Un ejemplo de fichero de configuración de esta librería de java sería |
- | Simplemente tendremos que tener en cuenta que las clases que nosotros nos hayamos definido deben implementar el interfaz | + | <file properties configuracion.props> |
- | \verb Serializable | + | # Fichero de configuracion |
- | serializada, | + | # Thu Nov 14 10:49:39 CET 2013 |
- | \begin{lstlisting}[language=java] | + | user=usuario |
- | public class Producto implements Serializable { | + | password=micontrasena |
- | | + | server=localhost |
- | | + | port=3306 |
- | | + | </ |
- | public Producto(String nombre, float precio) { | + | === Escribir ficheros de configuración === |
- | this.nombre | + | |
- | this.precio | + | |
- | } | + | |
- | public String getNombre() { return nombre; } | + | Así, si queremos generar, desde Java, un fichero de configuración como el anterior: |
- | public void setNombre(String nombre) { this.nombre = nombre; } | + | |
- | | + | <code java> |
- | public void setPrecio(float precio) { this.precio = precio; } | + | . . . |
+ | Properties configuracion = new Properties(); | ||
+ | configuracion.setProperty(" | ||
+ | configuracion.setProperty(" | ||
+ | configuracion.setProperty(" | ||
+ | configuracion.setProperty(" | ||
+ | try { | ||
+ | configuracion.store(new FileOutputStream(" | ||
+ | " | ||
+ | } catch (FileNotFoundException fnfe ) { | ||
+ | fnfe.printStackTrace(); | ||
+ | } catch (IOException ioe) { | ||
+ | ioe.printStackTrace(); | ||
+ | } | ||
+ | . . . | ||
+ | </ | ||
+ | |||
+ | === 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 ('' | ||
+ | |||
+ | <code java> | ||
+ | . . . | ||
+ | Properties configuracion = new Properties(); | ||
+ | try { | ||
+ | configuracion.load(new FileInputStream(" | ||
+ | usuario = configuracion.getProperty(" | ||
+ | password = configuracion.getProperty(" | ||
+ | servidor = configuracion.getProperty(" | ||
+ | puerto = Integer.valueOf(configuration.getProperty(" | ||
+ | } catch (FileNotFoundException fnfe ) { | ||
+ | fnfe.printStackTrace(); | ||
+ | } catch (IOException ioe) { | ||
+ | ioe.printStackTrace(); | ||
+ | } | ||
+ | . . . | ||
+ | </ | ||
+ | |||
+ | 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 '' | ||
+ | |||
+ | * Para el caso de las fechas, deberán ser convertidas a texto cando se quieran escribir y nuevamente reconvertidas a '' | ||
+ | * Para el caso de los tipos '' | ||
+ | * Para el caso de los tipos numéricos ('' | ||
+ | ==== 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 ''<'' | ||
+ | |||
+ | Obviamente, tal y como ocurría con los ficheros de configuración, | ||
+ | |||
+ | <file xml productos.xml> | ||
+ | <?xml version=" | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | </ | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | </ | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | </ | ||
+ | |||
+ | 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 void setPrecio (float precio) { this.precio = precio; } | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | === Escribir ficheros XML === | ||
+ | |||
+ | Si ahora queremos generar el fichero XML con toda la información de una colección de objetos // | ||
+ | |||
+ | <code java> | ||
+ | . . . | ||
+ | documento = dom.createDocument(null, | ||
+ | Element raiz = document.createElement(" | ||
+ | documento.getDocumentElement().appendChild(raiz); | ||
+ | Element nodoProducto = null , nodoDatos = null ; | ||
+ | Text texto = null; | ||
+ | |||
+ | for (Producto producto : listaProductos) { | ||
+ | nodoProducto = documento.createElement(" | ||
+ | raiz.appendChild(nodoProducto); | ||
+ | nodoDatos = documento.createElement(" | ||
+ | nodoProducto.appendChild(nodoDatos); | ||
+ | texto = documento.createTextNode(producto.getNombre()); | ||
+ | nodoDatos.appendChild(texto); | ||
+ | nodoDatos = documento.createElement(" | ||
+ | nodoProducto.appendChild(nodoDatos); | ||
+ | texto = documento.createTextNode(producto.getPrecio()); | ||
+ | nodoDatos.appendChild(texto); | ||
+ | } | ||
+ | . . . | ||
+ | </ | ||
+ | |||
+ | === Leer ficheros XML === | ||
+ | |||
+ | Y si lo que queremos es leer un fichero XML y cargarlo como una colección Java de objetos // | ||
+ | |||
+ | <code java> | ||
+ | . . . | ||
+ | NodeList productos = documento.getElementyByTagName(" | ||
+ | for (int i = 0; i < productos.getLength(); | ||
+ | Node producto = productos . item ( i ) ; | ||
+ | Element elemento = ( Element ) producto ; | ||
+ | System.out.println(elemento.getElementsByTagName(" | ||
+ | | ||
+ | System.out.println(elemento.getElementsByTagName(" | ||
+ | | ||
+ | } | ||
+ | . . . | ||
+ | </ | ||
+ | ===== 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.precio = precio; | ||
+ | } | ||
+ | |||
+ | public String getNombre() { return nombre; } | ||
+ | public void setNombre(String nombre) { this.nombre = nombre; } | ||
+ | |||
+ | public float getPrecio() { return precio ; } | ||
+ | | ||
} | } | ||
- | \end{lstlisting} | + | </ |
+ | ==== Serialización de objetos ==== | ||
- | Las clases Java como \verb ArrayList , \verb String , y otras, ya están definidas como \verb Serializable | + | // |
- | preocuparnos por ellas a la hora de serializar nuestra colección de productos a un fichero. | + | |
- | \subsection{Serializar | + | Hay que tener en cuenta que durante el proceso de serialización, |
- | Si suponemos que \verb listaProductos | + | === Serializar |
- | \emph{productos.dat}, | + | |
- | disco duro. Es lo que se conoce como persistencia. | + | |
- | \begin{lstlisting}[language=java] | + | < |
. . . | . . . | ||
ObjectOutputStream serializador = null; | ObjectOutputStream serializador = null; | ||
try { | try { | ||
- | | + | |
- | serializador.writeObject(listaProductos); | + | serializador.writeObject(listaProductos); |
} catch (IOException ioe) { | } catch (IOException ioe) { | ||
- | | + | |
} finally { | } finally { | ||
- | | + | |
- | try { | + | try { |
- | serializador.close(); | + | serializador.close(); |
- | } catch (IOException ioe) { | + | } catch (IOException ioe) { |
- | ioe.printStackTrace(); | + | ioe.printStackTrace(); |
- | } | + | |
} | } | ||
+ | } | ||
. . . | . . . | ||
- | \end{lstlisting} | + | </ |
- | \subsection{Deserializar | + | === Deserializar |
- | En el momento en que quiera recuperar esos datos almcenados en \emph{productos.dat}, | + | < |
- | recuperar la colección original y seguir trabajando con ella. | + | |
- | + | ||
- | \begin{lstlisting}[language=java] | + | |
. . . | . . . | ||
List< | List< | ||
ObjectInputStream deserializador = null; | ObjectInputStream deserializador = null; | ||
try { | try { | ||
- | | + | |
- | listaProductos = (ArrayList< | + | listaProductos = (ArrayList< |
} catch (FileNotFoundException fnfe ) { | } catch (FileNotFoundException fnfe ) { | ||
- | | + | |
} catch (ClassNotFoundException cnfe ) { | } catch (ClassNotFoundException cnfe ) { | ||
- | | + | |
} catch (IOException ioe) { | } catch (IOException ioe) { | ||
- | | + | |
} finally { | } finally { | ||
- | | + | |
- | try { | + | try { |
- | deserializador.close(); | + | deserializador.close(); |
- | } catch (IOException ioe) { | + | } catch (IOException ioe) { |
- | ioe.printStackTrace(); | + | ioe.printStackTrace(); |
- | } | + | } |
} | } | ||
. . . | . . . | ||
- | \end{lstlisting} | + | </ |
+ | |||
+ | ===== 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/ | ||
+ | |||
+ | ==== FileSystems ==== | ||
+ | |||
+ | Es una factoría que permite acceder a un sistema de ficheros: | ||
+ | * //static FileSystem getDefault()//: | ||
+ | |||
+ | ==== FileSystem ==== | ||
+ | |||
+ | Representa un sistema de ficheros | ||
+ | |||
+ | * //Path getPath(String first, String. . . more)//: Convierte una ruta en un objeto Path | ||
+ | * //String getSeparator()//: | ||
+ | * // | ||
+ | |||
+ | ==== 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< | ||
+ | * //static Stream< | ||
+ | * //static List< | ||
+ | * //static List< | ||
+ | * //static String readString(Path path)// | ||
+ | * //static long size(Path path)// | ||
+ | * //static Stream< | ||
+ | * //static Stream< | ||
---- | ---- | ||
- | (c) 2019 Santiago Faci | + | (c) 2019-{{date> |
apuntes/ficheros.1550182437.txt.gz · Last modified: 2019/02/14 22:13 by Santiago Faci