Java Skriv til fil | Tekststrenge | Forskellige måder at skrive fileksempler på

String

Mange virksomheders applikation skal skrive indhold i filen. For eksempel oprettelse af en rapport eller fakturafiler. Problemet er, hvordan du vil gøre med Java Write to File? Der er mange måder at gøre det på. I dette selvstudie vil vi diskutere forskellige måder at Java-skrive til fil med eksempler på.

Skriv en fil på Java-måder

Her er nogle forskellige måder at skrive en fil i java på.

BufferedWritter
FileWriter – Skriver direkte ind i filen
PrintWriter – Skriv formateret tekst.
FileOutputStream – Skriv binære data.
DataOutputStream – Skriv primitive datatyper
FileChannel – Skriv større filer
Skriv fil ved hjælp af Java 7 Path

Lad os starte Java Write to File eksempel på forskellige måder

Vi vil se på en hurtig og meget enkel måde med korte detaljer om, hvordan man skriver filer. Hvis vi prøvede en skrivefil, og denne fil ikke eksisterer, vil den give en fejl, så brug altid try-catch-blok eller brug undtagelseshåndtering. De fleste eksempler er baseret på Java, skriv en streng til fil.

BufferedWritter

Det enkleste at skrive en fil i java brugte BufferedWritter, som skriver tekst til en karakter-outputstrøm. Så det er mere effektiv skrivning af enkelte tegn, strenge og arrays.

Se nedenstående eksempel. Du havde brug for en skrevet kode i try-catch undtagelseshåndtering, fordi der er stor risiko for fejl. Som ikke fundet filfejl osv.

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello BufferedWriter file writing ";

        try {
            BufferedWriter writer =
                    new BufferedWriter(new FileWriter("samplefile.txt"));

            writer.write(fileContent);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Her er en gif-præsentation af projektfilen og kodeoutput.

Java Write-fil ved hjælp af FileWriter/PrintWriter

FileWriter skriver direkte ind i filen. Dens ydeevne er mindre end andre, så brug kun, når du ønsker at skrive mindre. Dens syntaks er ren og nem, se nedenstående eksempel. Det vil fjerne det gamle indhold af filen, hvis det findes der.

import java.io.FileWriter;
import java.io.IOException;

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello FileWriter ";

        try {
            FileWriter fileWriter = new FileWriter("samplefile.txt");
            fileWriter.write(fileContent);
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PrintWriter bruges når du vil skrive en fil i format. Det har nogle fordele, fordi denne klasse implementerer alle printmetoder, der findes i PrintStream så du kan bruge alle formater. Og du kan også bruge det med System.out.println() udsagn.

Se koden, du får en idé om hvordan printf de andre metoder kan bruge her.

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello PrintWriter ";

        try {
            FileWriter fileWriter = new FileWriter("samplefile.txt");
            PrintWriter printWriter = new PrintWriter(fileWriter);
            printWriter.print(fileContent);
            printWriter.printf("writing another string");
            printWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutputStream

Med FileOutputStream kan du skrive binære data i en fil. For et eksempel på at skrive en billedrækkedata.

import java.io.FileOutputStream;
import java.io.IOException;

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello FileOutputStream ";

        try {
            FileOutputStream outputStream = new FileOutputStream("samplefile.txt");
            byte[] strToBytes = fileContent.getBytes();
            outputStream.write(strToBytes);

            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DataOutputStream

Når du ønsker at skrive primitive Java-datatyper, er DataOutputStream en bærbar måde. Mulig tilbagelæsning af data fra en fil.

import java.io.*;


public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello FileOutputStream";

        try {
            FileOutputStream outputStream = new FileOutputStream("c:/temp/samplefile5.txt");
            DataOutputStream dataOutStream = new DataOutputStream(new BufferedOutputStream(outputStream));
            dataOutStream.writeUTF(fileContent);

            dataOutStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Filkanal

Når du vil skrive en større fil, skal du bruge FileChannel. Det bruges til at læse, skrive, kortlægge og manipulere en fil. Det er hurtigere end standard IO i større filsager.

Filkanal er også sikker ved flere samtidige tråde. Se eksempel på det.

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello File channel";

        try {
            RandomAccessFile stream = new RandomAccessFile("samplefile.txt", "rw");
            FileChannel channel = stream.getChannel();
            byte[] strBytes = fileContent.getBytes();
            ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
            buffer.put(strBytes);
            buffer.flip();
            channel.write(buffer);
            stream.close();
            channel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Brug af Java 7 Path

Java 7 introducerede værktøjsklassen Filer, hvor du kan skrive en fil ved hjælp af dens skrivemetode , internt bruger den OutputStream til at skrive byte-array ind i en fil.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello Java 7 Path";

        try {
            Path path = Paths.get("samplefile.txt");
            Files.write(path, fileContent.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

API i Java 8 Skriv til fil

Hvor BufferedWriter bruges til at skrive tekst til en karakter- eller bytestrøm. Den gemmer et tegn i bufferen og udskriver derefter i bundter.

Her er et eksempel på et Java-program til at skrive indhold til en fil ved hjælp af Java 8 API'er.

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileWriting {
    public static void main(String arg[]) {

        Path path = Paths.get("samplefile.txt");

        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
            writer.write("Hello World !!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Spørgsmål :Java skriver til filen linje for linje?

Svar :Forskellige-forskellige måder har forskellige metoder, her deler vi nogle af dem.

FileOutputStream

bufferWriter.write("new line");
bufferWriter.newLine();

FileWriter

fileWriter.write("new line");

PrintWriter

printWriter.write("New line");

OutputStreamWriter

osw.write("New line");

Et vigtigt punkt, når du laver java-skriv til fil:

Brug try-catch eller undtagelseshåndtering for at forhindre programnedbrud
Luk outputstrømmen efter brug for at frigive alle ressourcer.