Archivos Binarios en Java

Un fichero binario o de datos est formado por secuencias de bytes. Estos archivos pueden contener datos de tipo bsico (int, float, char, etc) y objetos. Para poder leer el contenido de un fichero binario debemos conocer la estructura interna del fichero, es decir, debemos saber cmo se han escrito: si hay enteros, long, etc. y en qu orden estn escritos en el fichero. Si no se conoce su estructura podemos leerlo byte a byte ESCRIBIR DATOS EN FICHEROS BINARIOS Para escribir datos en un fichero binario utilizaremos las clases Java FileOutputStream y DataOutputStream derivadas de OutputStream. FileOutputStream La clase FileOutputStream permite tener acceso al fichero para escribir bytes. Para crear objetos FileOutputStream podemos utilizar los constructores: FileOutputStream (String ruta) FileOutputStream (File objetoFile); FileOutputStream (String ruta, boolean append) FileOutputStream (File objetoFile, boolean append) Si el parmetro append es true significa que los datos se van a aadir a los existentes. Si es false los datos existentes se pierden. Si se utiliza uno de los dos primeros constructores los datos existentes se pierden. Los constructores lanzan una excepcin FileNotFoundException si no existe y no se ha podido crear el fichero. La clase FileOutputStream proporciona el mtodo write() para escribir bytes en el fichero. Este mtodo lanza una IOException. DataOutputStream A partir de un objeto FileOutputStream se puede crear un objeto DataOutputStream, que proporciona mtodos para escribir datos de tipo primitivo en el fichero. Para crear un objeto DataOutputStream se utiliza el constructor: DataOutputStream(OutputStream nombre); La clase proporciona mtodos writeXxx() donde Xxx es el nombre del tipo primitivo. Lanzan una IOException EJEMPLOS JAVA DE ESCRITURA EN FICHEROS BINARIOS Ejemplo 1: Programa que lee enteros por teclado y los escribe en el fichero datos.dat. La lectura de datos acaba cuando se introduce -1. import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Scanner;

public class Binarios1 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); FileOutputStream fos = null; DataOutputStream salida = null; int n; try { fos = new FileOutputStream("/ficheros/datos.dat"); salida = new DataOutputStream(fos); System.out.print("Introduce nmero entero. -1 para acabar: "); n = sc.nextInt(); while (n != -1) { salida.writeInt(n); //se escribe el nmero entero en el fichero System.out.print("Introduce nmero entero. -1 para acabar: "); n = sc.nextInt(); } } catch (FileNotFoundException e) { System.out.println(e.getMessage()); } catch (IOException e) { System.out.println(e.getMessage()); } finally { try { if (fos != null) { fos.close(); } if (salida != null) { salida.close(); } } catch (IOException e) { System.out.println(e.getMessage()); } } } } Ejemplo 2: Programa Java que crea una matriz de elementos de tipo double y lee por teclado el valor de sus elementos. A continuacin escribe el contenido de la matriz en un fichero. Al principio del fichero se escriben dos enteros con los valores del nmero de filas y columnas de la matriz. import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Scanner;

public class Binarios2 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); FileOutputStream fos = null; DataOutputStream salida = null; double[][] matriz;

int filas, columnas, i, j; do{ System.out.print("Nmero de filas: "); filas = sc.nextInt(); }while(filas<=0); do{ System.out.print("Nmero de columnas: "); columnas = sc.nextInt(); }while(columnas<=0); matriz = new double[filas][columnas]; //se crea la matriz for (i = 0; i < filas; i++) { //lectura de datos por teclado for (j = 0; j < columnas; j++) { System.out.print("matriz[" + i + "][" + j + "]: "); matriz[i][j] = sc.nextDouble(); } } try { //crear el fichero de salida fos = new FileOutputStream("/ficheros/matriz.dat"); salida = new DataOutputStream(fos); //escribir el nmero de filas y columnas en el fichero salida.writeInt(filas); salida.writeInt(columnas); //escribir la matriz en el fichero for (i = 0; i < filas; i++) { for (j = 0; j < columnas; j++) { salida.writeDouble(matriz[i][j]); } } } catch (FileNotFoundException e) { System.out.println(e.getMessage()); } catch (IOException e) { System.out.println(e.getMessage()); } finally { try { if (fos != null) { fos.close(); } if (salida != null) { salida.close(); } } catch (IOException e) { System.out.println(e.getMessage()); } } } } LECTURA DE FICHEROS BINARIOS Para leer de un fichero binario utilizaremos las clases Java FileInputStream y DataInputStream derivadas de InputStream. FileInputStream La clase FileInputStream permite leer bytes de un fichero.

Para crear objetos FileInputStream podemos utilizar los constructores: FileInputStream (String ruta) FileInputStream (File objetoFile); Ambos lanzan una excepcin FileNotFoundException si el fichero no existe. La clase proporciona el mtodo read() para leer bytes del fichero. El mtodo read lanza una excepcin IOException. DataInputStream A partir de un objeto FileInputStream podemos crear un objeto DataInputStream para leer datos de tipo primitivo. Para crear un objeto DataInputStream se utiliza el constructor: DataInputStream (InputStream nombre); La clase proporciona mtodos readXxx() donde Xxx es el nombre del tipo primitivo. Lanzan una excepcin IOException. Cuando un mtodo readXxx() alcanza el final del fichero lanza una excepcin EOFException.

EJEMPLOS JAVA DE LECTURA DE FICHEROS BINARIOS Ejemplo 3: Programa que lee el contenido del fichero creado en el Ejemplo 1. Utilizaremos un bucle infinito para leer los datos. Cuando se llega al final del fichero se lanza la excepcin EOFException que se utiliza para salir del bucle while. import java.io.DataInputStream; import java.io.EOFException; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class Binarios3 { public static void main(String[] args) { FileInputStream fis = null; DataInputStream entrada = null; int n; try { fis = new FileInputStream("/ficheros/datos.dat"); entrada = new DataInputStream(fis); while (true) { n = entrada.readInt(); //se lee un entero del fichero System.out.println(n); //se muestra en pantalla } } catch (FileNotFoundException e) { System.out.println(e.getMessage()); } catch (EOFException e) { System.out.println("Fin de fichero"); } catch (IOException e) { System.out.println(e.getMessage()); } finally { try { if (fis != null) { fis.close();

} if (entrada != null) { entrada.close(); } } catch (IOException e) { System.out.println(e.getMessage()); } } } }

Ejemplo 4: Programa Java que lee el contenido del fichero creado en el Ejemplo 2 y lo muestra por pantalla. import java.io.DataInputStream; import java.io.EOFException; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class Binarios4 { public static void main(String[] args) { FileInputStream fis = null; DataInputStream entrada = null; int filas, columnas, i, j; try { fis = new FileInputStream("/ficheros/matriz.dat"); entrada = new DataInputStream(fis); filas = entrada.readInt(); //se lee el primer entero del fichero columnas = entrada.readInt();//se lee el segundo entero del fichero for (i = 0; i < filas; i++) { for (j = 0; j < columnas; j++) { // se leen los double y se muestran por pantalla System.out.printf("%8.2f", entrada.readDouble()); } System.out.println(); } } catch (FileNotFoundException e) { System.out.println(e.getMessage()); } catch (EOFException e) { System.out.println("Fin de fichero"); } catch (IOException e) { System.out.println(e.getMessage()); } finally { try { if (fis != null) { fis.close(); } if (entrada != null) { entrada.close(); } } catch (IOException e) { System.out.println(e.getMessage()); } } } }

Archivos de Texto en Java

La primera clase que se muestra a continuacin se encarga de almacenar en un archivo de texto alguna cosa que quieras, en este caso es una variable que ya tiene un valor, bien podria ser mas interactivo, ejemplo: 1. 2. 3. Que se pida el dato por consola Que de opciones para guardar algunas cosas Etc. jeje

La segunda clase muestra como leer el contenido de un archivo de texto, trabajar con el nombre del archivo de la clase anterior. El objetivo es utilizar clases para escribir sobre archivo [Binarios o de texto] y usar accesos secuenciales o aleatorios para obtener el contenido de los archivos [Binarios o de Texto]. A mi se me facilito el uso de archivos de texto y por eso uso en los ejemplos las clases: File (Para crear el archivo) FileWriter (Para escribir sobre el archivo) FileReader (Para leer el archivo)

El metodo write de la clase FileWriter es el que se encarga de escribir sobre el archivo de texto. Para no hacer largo esto, aqui estan las clases:
/*Clase que permite escribir en un archivo de texto*/ //Importamos clases que se usaran import java.io.File; import java.io.FileWriter; public class Escribir { public static void main(String []args) { //Un texto cualquiera guardado en una variable String saludo="Hola"; try { //Crear un objeto File se encarga de crear o abrir acceso a un archivo que se especifica en su constructor File archivo=new File("texto.txt"); //Crear objeto FileWriter que sera el que nos ayude a escribir sobre archivo FileWriter escribir=new FileWriter(archivo,true); //Escribimos en el archivo con el metodo write escribir.write(saludo); //Cerramos la conexion escribir.close(); } //Si existe un problema al escribir cae aqui catch(Exception e) { System.out.println("Error al escribir"); } } } /*Clase que permite leer un archivo de texto*/

//Importamos clases a usar import java.io.FileReader; import java.io.BufferedReader; public class Leer { public static void main(String arg[]) { //Creamos un String que va a contener todo el texto del archivo String texto=""; try { //Creamos un archivo FileReader que obtiene lo que tenga el archivo FileReader lector=new FileReader("texto.txt"); //El contenido de lector se guarda en un BufferedReader BufferedReader contenido=new BufferedReader(lector); //Con el siguiente ciclo extraemos todo el contenido del objeto "contenido" y lo mostramos while((texto=contenido.readLine())!=null) { System.out.println(texto); } } //Si se causa un error al leer cae aqui catch(Exception e) { System.out.println("Error al leer"); } } }

Archivos de Acceso Aleatorio en Java

Ejemplo 1: Escribir un mtodo que reciba por parmetro un array de valores enteros correspondientes a referencias a artculos y un array de valores reales correspondientes a los precios de los artculos anteriores. El mtodo recibir tambin el nombre de un archivo sobre el que se escribir cada referencia de artculo seguida de su precio. No capturar ninguna excepcin. (Con RandomAccessFile) import java.io.File; import java.io.RandomAccessFile; public class _2x2x05 { public static void metodo(int[] ref, double[] precio, String ruta) { try { RandomAccessFile raf = new RandomAccessFile(new File(ruta), "rw"); for( int i = 0 ; i < ref.length ; i++ ) { raf.writeInt(ref[i]); raf.writeByte('\t'); raf.writeDouble(precio[i]); raf.writeByte('\n'); } raf.close(); } catch( Exception e ) { e.printStackTrace(); } } public static void main(String[] args) { int[] ref = { 1001, 1002, 1003, 1004 }; double[] precio = { 10.3, 15.2, 5.02, 151.99 }; String ruta = "tienda.txt"; metodo(ref, precio, ruta); } }

Ejemplo 2: Escribir un mtodo que reciba por parmetro el nombre de un archivo que almacena una serie de referencias y precios de artculos y muestre su contenido por pantalla. (Con RandomAccessFile) import java.io.EOFException; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; public class _2x2x06 { public static void metodo(String[] args) { RandomAccessFile raf = null; boolean finFichero = false; try { raf = new RandomAccessFile(new File(args[0]), "r"); do { try { System.out.print(raf.readInt() + " "); raf.seek(raf.getFilePointer() + 1); System.out.println(raf.readDouble()); raf.seek(raf.getFilePointer() + 1); } catch( EOFException e ) { finFichero = true; raf.close(); } } while( !finFichero ); } catch( FileNotFoundException e ) { System.out.println("El archivo no existe"); } catch( IOException e ) { System.out.println("Se produjo un error con el archivo"); } } public static void main(String[] args) { String[] argumentos = { "tienda.txt" }; metodo(argumentos); } }

Ejemplo 3: Escribir un mtodo que reciba por parmetro el nombre de un archivo que almacena una serie de referencias y precios de artculos y actualice los precios de forma que los superiores a 100 euros se decrementen en un 50% y los inferiores se incrementen en un 50%. El mtodo capturar y tratar todas las excepciones que puedan producirse. (Con RandomAccessFile) import java.io.EOFException; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; public class _2x2x07 { public static void metodo(String[] args) { RandomAccessFile raf = null; boolean finFichero = false; double eur; try { raf = new RandomAccessFile(new File(args[0]), "rw"); do { try { raf.seek(raf.getFilePointer() + Integer.SIZE / 8 + Byte.SIZE / 8); eur = raf.readDouble(); if( eur > 100 ) eur *= 1.5; else eur /= 1.5; raf.seek(raf.getFilePointer() - Double.SIZE / 8); raf.writeDouble(eur); raf.seek(raf.getFilePointer() + Byte.SIZE / 8); } catch( EOFException e ) { finFichero = true; raf.close(); } } while( !finFichero ); } catch( FileNotFoundException e ) { System.out.println("El archivo no existe"); } catch( IOException e ) { System.out.println("Se produjo un error con el archivo"); } } public static void main(String[] args) { String[] argumentos = { "tienda.txt" }; metodo(argumentos); } }