5.3.- Escribir contenido en un fichero.

Modos de acceso, el parámetro OpenOptions

A la hora de utilizar un fichero en Java se puede restringir el acceso que tenemos al mismo desde el propio lenguaje, haciendo más estrictos los permisos de acceso que dicho fichero ya tiene en el sistema de ficheros.

Por ejemplo, si el usuario tiene permisos de lectura y escritura sobre un fichero, un programa Java que solo quiera leerlo puede abrir el fichero solo en modo lectura, lo que ayudará a evitar bugs desde el propio lenguaje.

A tal efecto, en java se definen una serie de modos de acceso a un fichero a través del parámetro OpenOptions. La forma más cómoda de utilizar este parámetro es a través del enum StandardOpenOptions que puede tomar los siguientes valores (hay más):

WRITE: habilita la escritura en el fichero
APPEND: todo lo escrito al fichero se hará al final del mismo
CREATE_NEW: crea un fichero nuevo y lanza una excepción si ya existía
CREATE: crea el fichero si no existe y simplemente lo abre si ya existía
TRUNCATE_EXISTING: si el fichero existe, y tiene contenido, se ignora su contenido para sobreescribirlo desde el principio.

Los métodos que se muestran en las siguientes ejemplos utilizan este parámetro, en la descripción de cada método en el API se explica cual es el comportamiento por defecto en caso de no utilizarse este parámetro.

Escritura desde arrays de bytes

La escritura a ficheros mediante arrays es la forma más sencilla (y limitada) de escritura de ficheros, y se realiza mediante el método java.nio.file.Files.write().

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
public class FileEjemplo10 {
    public static void main(String args[]) {
        Path inputFile = Paths.get("C:\\Users\\alumno\\FileEjamplo\\origen\\hola.txt");
        Path outputFile = Paths.get("C:\\Users\\alumno\\FileEjamplo\\destino\\hola.txt"); 
        try {
            byte[] contents = Files.readAllBytes(inputFile);
            Files.write(outputFile, contents, StandardOpenOption.WRITE, 
            StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
       } catch (IOException e) {
            System.err.println(" ERROR : " + e);
            System.exit(1);
     }
  }
}

Escritura desde buffers
La escritura desde buffers resulta mucho más eficiente que utilizando arrays de bytes para ficheros grandes.

El siguiente programa Java copia ficheros, accediendo al fichero original una
vez por línea y escribiendo en el fichero destino una línea cada vez. Utiliza las clases de java.io: BufferedReader y BufferedWriter:

import java .nio. file. Path;
import java .nio. file. Paths ;
import java .nio. file. Files ;
import java .io. IOException;
import java .nio. charset . Charset ;
import java .io. BufferedReader;
import java .io. BufferedWriter;
import java .nio. file. StandardOpenOption;
public class FileEjemplo11 {
// Copy a file
public static void main( String args []) {
Path input = Paths . get( "C:\\Users\\alumno\\FileEjamplo\\origen\\hola.txt") ;
Path output = Paths . get("C:\\Users\\alumno\\FileEjamplo\\destino\\hola.txt") ;
try {
        BufferedReader inputReader = Files . newBufferedReader(input , Charset . 
        defaultCharset());
         BufferedWriter outputWriter = Files . newBufferedWriter(output , Charset .
         defaultCharset() ,  StandardOpenOption. WRITE , StandardOpenOption. 
         CREATE ,  StandardOpenOption. TRUNCATE_EXISTING);
         String line;
         while ( ( line = inputReader. readLine ()) != null ) {
                outputWriter. write (line , 0, line. length ());
                outputWriter. newLine () ;
         }
         inputReader. close ();
         outputWriter. close ();
         } catch ( IOException e) {
         System .err. println (" ERROR : " + e);
         System . exit (1);
        }
    }
}