Indice

Java: Archivos

Indice

Índice

• Introducción• Manejo básico de archivos• Archivos properties

2

Indice

Introducción

Indice

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

4

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.

Indice

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

5

Indice

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();

6

Flujo de bytes

InputStream

Flujo de caracteres

InputStreamReader

Flujo de buffer

BufferredReader

Indice

Manejo básico de archivos

Indice

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)

8

Indice

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.

9

Indice

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; }

10

Indice

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; }

}

11

Indice

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.

12

Indice

StringTokenizer• Del paquete java.util. Lo que hace:

– 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());}System.out.println( st.countTokens() );

• 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.

13

Indice

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.5figuras.dominio.Circulo, 11, 13, 2.21figuras.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

14

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

Indice

Segundo ejemplo (II)• 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)

15

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

}

if (st.hasMoreElements()) {

try {

y = Integer.parseInt((String) st.nextElement());

} catch (Exception e) {}

}

if (x != -1 && y != -1)

posicion = new Punto(x, y);

//// Obtenemos el radio

double radio = -1;

if (st.hasMoreElements()) {

try {

radio = Double.parseDouble((String) st.nextElement());

} catch (Exception e) {}

}

//// 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;

}

}

Indice

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() ); } }

16

public static void main(String[] args) {

Pagina pagina = Archivador.lectura("c:/DOC/Java_libre/Figuras/archivos/ejemplo.txt");

VistaFiguras.mostrar(pagina);

}

Indice

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) { return false; } } 17

Con getClass().getName() obtenemos el nombre completo de la clase (incluye paquete)

Indice

Archivos properties

Indice

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/dominioextension=java

• Ventaja: podremos cambiar el directorio y extensión en el archivo properties, sin necesidad de cambiar y recompilar el código fuente

19

Indice

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

20

Indice

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; try { 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, ""); }}

21

Indice

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") );

22