##
STREAMS DE SALIDA

La contrapartida necesaria de la lectura de datos es la escritura de datos. Como con los Streams de entrada, las clases de salida están ordenadas jerárquicamente:

Examinaremos las clases FileOutputStream y DataOutputStream para complementar los streams de entrada que se han visto. En los ficheros fuente del directorio `$JAVA_HOME/src/java/io` se puede ver el uso y métodos de estas clases, así como de los streams de entrada (`$JAVA_HOME` es el directorio donde se haya instalado el Java Development Kit, en sistemas UNIX).

### Objetos FileOutputStream

Los objetos FileOutputStream son útiles para la escritura de ficheros de texto. Como con los ficheros de entrada, primero se necesita abrir el fichero para luego escribir en él.

#### Apertura de un FileOutputStream

Para abrir un objeto FileOutputStream, se tienen las mismas posibilidades que para abrir un fichero stream de entrada. Se le da al constructor un String o un objeto File.

        FileOutputStream miFicheroSt;
        miFicheroSt = new FileOutputStream( "/etc/kk" );

Como con los streams de entrada, también se puede utilizar:

    File miFichero FileOutputStream miFicheroSt;

        miFichero = new File( "/etc/kk" );
        miFicheroSt = new FileOutputStream( miFichero );

#### Escritura en un FileOutputStream

Una vez abierto el fichero, se pueden escribir bytes de datos utilizando el método write(). Como con el método read() de los streams de entrada, tenemos tres posibilidades:

`void write( int b );`

> Escribe un byte.

`void write( byte b[] );`

> Escribe todo el array, si es posible.

`void write( byte b[],int offset,int longitud );`

> Escribe longitud bytes en `b` comenzando por `b[offset]`.

#### Cierre de FileOutputStream

Cerrar un stream de salida es similar a cerrar streams de entrada. Se puede utilizar el método explícito:

        miFicheroSt.close();

O, se puede dejar que el sistema cierre el fichero cuando se recicle `miFicheroSt`.

#### Ejemplo: Almacenamiento de Información

Este programa, Telefonos.java, pregunta al usuario una lista de nombres y números de teléfono. Cada nombre y número se añade a un fichero situado en una localización fija. Para indicar que se ha introducido toda la lista, el usuario especifica "Fin" ante la solicitud de entrada del nombre.

Una vez que el usuario ha terminado de teclear la lista, el programa creará un fichero de salida que se mostrará en pantalla o se imprimirá. Por ejemplo:

        95-4751232,Juanito
        564878,Luisa
        123456,Pepe
        347698,Antonio
        91-3547621,Maria

El código fuente del programa es el siguiente:

    import java.io.*;

    class Telefonos {
        static FileOutputStream fos;
        public static final int longLinea = 81;

        public static void main( String args[] ) throws IOException {
            byte tfno[] = new byte[longLinea];
            byte nombre[] = new byte[longLinea];

            fos = new FileOutputStream( "telefono.dat" );
            while( true )
                {
                System.err.println( "Teclee un nombre ('Fin' termina)" );
                leeLinea( nombre );
                if( "fin".equalsIgnoreCase( new String( nombre,0,0,3 ) ) )
                    break;

                System.err.println( "Teclee el numero de telefono" );
                leeLinea( tfno );
                for( int i=0; tfno[i] != 0; i++ )
                    fos.write( tfno[i] );
                fos.write( ',' );
                for( int i=0; nombre[i] != 0; i++ )
                    fos.write( nombre[i] );
                fos.write( '\n' );
                }
            fos.close();
            }

        private static void leeLinea( byte linea[] ) throws IOException {
            int b = 0;
            int i = 0;

            while( (i < ( longLinea-1) ) &&
                ( ( b = System.in.read() ) != '\n' ) )
                linea[i++] = (byte)b;
            linea[i] = (byte)0;
            }
        }

### Streams de salida con buffer

Si se trabaja con gran cantidad de datos, o se escriben muchos elementos pequeños, será una buena idea utilizar un stream de salida con buffer. Los streams con buffer ofrecen los mismos métodos de la clase FileOutputStream, pero toda salida se almacena en un buffer. Cuando se llena el buffer, se envía a disco con una única operación de escritura; o, en caso necesario, se puede enviar el buffer a disco en cualquier momento.

#### Creación de Streams de salida con buffer

Para crear un stream BufferedOutput, primero se necesita un stream FileOutput normal; entonces se le añade un buffer al stream:

        FileOutputStream miFileStream;
        BufferdOutpurStream miBufferStream;
        // Obtiene un controlador de fichero
        miFileStream = new FileOutputStream( "/tmp/kk" );
        // Encadena un stream de salida con buffer
        miBufferStream = new BufferedOutputStream( miFileStream );

#### Volcado y Cierre de Streams de salida con buffer

Al contrario que los streams FileOutput, cada escritura al buffer no se corresponde con una escritura en disco. A menos que se llene el buffer antes de que termine el programa, cuando se quiera volcar el buffer explícitamente se debe hacer mediante una llamada a flush():

        // Se fuerza el volcado del buffer a disco
        miBufferStream.flush();
        // Cerramos el fichero de datos. Siempre se ha de cerrar primero el
        // fichero stream de mayor nivel
        miBufferStream.close();
        miFileStream.close();

### Streams DataOutput

Java también implementa una clase de salida complementaria a la clase DataInputStream. Con la clase DataOutputStream, se pueden escribir datos binarios en un fichero.

#### Apertura y cierre de objetos DataOutputStream

Para abrir y cerrar objetos DataOutputStream, se utilizan los mismos métodos que para los objetos FileOutputStream:

        DataOutputStream miDataStream;
        FileOutputStream miFileStream;
        BufferedOutputStream miBufferStream;

        // Obtiene un controlador de fichero
        miFileStream = new FileOutputStream( "/tmp/kk" );
        // Encadena un stream de salida con buffer (por eficiencia)
        miBufferStream = new BufferedOutputStream( miFileStream );
        // Encadena un fichero de salida de datos
        miDataStream = new DataOutputStream( miBufferStream );

        // Ahora se pueden utilizar los dos streams de entrada para
        // acceder al fichero (si se quiere)
        miBufferStream.write( b );
        miDataStream.writeInt( i );

        // Cierra el fichero de datos explícitamente. Siempre se cierra
        // primero el fichero stream de mayor nivel
        miDataStream.close();
        miBufferStream.close();
        miFileStream.close();

#### Escritura en un objeto DataOutputStream

Cada uno de los métodos write() accesibles por los FileOutputStream también lo son a través de los DataOutputStream. También encontrará métodos complementarios a los de DataInputStream:

        void writeBoolean( boolean b );
        void writeByte( int i );
        void writeShort( int i );
        void writeChar( int i );
        void writeInt( int i );
        void writeFloat( float f );
        void writeDouble( double d );
        void writeBytes( String s );
        void writeChars( string s );

Para las cadenas, se tienen dos posibilidades: bytes y caracteres. Hay que recordar que los bytes son objetos de 8 bits y los caracteres lo son de 16 bits. Si nuestras cadenas utilizan caracteres Unicode, debemos escribirlas con writeChars().

#### Contabilidad de la salida

Otra función necesaria durante la salida es el método size(). Este método simplemente devuelve el número total de bytes escritos en el fichero. Se puede utilizar size() para ajustar el tamaño de un fichero a múltiplo de cuatro. Por ejemplo, de la forma siguiente:

        . . .
        int numBytes = miDataStream.size() % 4;
        for( int i=0; i < numBytes; i++ )
            miDataStream.write( 0 );
        . . .

|  | ##### [Anterior] [Indice] [Siguiente]