Archivos que uo sou de texto

DatalnputStream y DataOutputStream son clases de Java 1.0 que un lian sido alteradas hasta ahora. 

Para leer y escribir datos primitivos directamente (sin convertir a/de String) siguen siendo más útiles estas dos clases. Son clases diseñadas para trabajar de manera conjunta. Una puede leer lo que la otra escribe, que en sí no es algo legible, sino el dato como una secuencia de bytes. Por ello se utilizan para almacenar datos de manera independiente de la plataforma (o para mandarlos por una red entre ordenadores muy distintos). El problema es que obligan a utilizar clases que descienden de InpntStream y OutputStream y por lo tanto algo más complicadas de utilizar. El siguiente código primero escribe en el fichero prueba.dat para después leer los datos escritos:

// Escritura de una variable double
DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(

new FileOutputStream("prueba.dat"))) ;
double di = 17/7;
dos.writeDouble(d);
dos.cióse();

// Lectura de la variable double
DatalnputStream dis = new DatalnputStream(
new Bufferedlnputstream(

new FilelnputStream("prueba.dat")));
double d2 = dis.readDouble();

Escritura de archivos de texto

La clase PrintWriter es la más práctica para escribir un archivo de texto porque posee los métodos />ri«í(cualquier tipo) y />r?7rf/n(cualquier tipo), idénticos a los de System.out (de clase PrintStream). 

Un objeto PrintWriter se puede crear a partir de un BufferedWriter (para disponer de buffer), que se crea a partir del FileWriter al que se la pasa el nombre del archivo. Después, escribir en el archivo es tan fácil como en pantalla. El siguiente ejemplo ilustra lo anterior:

try {

FileWriter fw = new FileWriter("escribeme.txt");
BufferedWriter bw = new BufferedWriter(fw);
PrintWriter salida = new PrintWriter(bw);
salida.println("Hola, soy la primera linea");
salida.cióse ();
// Modo append

bw = new BufferedWriter(new FileWriter("escribeme.txt", true));

salida = new PrintWriter(bw);

salida.print("Y yo soy la segunda. ");

double b = 123.45;

salida.println(b);

salida.cióse();

}

cacth(java.io.IOException idex) { }

Lectura ele archivos de texto

Se puede crear un objeto BufferedReader para leer de un archivo de texto de la siguiente manera:

BufferedReader br = new BufferedReader(new FileReader("archivo.txt"));

Utilizando el objeto de tipo BufferedReader se puede conseguir exactamente lo mismo que en las secciones anteriores utilizando el método readLine() y la clase StringTokenizer. En el caso de archivos es muy importante utilizar el buffer puesto que la tarea de escribir en disco es muy lenta respecto a los procesos del programa y realizar las operaciones de lectura de golpe y una de una en lina hace mucho más eficiente el acceso. Por ejemplo:

// Lee un archivo entero de la misma manera que de teclado
String texto = new String();
try {

FileReader fr = new FileReader("archivo.txt");
entrada = new BufferedReader(fr);
String s;

while((s = entrada.readLine()) != nuil)

texto += s;
entrada.cióse();

}

catch(java.io.FileNotFoundException fnfex) {

System.out.println("Archivo no encontrado: " + fnfex);}
catch(java.io.IOException ioex) {}

LECTURA DE UN ARCHIVO EN UN SERVIDOR DE INTERNET

Teniendo la dilección de Internet de un archivo, la librería de Java permite leer este archivo utilizando 1111 stream. Es una aplicación muy sencilla que muestra la polivalencia del concepto de stream. 

En el package java.net existe la clase URL. que representa una dirección de Internet. Esta clase tiene el método InputStream openStream(URL dir) que abre un stream con origen en la dirección de Internet. A partir de ahí. se trata como cualquier elemento InputStream. 

Por ejemplo: //Lectura del archivo (texto HTML) URL dirección = new URL("http://wwwl.ceit.es/subdir/MiPagina.htm");

String s = new String();
String html = new String();
try {

BufferedReader br = new BufferedReader(

new InputStreamReader(

dirección.openStream()));
while((s = br.readLine()) != nuil)

html += s + '\n¹;
br.close ();

}

catch(Exception e) {

System.err.println (e);

}

Clases File y FileDialog - II

Una forma típica de preguntar por un archivo es presentar un caja de diálogo. La clase java.awt.FileDialog presenta el diálogo típico de cada sistema operativo para guardar o abrir ficheros. Sus constructores son:

FileDialog(Frame fr)

FileDialog(Frame fr, String title)

FileDialog(Frame fr, String title, int type)

donde type puede ser FileDialog.LOAD o FileDialog.SAVE según la operación que se desee realizar. Es muy fácil conectar este diálogo con un Fitf. utilizando los métodos String getFi!e() y String getDirectoryO. Por ejemplo:

FileDialog fd = new FileDialog(f, "Elija un archivo");
fd.show();

File f = new File(fd.getDirectory(), fd.getFile());

Clases File y FileDialog - I

Un objeto de la clase File puede representar un archivo o un directorio. Tiene los siguientes constructores:

File(String name)

File(String dir, String name)

File(File dir, String name).

Se puede dar el nombre de un archivo, el nombre y el directorio, o sólo el directorio, como path absoluto y como path relativo al directorio actual. Para saber si el archivo existe se puede llamar al método boolean exists().

File fl = new File ("c: WwindowsWnotepad.exe"); // La barra *\' se escribe
File f2 = new File("c:\\windows");    // Un directorio

File f3 = new File(f2, "notepad.exe");  // Es igual a fl

Si File representa un archivo que existe los métodos de la Tabla 9.6 dan información de él.

LECTURA Y ESCRITURA DE ARCHIVOS

Aunque el manejo de archivos tiene características especiales, se puede utilizar lo dicho hasta ahora para las entradas y salidas estándar con pequeñas variaciones. Java ofrece las siguientes posibilidades: 

Existen las clases FileInputStream\ y FileOutputStream (extendiendo InputStream y OutputStream) que permiten leer y escribir bytes en archivos. Para archivos de texto son preferibles FileReader (desciende de Reader) y FileWriter (desciende de Writer). que realizan las mismas funciones. Se puede construir un objeto de cualquiera de estas cuatro clases a partir de un Stríng que contenga el nombre o la dirección en disco del archivo o con un objeto de la clase File que representa dicho archivo. Por ejemplo el código

FileReader frl = new FileReader("archivo.txt");

es equivalente a:

File f = new File("archivo.txt"); 

FileReader fx2 = new FileReader(f); 

Si no encuentran el archivo indicado, los constructores de FileReader y FilelnputStream pueden lanzar la excepción java.io.FileNotFoundException. Los constructores de FileWriter y FileOutputStream pueden lanzar java. io.IOExeeption. Si no encuentran el archivo indicado, lo crean nuevo. Por defecto, estas dos clases comienzan a escribir al comienzo del archivo. Para escribir detrás de lo que ya existe en el archivo ("append*'), se utiliza un segundo argumento de tipo boolean con valor true\ 

FileWriter fw = new FileWriter("archivo.txt", true);

Las clases que se explican a continuación permiten un manejo más fácil y eficiente que las vistas hasta ahora.