Java: Archivos

Índice Introducción Manejo básico de archivos Archivos properties

Introducción

Introducción (I) Cualquier programa realizado en Java que necesite llevar a cabo una operación de I/O lo hará a través de un stream. Un stream, cuya traducción literal es "flujo", es una abstracción de todo aquello que permite introducir o extraer información. Así, un stream de teclado es un flujo de entrada para el programa y un stream de pantalla es un flujo de salida del programa Input: Teclado Output: Pantalla La vinculación de este stream al dispositivo físico (teclado, pantalla, archivo, impresora, etc.) la hace el sistema de entrada y salida de Java.

Introducción (II) El paquete System define tres clases: in (entrada estándar) out (salida estándar) err (salida de errores estándar) La escritura hacia pantalla se hace con System.out System.out.println(“Hola Mundo”); // Añade nueva línea al final System.out.print(“Adios”); // NO añade nueva línea al final La lectura desde teclado se hace con System.in Para archivos tendremos flujos de: Entrada (input stream), lectura de archivo Salida (output stream), escritura de archivo

Del byte al buffer: el ejemplo del teclado Un flujo importante en este tipo de problemas es InputStream, que es una clase abstracta para el flujo de entradas de bytes sin estructura. Es una superclase de todas las demás clases de flujo de entrada y proporciona una interfaz básica. El sistema Java incluye un InputStream básico para entradas por teclado: System.in Pero necesitamos algo más sofisticado que un sistema de lectura de bytes sin estructura. Para ello vamos a utilizar flujos que reciben un flujo de entrada de bytes y lo convierten en flujos estructurados (modo caracter). Un ejemplo es InputStreamReader, que sirve de puente desde un stream de bytes a un stream de caracteres: InputStreamReader isr = new InputStreamReader( System.in ); Con un InputStreamReader tenemos el método read() para leer caracteres. Pero todavía no es suficiente. Necesitamos otras clases que conviertan el flujo en modo carácter a uno en modo buffer (una cadena de caracteres con señal de fin de línea). Para ello contamos con clases como BufferedReader que recibe en su constructor el flujo de caracteres y maneja el flujo en la forma de buffer, con un método como readLine() que lee los caracteres hasta encontrar un final de línea. Un ejemplo de estas transformaciones (byte-carácter-buffer) se encuentra en el manejo de teclado: BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in)); entrada.readLine(); Flujo de bytes InputStream Flujo de caracteres InputStreamReader Flujo de buffer BufferredReader

Manejo básico de archivos

Del byte al buffer con archivos En el siguiente ejemplo con archivos partimos de un stream de bytes (FileInputStream) A continuación lo convertimos en un stream de caracteres (FileReader). Pero como vamos buscando mayor abstracción (y comodidad) lo convertimos en un flujo en modo buffer (BufferedReader) En este ejemplo obtenemos la primera línea del archivo y la mostramos por pantalla: String linea; try { FileInputStream fis = new FileInputStream("c:/DOC/Java_libre/Figuras/archivos/ejemplo.txt"); BufferedReader entrada = new BufferedReader(new FileReader( fis.getFD() )); linea = entrada.readLine(); System.out.println( linea); } catch (Exception e) { e.printStackTrace(); } Notas: Usamos el paquete java.io El uso de las clases de este paquete normalmente exige el manejo de excepciones Utilizamos rutas absolutas para los archivos, aunque se podrían utilizar rutas relativas en función de la configuración del IDE fis.getFD(): me devuelve el descriptor de archivo (FileDescriptor)

La clase File Lo anterior es demasiado trabajoso, se puede simplificar Trabajar con streams a bajo nivel, como hasta ahora hemos hecho, te da pocos servicios. Por ejemplo, nos puede interesar averiguar si el recurso existe, se puede leer, su tamaño, etc Para ello, los creadores de Java nos han provisto de clases de utilidad, como File. Un ejemplo: File archivo = new File("c:/DOC/Java_libre/Figuras/archivos/ejemplo.txt"); String linea; try { BufferedReader entrada = new BufferedReader(new FileReader(archivo)); if ( archivo.exists() ) System.out.println( "El archivo " + archivo.getAbsolutePath() + " existe" ); if ( archivo.canRead() ) System.out.println( "El archivo se puede leer" ); System.out.println( "Longitud: " + archivo.length()); linea = entrada.readLine(); System.out.println( "Primera línea: " + linea); } catch (Exception e) { e.printStackTrace(); } Consulte la documentación del JDK, ya que que con File se pueden hacer más cosas: crear directorios, borrar, obtener listas de archivos, etc.

Listado filtrado de archivos (I) En este ejemplo se obtienen todos los archivos de un directorio, que tengan una extensión determinada (java). Nuestro método “Archivador.getArchivos()” nos devuelve un array del tipo File: File archivos[]=Archivador.getArchivos("c:/DOC/Java_libre/Figuras/src/figuras/dominio", "java"); if ( archivos != null ) for ( int i = 0; i < archivos.length; i++ ) System.out.println( archivos[i].getName()); A continuación en nuestro método creamos un objeto del tipo File que hace referencia al directorio Después llamamos al método listFiles(), que nos pide como argumento una clase que implemente el interfaz java.io.FileFilter public static File[] getArchivos(String nomDirectorio, String extension ) { try { File dir = new File( nomDirectorio ); return dir.listFiles( new FiltroArchivos(extension)); } catch (Exception e) { e.printStackTrace(); return null;

Listado filtrado de archivos (II) Ya sabemos que cuando una clase implementa un interfaz está obligada a implementar todos los métodos del interfaz. En nuestro caso el método accept(). Este método devuelve true si el archivo (parámetro) pasa el filtro: package figuras.persistencia; import java.io.FileFilter; public class FiltroArchivos implements FileFilter { private String extension; public FiltroArchivos( String extension ) { this.extension = extension; } public boolean accept(java.io.File f) { if (!f.isDirectory()) { String name = f.getName().toLowerCase(); return name.endsWith( extension ); return false;

Primer ejemplo Para nuestro proyecto de figuras (consultar capítulos anteriores) vamos a incorporar la capacidad de lectura de un archivo El archivo (“ejemplo.txt”) lo pondremos en un subdirectorio (“archivos”) del directorio de proyectos. En resumen: Figuras/archivos/ejemplo.txt Crearemos la clase figuras.persistencia.Archivador con el método “lectura()”, que por ahora sólo muestra por pantalla cada línea del archivo: public static void lectura( String nomArchivo ) { String linea; try { File archivo = new File( nomArchivo ); BufferedReader entrada = new BufferedReader(new FileReader(archivo)); if ( !archivo.exists() || !archivo.canRead()) System.out.println( “Archivo no disponible”); for (linea=entrada.readLine(); linea != null && linea.length() > 0; linea= entrada.readLine()) System.out.println( "Línea: " + linea); } catch (Exception e) { e.printStackTrace(); } En el for() lo primero que hacemos es leer la primera línea. Siempre comprobamos que lo que devuelve readLine() no es null o vacío.

StringTokenizer Del paquete java.util. Lo que hace: Ejemplo: Recibe una cadena de caracteres Devuelve las subcadenas separadas por el delimitador. El delimitador por defecto es el espacio en blanco Ejemplo: StringTokenizer st = new StringTokenizer("this is a test"); System.out.println( st.countTokens() ); while (st.hasMoreElements()) { System.out.println( (String) st.nextElement()); } En este ejemplo se puede observar que StringTokenizer implementa countTokens(), que nos devuelve el número de tokens disponibles. Es necesario insistir en la palabra “disponible”, ya que la segunda llamada a este método devuelve cero (ya se ha llegado al final y no hay ningún token disponible). Existe un constructor al que se puede pasar como segundo argumento un String que representa al delimitador.

Segundo ejemplo (I) Vamos a enriquecer el ejemplo de las figuras, tratando de crear instancias de la clase Circulo por cada línea del archivo ejemplo.txt (clase, x, y, radio): figuras.dominio.Circulo, 23, 22, 4.5 figuras.dominio.Circulo, 11, 13, 2.21 figuras.dominio.Circulo, 45, 62, 8.99 Vamos a usar el StringTokenizer, para tratar cada línea. Si hay algún error en una línea, no se crea la figura package figuras.persistencia; import figuras.dominio.*; import java.io.File; import java.io.BufferedReader; import java.io.FileReader; import java.util.StringTokenizer; public class Archivador { public static Pagina lectura(String nomArchivo) { Pagina pagina = null; try { File archivo = new File(nomArchivo); BufferedReader entrada = new BufferedReader(new FileReader(archivo)); pagina = new Pagina(); String linea; if (!archivo.exists() || !archivo.canRead()) return null; StringTokenizer st; Circulo circulo = null; //// Leemos linea a linea for (linea = entrada.readLine(); linea != null && linea.length() > 0; linea = entrada.readLine()) { //// Tokenizaremos la linea st = new StringTokenizer(linea, ", "); El segundo argumento del constructor de StringTokenizer representa el delimitador, en nuestro caso es una coma y un espacio en blanco

Segundo ejemplo (II) //// Obtenemos la clase String clase = null; if (st.hasMoreElements()) clase = (String) st.nextElement(); //// Obtenemos el punto Punto posicion = null; int x = -1, y = -1; if (st.hasMoreElements()) { try { x = Integer.parseInt((String) st.nextElement()); } catch (Exception e) {} } y = Integer.parseInt((String) st.nextElement()); if (x != -1 && y != -1) posicion = new Punto(x, y); //// Obtenemos el radio double radio = -1; radio = Double.parseDouble((String) st.nextElement()); Los try-catch internos controlan que, en caso de error en una conversión (parseXX()), no se detenga la ejecución del programa Antes de acabar el for() que recorre las líneas: si no hay errores, creamos el círculo y lo agregamos a la página Al final se devuelve la página (si no se ha podido leer el archivo, devuelve null) //// Creamos la figura si no hay errores if (clase != null && posicion != null && radio != -1) { circulo = new Circulo(radio, posicion); pagina.agregar(circulo); } } // FIN DE FOR } catch (Exception e) { e.printStackTrace(); return null; return pagina;

Segundo ejemplo (III) El método main() es muy breve debido al grado de encapsulamiento de la aplicación: Si falla la lectura del archivo : la página puede ser null Una precaución: para gestionar el caso en el que la página sea null, el método VistaFiguras.mostrar() es: public static void mostrar( Pagina pag ) { if ( pag == null ) { System.out.println("Error al intentar mostrar la página"); return; } for ( int i = 0; i < pag.tamanio(); i++ ) { Figura fig = pag.obtener(i); System.out.println( fig.toString() ); public static void main(String[] args) { Pagina pagina = Archivador.lectura("c:/DOC/Java_libre/Figuras/archivos/ejemplo.txt"); VistaFiguras.mostrar(pagina); }

Escritura de archivos Seguimos la misma lógica de streams de byte-carácter-buffer Usamos: write( String ): escribe la cadena en el flujo newLine(): escribe señal de nueva línea en el flujo close(): vierte (flush) el contenido del flujo en el archivo y lo cierra Seguimos con el ejemplo de las figuras. Implementamos el método que obtiene las figuras (sólo círculos) de la página y las escribe en el archivo: public static boolean escritura( Pagina pagina, String nomArchivo ) { try { if ( pagina == null ) return false; BufferedWriter salida = new BufferedWriter(new FileWriter(nomArchivo)); Circulo cir; String linea; for ( int i = 0; i < pagina.tamanio(); i++ ) { cir = (Circulo) pagina.obtener(i); linea = cir.getClass().getName() + ", " + cir.getPosicion().getX() + ", " + cir.getPosicion().getY() + ", " + cir.getRadio(); salida.write( linea ); salida.newLine(); } salida.close(); return true; } catch (Exception e) { Con getClass().getName() obtenemos el nombre completo de la clase (incluye paquete)

Archivos properties

Las propiedades Java incorpora estructuras de datos en la forma de propiedad=valor, usando archivos con extensión .properties Normalmente sirven para información de configuración Ejemplo: directorio= c:/DOC/Java_libre/Figuras/src/figuras/dominio extension=java Ventaja: podremos cambiar el directorio y extensión en el archivo properties, sin necesidad de cambiar y recompilar el código fuente

Carga de propiedades (I) Java incorpora una estructura de datos para almacenar las propiedades: la clase java.util.Properties Por un momento nos olvidamos del archivo y veamos como se crean propiedades, se incorporan a un Properties y se recuperan con “String getProperty()”: java.util.Properties prop = new java.util.Properties(); prop.setProperty("directorio", "c:/DOC/Java_libre/Figuras/src/figuras/dominio"); prop.setProperty("extension", "java"); System.out.println( prop.getProperty("directorio") ); Volvamos a los archivos, cargar las propiedades en un objeto del tipo Properties es muy sencillo, simplemente tenemos que llamar al método load(), que nos solicita como argumento un InputStream

Carga de propiedades (II) En nuestro ejemplo hemos creado una clase especialmente pensada para cargar las propiedades de un archivo y poder consultarlas: package figuras.persistencia; import java.util.Properties; import java.io.File; /*************************************************************************** * Lee los valores de un archivo .properties ***************************************************************************/ public class LectorPropiedades { private Properties prop = new Properties(); /*** Carga en atributo 'prop' el archivo de propiedades ***/ public boolean cargar(String archivoPropiedades) { try { File archivo = new File(archivoPropiedades); // Abro prop.load(archivo.toURL().openStream()); // Cargo propiedades return true; } catch (Exception e) { return false; } /*** Método que recupera el valor de una propiedad o clave del atributo 'prop'. Si no la encuentra, devuelve el parámetro 'defecto ***/ public String getParametro(String clave, String defecto) { String retorno = defecto; if (prop == null) return defecto; retorno = prop.getProperty(clave, defecto); } catch (Exception e) {} return retorno; /*** Sobrecargado. Si no encuentra clave, devuelve "“***/ public String getParametro(String clave) { return getParametro(clave, "");

Consulta del valor de una propiedad Desde nuestro main() la carga y consulta de propiedades resulta bastante sencilla: LectorPropiedades lector = new LectorPropiedades(); if ( !lector.cargar("c:/DOC/Java_libre/Figuras/archivos/configuracion.properties") ) { System.out.println( "No se ha cargado el archivo de propiedades“ ); return; } System.out.println( lector.getParametro("directorio") ); System.out.println( lector.getParametro("extension") );