Escribir en archivo en Java – 4 formas de escribir en archivo en Java

Java ofrece varias formas de escribir en un archivo. Podemos usar `FileWriter`, `BufferedWriter`, `Files` de Java 7 y `FileOutputStream` para escribir un archivo en Java.

Escribir en Archivo en Java

Echemos un vistazo breve a cuatro opciones que tenemos para la operación de escritura en archivo en Java.

1. FileWriter: FileWriter es la forma más simple de escribir un archivo en Java. Proporciona un método de escritura sobrecargado para escribir enteros, matrices de bytes y cadenas en el archivo. También puedes escribir parte de la cadena o matriz de bytes usando FileWriter. FileWriter escribe directamente en archivos y solo debe usarse cuando el número de escrituras es menor.
2. BufferedWriter: BufferedWriter es casi similar a FileWriter pero usa un búfer interno para escribir datos en el archivo. Por lo tanto, si el número de operaciones de escritura es mayor, las operaciones de E/S reales son menores y el rendimiento es mejor. Debes usar BufferedWriter cuando el número de operaciones de escritura es mayor.
3. FileOutputStream: FileWriter y BufferedWriter están destinados a escribir texto en el archivo, pero cuando necesitas que se escriban datos de flujo sin procesar en el archivo, debes usar FileOutputStream para escribir archivos en Java.
4. Files: Java 7 introdujo la clase de utilidad Files y podemos escribir un archivo usando su función write. Internamente, está utilizando OutputStream para escribir una matriz de bytes en el archivo.

Java Write to File Example

Aquí tienes el ejemplo que muestra cómo podemos escribir un archivo en Java usando FileWriter, BufferedWriter, FileOutputStream y Files en Java. WriteFile.java

package com.journaldev.files;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Paths;

public class WriteFile {

    /**
     * This class shows how to write file in java
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) {
        String data = "I will write this String to File in Java";
        int noOfLines = 10000;
        writeUsingFileWriter(data);
        
        writeUsingBufferedWriter(data, noOfLines);
        
        writeUsingFiles(data);
        
        writeUsingOutputStream(data);
        System.out.println("DONE");
    }

    /**
     * Use Streams when you are dealing with raw data
     * @param data
     */
    private static void writeUsingOutputStream(String data) {
        OutputStream os = null;
        try {
            os = new FileOutputStream(new File("/Users/pankaj/os.txt"));
            os.write(data.getBytes(), 0, data.length());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * Use Files class from Java 1.7 to write files, internally uses OutputStream
     * @param data
     */
    private static void writeUsingFiles(String data) {
        try {
            Files.write(Paths.get("/Users/pankaj/files.txt"), data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Use BufferedWriter when number of write operations are more
     * It uses internal buffer to reduce real IO operations and saves time
     * @param data
     * @param noOfLines
     */
    private static void writeUsingBufferedWriter(String data, int noOfLines) {
        File file = new File("/Users/pankaj/BufferedWriter.txt");
        FileWriter fr = null;
        BufferedWriter br = null;
        String dataWithNewLine=data+System.getProperty("line.separator");
        try{
            fr = new FileWriter(file);
            br = new BufferedWriter(fr);
            for(int i = noOfLines; i>0; i--){
                br.write(dataWithNewLine);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                br.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Use FileWriter when number of write operations are less
     * @param data
     */
    private static void writeUsingFileWriter(String data) {
        File file = new File("/Users/pankaj/FileWriter.txt");
        FileWriter fr = null;
        try {
            fr = new FileWriter(file);
            fr.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //cerrar recursos
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

Estos son los métodos estándar para escribir un archivo en Java y debes elegir uno de estos según los requisitos de tu proyecto. Eso es todo para el ejemplo de escritura de archivos en Java.

Puedes consultar más ejemplos de E/S en Java en nuestro Repositorio de GitHub.