Java Datei schreiben – 4 Möglichkeiten, Dateien in Java zu schreiben

Java bietet verschiedene Möglichkeiten, um in eine Datei zu schreiben. Wir können FileWriter, BufferedWriter, Java 7 Files und FileOutputStream verwenden, um eine Datei in Java zu schreiben.

Java Schreiben in eine Datei

Lassen Sie uns einen kurzen Blick auf die vier Optionen werfen, die wir für das Schreiben in eine Datei in Java haben.

1. FileWriter: FileWriter ist der einfachste Weg, um eine Datei in Java zu schreiben. Es bietet eine überladene Schreibmethode, um int, Byte-Array und String in die Datei zu schreiben. Sie können auch einen Teil des Strings oder des Byte-Arrays mit FileWriter schreiben. FileWriter schreibt direkt in Dateien und sollte nur verwendet werden, wenn die Anzahl der Schreibvorgänge gering ist.
2. BufferedWriter: BufferedWriter ist fast identisch mit FileWriter, verwendet jedoch einen internen Puffer, um die Daten in die Datei zu schreiben. Wenn die Anzahl der Schreibvorgänge höher ist, sind die tatsächlichen E/A-Vorgänge geringer und die Leistung ist besser. Verwenden Sie BufferedWriter, wenn die Anzahl der Schreibvorgänge höher ist.
3. FileOutputStream: FileWriter und BufferedWriter sind dazu gedacht, Text in die Datei zu schreiben, aber wenn Sie rohe Streamdaten in die Datei schreiben müssen, sollten Sie FileOutputStream verwenden, um die Datei in Java zu schreiben.
4. Files: Java 7 hat die Hilfsklasse Files eingeführt, und wir können eine Datei mit ihrer write-Funktion schreiben. Intern verwendet es OutputStream, um ein Byte-Array in die Datei zu schreiben.

Java Write to File Beispiel

Hier ist das Beispiel, das zeigt, wie wir eine Datei in Java mit FileWriter, BufferedWriter, FileOutputStream und Files in Java schreiben können. 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{
            //close resources
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

Dies sind die Standardmethoden zum Schreiben einer Datei in Java, und Sie sollten eine davon basierend auf den Anforderungen Ihres Projekts auswählen. Das ist alles für das Java-Schreibbeispiel.

Sie können mehr Java-IO-Beispiele aus unserem GitHub-Repository überprüfen.