(c)BIT - Ud.7 Curso Java: unidades didacticas

	Curso JAVA Unidad 7: "Entrada/Salida"
	www.bit.es - Calendario de cursos - Solicitud de información

Curso Java
Curso Analista Programador entorno Java

Objetivos de la Unidad:

Conocer la gestión de ficheros de acceso directo
Conocer el mecanismo de los streams
Interpretar la jerarquía de clases standard base de los streams y filtros
Manejar ficheros y directorios con la clase File
Ficheros indexados con JAVA
Serialización
Compresión de streams
Creación y lectura de ficheros .zip

1.- Introducción

Hay dos enfoques para la gestión de ficheros en la librería standard:
Los ficheros de acceso directo (RandomAccessFile)
Los streams (InputStream, OutputStream y derivadas)

2.- RandomAccessFile

Ejemplo mínimo de escritura:

// EjemploRandomAccessFile.java
import java.io.*;

     public class EjemploRandomAccessFile
     {
       public static void main (String args[]) throws Exception
       {
       RandomAccessFile f = new RandomAccessFile("salida.txt", "rw");
       String cadena = "Frase de prueba";

       f.writeBytes(cadena);
       f.writeBytes("\r\n");
       f.writeChars(cadena);
       f.close();
       }
     }

Notas acerca de RandomAccessFile:
- Si el fichero no existe, lo crea
- Si el fichero existe lo abre y sobreescribe en su interior
- Con el método seek se puede posicionar a nivel de byte dentro del fichero
- Un fichero puede ser tratado como un array de bytes en disco.
Ejercicio: ¿Por qué aparecen espacios en blanco entre los caracteres de la segunda linea?

3.- FileOutputStream

El equivalente al ejemplo anterior es:

// EjemploFileOutputStream.java
import java.io.*;
public class EjemploFileOutputStream
{
public static void main (String args[]) throws Exception
{
FileOutputStream f = new FileOutputStream("salida.txt");
DataOutputStream d = new DataOutputStream(f);
String cadena = "Frase de prueba";
d.writeBytes(cadena);
d.writeBytes("\r\n");
d.writeChars(cadena);
d.close(); // desencadena el close de f
}
}
3.1.- Operaciones de "fontanería"

Los streams se conectan unos a otros mediante el constructor. DataOutputStream está basado en el Patrón de Diseño denominado Decorator. En los apartados siguientes se muestra cómo se realizan estas conexiones.
3.2.- Compresión de streams y ficheros zip
- Para generar un stream comprimido basta con aplicar los filtros ZipOutputStream y ZipInputStream del paquete java.util.zip y su modo de actuación es similar a la del filtro BufferedOuputStream.
- Ésta es una característica que aparece a partir del JDK 1.1.x
- Puede aplicarse a los ejemplos de esta unidad. En particular para el ejemplo del paso 3 sería:
// EjemploFileOutputStream.java
import java.io.*;
import java.util.zip.*;
public class EjemploFileOutputStream
{
public static void main (String args[]) throws Exception
{
FileOutputStream f = new FileOutputStream("salida.zip");
  ZipOutputStream z = new ZipOutputStream(f);
  z.putNextEntry(new ZipEntry("salida.txt"));
  DataOutputStream d = new   DataOutputStream(z);
String cadena = "Frase de prueba";
d.writeBytes(cadena);
d.writeBytes("\r\n");
d.writeChars(cadena);
d.close(); // desencadena el close de z y de f
}
}
- Sin la instrucción z.putNextEntry(new ZipEntry("salida.txt")); el fichero comprimido se crearía igual pero no sería manejable por WinZip
3.3.- Serialización

Para que una clase sea serializable, ésta o una clase de la que derive debe implementar el interface Serializable. Para el correcto funcionamiento del ejemplo siguiente se recomienda que la clase ObjGraf implemente Serializable.

import java.io.*;

public class PruebaSerializacion
{
  public static void main(String args[]) throws Exception
  {
    // Fase 1: Creación de los objetos

    Rectangulo r = new Rectangulo(1, 2, 3, 4);
    Circulo c = new Circulo(30, 20, 10);

    // Fase 2: Apertura de un fichero stream de salida y serialización hacia él
    // de objetos

    FileOutputStream f = new FileOutputStream("salida.dat");
    ObjectOutputStream objOut = new ObjectOutputStream(f);
    objOut.writeObject(r);
    objOut.writeObject(c);
    objOut.close();
    System.out.println("creado salida.dat");

    // Fase 3: Comprobación: Deserialización de los objetos

    FileInputStream f2 = new FileInputStream("salida.dat");
    ObjectInputStream objIn = new ObjectInputStream(f2);

    Rectangulo r2 = (Rectangulo) objIn.readObject();
    System.out.println("Rect: " + r2.getX());

    Circulo c2 = (Circulo) objIn.readObject();
    System.out.println("Circ: " + c2.getX());

  }
}
- Las operaciones de serialización y deserialización pueden personalizarse sobrescribiendo los métodos readObject() y writeObject() de los objetos a serializar.

4.- FileInputStream

Ejemplo de type en Java byte a byte (nota: f.read() lee byte a byte, de 00 a FF. Un fin de fichero devuelve -1, que al ser un int es FFFF (distinto de 00FF).

// type.java
import java.io.*;
public class type
{
public static void main (String args[]) throws Exception
{
    FileInputStream f = new FileInputStream(args[0]);
    int c;

    while ((c = f.read()) != -1)
    {
      System.out.print((char) c);
    }
}
}

Se puede optimizar el rendimiento mediante lectura por bloques (mediante un buffer de tamaño ajustable):
// type.java
import java.io.*;
public class type
{
public static void main (String args[]) throws Exception
{
    FileInputStream f = new FileInputStream(args[0]);
    byte buf[] = new byte[2048]; // buffer de 2Kb
    int n;
    while ((n = f.read(buf)) != -1)
    {
      System.out.print(new String(buf, 0, n));
    }
}
}

También puede realizarse leyendo línea a línea
// type.java
import java.io.*;
public class type
{
public static void main (String args[]) throws Exception
{
    String linea = "";
    FileInputStream f = new FileInputStream(args[0]);
    DataInputStream d = new DataInputStream(f);
    while ((linea = d.readLine()) != null)
    {
      System.out.println(linea);
    }
}
}

El ejemplo mostrado compilará y se ejecutará pero nos dará un mensaje de deprecated.
La lectura de teclado al estilo gets() o scanf() de C puede ser como sigue:

import java.io.*;

public class InputDeTeclado
{
  public static void main(String[] args) throws Exception
  {
    DataInputStream d = new DataInputStream(System.in);
    System.out.print("Nombre: ");
    String nombre = d.readLine();
    System.out.print("Cantidad: ");
    int cantidad = Integer.parseInt(d.readLine());
    System.out.println("Nombre: " + nombre + ", Cantidad: " + cantidad);
  }
}

El warning que vuelve a aparecer es debido al método readLine() de DataInputStream está deprecated (en desuso). Para la lectura de caracteres (Unicode) a partir de JDK 1.1 se han incorporado dos jerarquías de clases a tal efecto: La que deriva de Reader y la que deriva de Writer

import java.io.*;

public class InputDeTeclado2
{
  public static void main(String[] args) throws Exception
  {
    InputStreamReader ir = new InputStreamReader(System.in);
    LineNumberReader lr = new LineNumberReader(ir);
    System.out.print("Nombre: ");
    String nombre = lr.readLine();
    System.out.print("Cantidad: ");
    int cantidad = Integer.parseInt(lr.readLine());
    System.out.println("Nombre: " + nombre + ", Cantidad: " + cantidad);
  }
}

Puede mejorarse el rendimiento del ejemplo de la clase type aplicando el filtro BufferedInputStream que acelera las operaciones de entrada ya que carga un buffer intermedio de RAM con otro thread.

import java.io.*;
public class type
{
public static void main (String args[]) throws Exception
{
    String linea = "";
    FileInputStream f = new FileInputStream(args[0]);
    BufferedInputStream b = new BufferedInputStream(f);
    DataInputStream d = new DataInputStream(b);
    while ( (linea = d.readLine()) != null)
    {
      System.out.println(linea);
    }
}

De forma similar actúa BufferedOutputStream, pero para los casos de acceso concurrente sobre el mismo fichero de salida puede producirse sobreescritura de datos no deseada
El tamaño del buffer se puede especificar mediante un constructor.
Para copiar un archivo pueden combinarse los conceptos de InputStream y OutputStream:

// copy.java
import java.io.*;
public class copy
{
public static void main (String args[]) throws Exception
{
    FileInputStream f = new FileInputStream(args[0]);
    FileOutputStream f2 = new FileOutputStream(args[1]);
    int c;

    while ((c = f.read()) != -1)
    {
      f2.write(c);
    }
    f.close();
    f2.close();
}
}

En la Unidad 6 explicábamos cómo ejecutar comandos del sistema mediante el método exec() de la clase Runtime. Jugando con los streams se puede conseguir evitar el paso por ficheros intermedios lo cual se agradece en caso de sistemas concurrentes o en caso de querer evitar escribir en disco para evitar depender de disponer de privilegios. El código sería:

 ... Process p = Runtime.getRuntime().exec(cmd); InputStream 
pin = p.getInputStream(); ByteArrayOutputStream bo = new ByteArrayOutputStream(); 
int c; while ((c = pin.read()) != -1) bo.write(c);

 
String respuesta = bo.toString(); ...

5.- File

// Demostración de File.
import java.io.File;
public class FileDemo
{
static void p(String s)
{
     System.out.println(s);
}
public static void main(String args[])
{
    File f1 = new File("/midirectorio");
    p("Nombre fichero: " + f1.getName());
    p("Path: " + f1.getPath());
    p("Abs Path: " + f1.getAbsolutePath());
    p("Parent: " + f1.getParent());
    p(f1.exists() ? "existe" : "no existe");
    p(f1.canWrite() ? "es de escritura" : "no es de escritura");
    p(f1.canRead() ? "es de lectura" : "no es de lectura");
    p("" + (f1.isDirectory() ? "es" : "no es" + " un directorio"));
    p(f1.isFile() ? "es fichero normal" : "es fichero especial");
    p(f1.isAbsolute() ? "es absoluto" : "no es absoluto");
    p("Última modificación: " + f1.lastModified());
    p("Tamaño fichero: " + f1.length() + " Bytes");
}
}

6.- Listas de ficheros y directorios

// Gestión de directorios.
import java.io.File;
public class DirList
{
public static void main(String args[])
{
    String dirname = "/midirectorio";
    File f1 = new File(dirname);
    if (f1.isDirectory())
    {
      System.out.println("Directorio de " + dirname);
      String s[] = f1.list();
      for (int i=0; i < s.length; i++)
      {
        File f = new File(dirname + "/" + s[i]);
        if (f.isDirectory())
        {
          System.out.println(s[i] + " es un directorio");
        }
        else
        {
          System.out.println(s[i] + " es un fichero");
        }
      }
    }
    else
    {
      System.out.println(dirname + " no es un directorio");
    }
}
}

En el API estándar no habían inicialmente servicios de ordenación. Posteriormente la clase Arrays ofrece métodos sort() a tal efecto. En nuestro caso sería útil por ejemplo para obtener la lista de ficheros ordenada. Ello no es debido a que sus creadores como James Gosling no hayan caído en ello. En el propio JDK viene el ejemplo sortDemo en el que se incluyen varios algoritmos de ordenación como BubbleSort y QSort.
En base a ellos se listan a continuación dos rutinas estáticas y genéricas de ordenación por el método de la burbuja que en un momento dado pueden ser de utilidad:
Ordenación de un array de elementos tipo String:
public static void bubbleSort(String[] a)
{
  for (int i = 0; i < a.length; i++)
    for (int j = a.length-1; j > i; j--)
    {
      if (a[j-1].compareTo(a[j]) > 0)
      {
        String T = a[j-1];
        a[j-1] = a[j];
        a[j] = T;
      }
    }
}

Ordenación de un array de elementos tipo int:

public static void bubbleSort(int[] a)
{
  for (int i = 0; i < a.length; i++)
    for (int j = a.length-1; j > i; j--)
    {
      if (a[j-1] > 0)
      {
        int T = a[j-1];
        a[j-1] = a[j];
        a[j] = T;
      }
    }
}
Se propone como ejercicio avanzado recorrer recursivamente un árbol de directorios. Para repasar el concepto de recursividad se muestra en un ejemplo una comparativa de lógica recursiva y lógica de bucle:
```
public 
class PruebaRecursividad { public static void main(String[] args) { System.out.println("fRecur(0, 
5) :"); fRecur(0, 5); System.out.println("fIter(0, 5) :"); fBucle(0, 
5); }
```
```
 private static void fRecur (int 
i, int n) { if (i < n) { System.out.println("i = " + i); fRecur(++i, 
n); // se llama a sí mismo } // else return (implícito) }
```
```
 
public static void fBucle (int i, int n) { for (; i < n; i++) System.out.println("i 
= " + i); } }
```
Las llamadas recursivas se van acumulando en la pila hasta que se produce un return. A partir de ahí se cierran en cadena y en orden inverso las llamadas pendientes.

La clase Enzipador.java crea un fichero zip de un directorio, recorriendo recursivamente su estructura para incluir los subdirectorios. Puede se una clase útil para realizar copias de seguridad o preparar envíos de datos.
Filtros por extensión de ficheros

// Directorio de ficheros .HTML
import java.io.*;
public class DirListOnly
{
public static void main(String args[])
{
    String dirname = "/midirectorio";
    File f1 = new File(dirname);
    FilenameFilter only = new OnlyExt("html");
    String s[] = f1.list(only);
    for (int i=0; i < s.length; i++)
    {
      System.out.println(s[i]);
    }
}
}

public class OnlyExt implements FilenameFilter
{
String ext;
public OnlyExt(String ext)
{
this.ext = "." + ext;
}
public boolean accept(File dir, String name)
{
return name.endsWith(ext);
}
}
Aquí vendrían bien unos servicios para expresiones regulares con lo que se podrían definir filtros complejos. No obstante se puede ir más lejos gracias a un paquete regexp con licencia GNU que aporta funcionalidades similares a las que se disponen en lenguajes como Perl. Dicho package puede obtenerse en http://www.cacas.org/java/gnu/regexp

7.- StreamTokenizer

// Ejemplo de StreamTokenizer
import java.io.*;
public class CuentaPalabras
{
public static int words=0;
public static int lines=0;
public static int chars=0;
public static void cuenta(InputStream f) throws IOException
{
    StreamTokenizer tok = new StreamTokenizer(f);
    tok.resetSyntax();
    tok.wordChars(33, 255);
    tok.whitespaceChars(0, ' ');
    tok.eolIsSignificant(true);
    while (tok.nextToken() != tok.TT_EOF)
    {
      switch (tok.ttype)
      {
        case tok.TT_EOL:
          lines++;
          chars++;
          break;
        case tok.TT_WORD:
          words++;
        default:
          chars += tok.sval.length();
          break;
      }
    }
}
public static void main(String args[])
{
    if (args.length == 0) // se trabaja con stdin
    {
      try
      {
        cuenta(System.in);
        System.out.println(lines + " " + words + " " + chars);
      }
      catch (IOException e) {};
    }
    else
    {
      int twords = 0, tchars = 0, tlines = 0;
      for (int i=0; i<args.length; i++)
      {
        try
        {
          words = chars = lines = 0;
          cuenta(new FileInputStream(args[i]));
          twords += words;
          tchars += chars;
          tlines += lines;
          System.out.println(args[i] + ": " +
            lines + " " + words + " " + chars);
        }
        catch (IOException e)
        {
          System.out.println(args[i] + ": error.");
        }
      }
      System.out.println("total: " +
      tlines + " " + twords + " " + tchars);
    }
}
}
Bajo una idea similar se planteó la clase HTMLStreamTokenizer de Arthur Do que en lugar de parsear texto plano HTML parsea HTML. Puede obtenerse libremente en http://www.do.org
En el paquete javax.swing.text.html.parser se dispone de elementos para parsear HTML
Ya que hablamos de parsers y de gramáticas comentar que está disponible un repositorio de gramáticas en http://www.cobase.cs.ucla.edu/pub/javacc/. JavaCC es a Java lo que Yacc a C. Su página es http://www.metamata.com/JavaCC/
Utilizando un parser de HTML puede elaborarse un traductor de páginas on-line al estilo AltaVista o un corrector como se muestra en la práctica on-line de Bit en http://www.bit-net.org/java/corr.html

8.- Ficheros indexados con Java

En capítulos sucesivos veremos el acceso a bases de datos mediante JDBC. Entre los ficheros de acceso directo y las bases de datos relacionales hay un importante hueco: Los ficheros indexados.
Hay aplicaciones en las que vendrían bien unas librerías de ficheros indexados como por ejemplos catálogos en CD-ROM o casos en que solamente queramos utilizar servlet hosting pero no servicios de base de datos como aplicaciones de e-commerce sin un gran volumen de datos.
JAVA no incluye soporte de ficheros indexados de forma nativa, sin embargo se pueden encontrar productos como xBaseJ que disponen de unas librerías 100% Java para crear, acceder y modificar ficheros dBase utilizando los ficheros índice .ndx propios de dBase.
Se puede obtener información y una versión de evaluación (5 DBF abiertos simultáneos como máximo) en http://www.americancoders.com/xBaseJ.html. Una versión Open Source que puede ser muy útil es jdbf en http://www.svcon.com/jdbf/
Los ficheros indexados se basan en general en algoritmos tipo b-tree. Un enfoque docente se puede encontrar en el libro "Algoritmos y estructuras de datos" de Niklaus Wirth. Como referencia se puede comentar sobre los b-tree (balance trees) que para un acceso sobre un millón de claves basta con dos accesos disco por lo que es un sistema rápido. Se puede encontrar información sobre ello en http://www.bluerwhite.org/btree
Se puede encontrar información detallada de la estructura de los ficheros del mundo "xbase" en http://www.e-bachmann.dk/docs/xbase.htm
El AS/400 Toolbox for Java (http://www.as400.ibm.com/toolbox) ofrece librerías para el manejo de archivos físicos y lógicos directamente desde Java y ello se describe en http://publib.boulder.ibm.com/pubs/html/as400/v4r5/ic2924/info/java/rzahh/toolbox.htm

Unidad anterior - Unidad siguiente