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/16 19:48] – Santiago Faci | apuntes:ficheros [2023/05/28 12:12] (current) – [Files] Santiago Faci | ||
---|---|---|---|
Line 1: | Line 1: | ||
====== Ficheros ====== | ====== Ficheros ====== | ||
- | ===== Crear ficheros | + | ===== Tipos de ficheros |
- | La manera más cómoda y habitual | + | Desde el punto de vista de un programador solamente distinguiremos entre dos tipos de ficheros: |
+ | |||
+ | * **Ficheros | ||
+ | |||
+ | ^ Extensión | ||
+ | | .txt | Fichero de texto plano | | ||
+ | | .xml | Fichero XML | | ||
+ | | .json | Fichero de intercambio de información | ||
+ | | .props | ||
+ | | .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 | ||
+ | | .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 | ||
+ | |||
+ | ===== System Properties ===== | ||
+ | |||
+ | En cualquier caso, para el acceso | ||
+ | * ''" | ||
+ | * ''" | ||
+ | * ''" | ||
+ | * ''" | ||
+ | |||
+ | 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 (// | ||
+ | |||
+ | 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> | <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) { . . . } |
+ | } | ||
</ | </ | ||
- | ===== Leer ficheros de texto ===== | + | === Leer ficheros de texto plano === |
- | + | ||
- | Para realizar la operación de lectura de un fichero de texto línea a línea utilizaremos la clase '' | + | |
- | + | ||
- | 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 '' | + | |
<code java> | <code java> | ||
Line 34: | 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) { . . . } |
} | } | ||
</ | </ | ||
- | ===== 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 |
- | 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> |
+ | # Fichero de configuracion | ||
+ | # Thu Nov 14 10:49:39 CET 2013 | ||
+ | |||
+ | user=usuario | ||
+ | password=micontrasena | ||
+ | server=localhost | ||
+ | port=3306 | ||
+ | </ | ||
+ | |||
+ | === Escribir ficheros de configuración === | ||
+ | |||
+ | Así, si queremos | ||
<code java> | <code java> | ||
- | public class Producto implements Serializable { | + | . . . |
- | | + | Properties configuracion |
- | | + | configuracion.setProperty(" |
- | | + | configuracion.setProperty(" |
+ | configuracion.setProperty(" | ||
+ | configuracion.setProperty(" | ||
+ | try { | ||
+ | configuracion.store(new FileOutputStream(" | ||
+ | " | ||
+ | } catch (FileNotFoundException fnfe ) { | ||
+ | fnfe.printStackTrace(); | ||
+ | } catch (IOException ioe) { | ||
+ | ioe.printStackTrace(); | ||
+ | } | ||
+ | . . . | ||
+ | </ | ||
- | public Producto(String nombre, float precio) { | + | === Leer ficheros de configuración === |
- | this.nombre | + | |
- | this.precio | + | |
- | } | + | |
- | public String getNombre() { return nombre; } | + | 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 ('' |
- | public void setNombre(String | + | |
- | public float getPrecio() { return precio | + | <code java> |
- | | + | . . . |
+ | Properties configuracion = new Properties(); | ||
+ | try { | ||
+ | configuracion.load(new FileInputStream(" | ||
+ | | ||
+ | password = configuracion.getProperty(" | ||
+ | servidor | ||
+ | puerto = Integer.valueOf(configuration.getProperty(" | ||
+ | } catch (FileNotFoundException fnfe ) { | ||
+ | fnfe.printStackTrace(); | ||
+ | } catch (IOException ioe) { | ||
+ | ioe.printStackTrace(); | ||
} | } | ||
+ | . . . | ||
</ | </ | ||
- | Las clases Java como '' | + | 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 |
+ | |||
+ | * Para el caso de las fechas, deberán ser convertidas a texto cando se quieran escribir | ||
+ | * 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 | ||
+ | |||
+ | Por ejemplo, el siguiente fichero XML podría ser el resultado | ||
+ | |||
+ | 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 float getPrecio () { return precio; } | ||
+ | public void setPrecio (float precio) { this.precio = precio; } | ||
+ | } | ||
+ | </ | ||
- | ==== Serializar objetos ==== | + | === Escribir ficheros XML === |
- | Si suponemos que '' | + | 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 | ||
+ | |||
+ | <code java> | ||
+ | . . . | ||
+ | NodeList | ||
+ | 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.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; } | ||
+ | } | ||
+ | </ | ||
+ | ==== Serialización | ||
+ | |||
+ | // | ||
+ | |||
+ | Hay que tener en cuenta que durante el proceso | ||
+ | |||
+ | === Serializar un objeto === | ||
<code java> | <code java> | ||
Line 87: | Line 289: | ||
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(); |
- | } | + | |
} | } | ||
+ | } | ||
. . . | . . . | ||
</ | </ | ||
- | ==== Deserializar | + | === Deserializar |
- | + | ||
- | En el momento en que quiera recuperar esos datos almcenados en '' | + | |
<code java> | <code java> | ||
Line 111: | Line 311: | ||
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(); |
- | } | + | } |
} | } | ||
. . . | . . . | ||
</ | </ | ||
+ | |||
+ | ===== 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.1550346523.txt.gz · Last modified: 2019/02/16 19:48 by Santiago Faci