Fichero o Archivo

Los programas usan variables para almacenar informacin: los datos de entrada, los resultados
calculados y valores intermedios generados a lo largo del clculo. Toda esta informacin es
efmera, cuando acaba el programa, todo desaparece. Pero, para muchas aplicaciones, es
importante poder almacenar datos de manera permanente. Cuando se desea guardar informacin
ms all del tiempo de ejecucin de un programa lo habitual es organizar esa informacin en uno
o varios ficheros almacenados en algn soporte de almacenamiento persistente. Otras
posibilidades como el uso de bases de datos utilizan archivos como soporte para el
almacenamiento de la informacin.
Archivos en java

En Java, los distintos tipos de ficheros se diferencian por las clases que usaremos para
representarlos y manipularlos. Como las clases que usaremos pertenecen a la biblioteca estndar
del lenguaje, su uso es algo ms complejo que las de las clases de la ACM, ya que su diseo se ha
realizado pensando en su uso industrial. Las clases que usaremos para el tratamiento de ficheros
estn ubicadas en el paquete java.io por lo que deben ser importadas. Adems, el cdigo que trabaja
con archivos ha de considerar que muchas cosas pueden ir mal cuando se trabaja con ellos: el
archivo puede estar corrupto, alguien ha desconectado el pendrive a medio ejecutar del programa,
es un disco en red y sta ha cado, o no tiene ms espacio para almacenar informacin, etc. Es por
ello que, aunque de forma breve, deberemos introducir el mecanismo estndar en Java para tratar
con los errores que pueden darse en nuestro programas.

Sabemos que es diferente manipular nmeros que Strings, aunque en el fondo ambos acaben siendo
bits en la memoria del ordenador. Por eso, cuando manipulamos archivos, distinguiremos dos
clases de archivos dependiendo del tipo de datos que contienen:

Los archivos de caracteres (o de texto)

Los archivos de bytes (o binarios)
Un fichero de texto es aqul formado exclusivamente por caracteres y que, por tanto, puede crearse
y visualizarse usando un editor. Las operaciones de lectura y escritura trabajarn con caracteres.
Por ejemplo, los ficheros con cdigo java son ficheros de texto. En cambio un fichero binario ya
no est formado por caracteres sino que los bytes que contiene pueden representar otras cosas
como nmeros, imgenes, sonido, etc.

El criterio del acceso

Existen dos modos bsicos de acceso a la informacin contenida en un archivo:

Secuencial
Acceso directo
En el modo secuencial la informacin del archivo es una secuencia de bytes (o caracteres) de
manera que para acceder al byte (o carcter) iXsimo se ha de haber accedido anteriormente a los
iX1 anteriores. Un ejemplo de acceso secuencial lo hemos visto con la clase StringTokenizer.
El modo de acceso directo nos permite acceder directamente a la informacin del byte iXsimo.
Un ejemplo muy conocido de acceso directo lo tenemos con los vectores (arrays).
Lectura de un fichero en java
Podemos abrir un fichero de texto para leer usando la clase FileReader. Esta clase tiene mtodos
que nos permiten leer caracteres. Sin embargo, suele ser habitual querer las lneas completas, bien
porque nos interesa la lnea completa, bien para poder analizarla luego y extraer campos de
ella. FileReader no contiene mtodos que nos permitan leer lneas completas, pero
s BufferedReader. Afortunadamente, podemos construir un BufferedReader a partir
del FileReader de la siguiente forma:
File archivo = new File ("C:\\archivo.txt");
FileReader fr = new FileReader (archivo);
BufferedReader br = new BufferedReader(fr);
...
String linea = br.readLine();

La apertura del fichero y su posterior lectura pueden lanzar excepciones que debemos capturar.
Por ello, la apertura del fichero y la lectura debe meterse en un bloque try-catch.
Adems, el fichero hay que cerrarlo cuando terminemos con l, tanto si todo ha ido bien como si
ha habido algn error en la lectura despus de haberlo abierto. Por ello, se suele poner al try-
catch un bloque finally y dentro de l, el close() del fichero.
El siguiente es un cdigo completo con todo lo mencionado.

import java.io.*;

class LeeFichero {
public static void main(String [] arg) {
File archivo = null;
FileReader fr = null;
BufferedReader br = null;

try {
// Apertura del fichero y creacion de BufferedReader para poder
// hacer una lectura comoda (disponer del metodo readLine()).
archivo = new File ("C:\\archivo.txt");
fr = new FileReader (archivo);
br = new BufferedReader(fr);

// Lectura del fichero

String linea;
while((linea=br.readLine())!=null)
System.out.println(linea);
}
catch(Exception e){
e.printStackTrace();
}finally{
// En el finally cerramos el fichero, para asegurarnos
 // que se cierra tanto si todo va bien como si salta
// una excepcion.
try{
if( null != fr ){
fr.close();
}
}catch (Exception e2){
e2.printStackTrace();
}
}
}
}

Escritura de un fichero en java

El siguiente cdigo escribe un fichero de texto desde cero. Pone en l 10 lneas
import java.io.*;

public class EscribeFichero

{
public static void main(String[] args)
{
FileWriter fichero = null;
PrintWriter pw = null;
try
{
fichero = new FileWriter("c:/prueba.txt");
pw = new PrintWriter(fichero);

for (int i = 0; i < 10; i++)

pw.println("Linea " + i);

} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// Nuevamente aprovechamos el finally para
// asegurarnos que se cierra el fichero.
if (null != fichero)
fichero.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
Si queremos aadir al final de un fichero ya existente, simplemente debemos poner un flag a true
como segundo parmetro del constructor de FileWriter.

FileWriter fichero = new FileWriter("c:/prueba.txt",true);

Ficheros binarios

Para ficheros binarios se hace exactamente igual, pero en vez de usar los "Reader" y los "Writer",
se usan los "InputStream" y los "OutputStream". En lugar de los readLine() y println(), hay que
usar los mtodos read() y write() de array de bytes.

El siguiente ejemplo hace una copia binaria de un fichero

package chuidiang.ejemplos;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CopiaFicheros {

public static void main(String[] args) {

copia ("c:/ficheroOrigen.bin", "c:/ficheroDestino.bin");
}

public static void copia (String ficheroOriginal, String ficheroCopia)

{
try
{
// Se abre el fichero original para lectura
FileInputStream fileInput = new FileInputStream(ficheroOriginal);
BufferedInputStream bufferedInput = new BufferedInputStream(fileInput);

// Se abre el fichero donde se har la copia

FileOutputStream fileOutput = new FileOutputStream (ficheroCopia);
BufferedOutputStream bufferedOutput = new
BufferedOutputStream(fileOutput);

// Bucle para leer de un fichero y escribir en el otro.

byte [] array = new byte[1000];
int leidos = bufferedInput.read(array);
while (leidos > 0)
 {
bufferedOutput.write(array,0,leidos);
leidos=bufferedInput.read(array);
}
// Cierre de los ficheros
bufferedInput.close();
bufferedOutput.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}

Buffering

El concepto de buffering queda muy bien explicado en el siguiente prrafo extrado del libro Head
First Java:
Si no hubiera buffers, sera como comprar sin un carrito: debera
llevar los productos uno a uno hasta la caja. Los buffers te dan un
lugar en el que dejar temporalmente las cosas hasta que est lleno.
Por ello has de hacer menos viajes cuando usas el carrito.

Cualquier operacin que implique acceder a memoria externa es muy costosa, por lo que es
interesante intentar reducir al mximo las operaciones de lectura/escritura que realizamos sobre
los ficheros, haciendo que cada operacin lea o escriba muchos caracteres. Adems, eso tambin
permite operaciones de ms alto nivel, como la de leer una lnea completa y devolverla en forma
de cadena.