Java Bestand Schrijven – 4 Manieren om Bestand te Schrijven in Java

Java biedt verschillende manieren om naar een bestand te schrijven. We kunnen FileWriter, BufferedWriter, java 7 Files en FileOutputStream gebruiken om een bestand in Java te schrijven.

Java Schrijven naar Bestand

Laten we kort kijken naar vier opties die we hebben voor het schrijven naar een bestand in Java.

1. FileWriter: FileWriter is de eenvoudigste manier om een bestand in Java te schrijven. Het biedt een overbelaste schrijfmethode om een int, byte array en String naar het bestand te schrijven. Je kunt ook een deel van de String of byte array schrijven met behulp van FileWriter. FileWriter schrijft rechtstreeks naar bestanden en moet alleen worden gebruikt wanneer het aantal schrijfbewerkingen minder is.
2. BufferedWriter: BufferedWriter is bijna vergelijkbaar met FileWriter, maar het gebruikt een interne buffer om gegevens naar het bestand te schrijven. Dus als het aantal schrijfbewerkingen groter is, zijn de daadwerkelijke IO-bewerkingen minder en is de prestatie beter. Je moet BufferedWriter gebruiken wanneer het aantal schrijfbewerkingen groter is.
3. FileOutputStream: FileWriter en BufferedWriter zijn bedoeld om tekst naar het bestand te schrijven, maar wanneer je ruwe stroomgegevens in het bestand wilt schrijven, moet je FileOutputStream gebruiken om het bestand te schrijven in Java.
4. Files: Java 7 introduceerde de hulpprogrammaklasse Files en we kunnen een bestand schrijven met behulp van de write-functie ervan. Intern gebruikt het OutputStream om een byte-array in het bestand te schrijven.

Voorbeeld van schrijven naar bestand in Java

Hier is het voorbeeld dat laat zien hoe we een bestand kunnen schrijven in Java met behulp van FileWriter, BufferedWriter, FileOutputStream, en 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{
            //bronnen sluiten
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

Dit zijn de standaardmethoden om een bestand te schrijven in Java en je moet een van deze kiezen op basis van de eisen van je project. Dat is alles voor het voorbeeld van het schrijven naar een bestand in Java.

Je kunt meer voorbeelden van Java IO bekijken in ons GitHub Repository.