Java Scrivere su File – 4 Modi per Scrivere un File in Java

Java fornisce diversi modi per scrivere su un file. Possiamo utilizzare FileWriter, BufferedWriter, java 7 Files e FileOutputStream per scrivere un file in Java.

Scrittura su file in Java

Diamo un’occhiata breve alle quattro opzioni disponibili per l’operazione di scrittura su file in Java.

1. FileWriter: FileWriter è il modo più semplice per scrivere un file in Java. Fornisce un metodo di scrittura sovraccaricato per scrivere int, byte array e String nel File. Puoi anche scrivere parte della String o dell’array di byte usando FileWriter. FileWriter scrive direttamente nei file e dovrebbe essere utilizzato solo quando il numero di scritture è limitato.
2. BufferedWriter: BufferedWriter è quasi simile a FileWriter, ma utilizza un buffer interno per scrivere dati nel file. Quindi, se il numero di operazioni di scrittura è maggiore, le effettive operazioni di IO sono inferiori e le prestazioni sono migliori. Dovresti utilizzare BufferedWriter quando il numero di operazioni di scrittura è maggiore.
3. FileOutputStream: FileWriter e BufferedWriter sono destinati a scrivere testo nel file ma quando hai bisogno che i dati dello stream grezzi vengano scritti nel file, dovresti usare FileOutputStream per scrivere file in Java.
4. Files: Java 7 ha introdotto la classe di utilità Files e possiamo scrivere un file utilizzando la sua funzione di scrittura. Internamente utilizza OutputStream per scrivere un array di byte nel file.

Esempio di scrittura su file Java

Ecco l’esempio che mostra come possiamo scrivere un file in Java utilizzando FileWriter, BufferedWriter, FileOutputStream e Files in 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{
            //chiudi le risorse
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

Questi sono i metodi standard per scrivere un file in Java e dovresti sceglierne uno in base ai requisiti del tuo progetto. Questo è tutto per l’esempio di scrittura su file Java.

Puoi controllare altri esempi di IO Java dal nostro Repository GitHub.