Java – Zapisz do pliku

Jednym z najczęstszych zadań podczas tworzenia oprogramowania jest możliwość odczytu i zapisu plików. W Javie zapisywanie do pliku jest prostym procesem, który można wykonać przy użyciu wbudowanych klas i metod. W tym artykule przyjrzymy się sposobom zapisu do pliku przy użyciu języka Java oraz omówimy różne klasy i metody z tym związane. Java udostępnia wbudowane klasy, takie jak FileWriter i PrintWriter, umożliwiające zapis do pliku w języku Java.

Przykład zapisu Java do pliku

Na początek spójrzmy na prosty przykład zapisu do pliku w Javie. Oto przykład zapisania ciągu znaków do pliku w Javie przy użyciu klasy FileWriter :

Klasa FileWriter

Klasa FileWriter to kolejny sposób zapisu do pliku w Javie. Jest to klasa strumienia znaków, która umożliwia zapisywanie danych znakowych do pliku. Oto przykład pokazujący, jak użyć klasy FileWriter do zapisania ciągu znaków do pliku:

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


// Main method for the string to file in java starts from here,
public class WriteToFileExample {
    public static void main(String[] args) {
        // create a string to write text to file
        String data = "Hello, world!";

        try {
            // create a FileWriter object with the file name
            FileWriter writer = new FileWriter("output.txt");

            // write the string to the file
            writer.write(data);

            // close the writer
            writer.close();

            System.out.println("Successfully wrote text to file.");

        } catch (IOException e) {
            System.out.println("An error occurred.");
            e.printStackTrace();
        }
    }
}

W tym przykładzie najpierw tworzymy obiekt String o nazwie data , który zawiera tekst, który chcemy zapisać w pliku. Następnie tworzymy obiekt FileWriter z nazwą pliku, do którego chcemy pisać, w tym przypadku o nazwie Output.txt . Następnie używamy metody write() obiektu FileWriter w celu zapisania ciągu danych do pliku. Ta metoda przyjmuje argument String zawierający dane do zapisu. Na koniec zamykamy obiekt FileWriter , aby zwolnić zasoby pliku i wypisać na konsoli komunikat o powodzeniu, jeśli operacja zapisu się powiedzie, lub komunikat o błędzie, jeśli zostanie złapany wyjątek. Klasa FileWriter to prosty sposób na zapisanie danych znakowych do pliku w Javie.

Klasa FileOutputStream

Klasa FileOutputStream służy do zapisywania danych do pliku w postaci strumienia bajtów . Oto przykład:

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

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            FileOutputStream stream = new FileOutputStream("output.txt");
            byte[] bytesToWrite = textToWrite.getBytes();
            stream.write(bytesToWrite);
            stream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

W tym przykładzie tworzymy obiekt FileOutputStream o nazwie stream z nazwą pliku „output.txt” do zapisu. Następnie konwertujemy ciąg tekstowy ToWrite na tablicę bajtów za pomocą metody getBytes() i zapisujemy tablicę bajtów do obiektu strumienia za pomocą metody write() . Na koniec zamykamy obiekt strumienia .

Klasa BufferedWriter

Klasa BufferedWriter służy do zapisywania tekstu do pliku z możliwością buforowania. Oto przykład:

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

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write(textToWrite);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

W tym przykładzie tworzymy obiekt BufferedWriter o nazwie write z obiektem FileWriter , który zapisuje do pliku „output.txt”. Następnie używamy metody write() obiektu piszącego , aby zapisać tekstToWrite w pliku. Na koniec zamykamy obiekt Writer .

Metoda WriteString().

Metoda writeString () to wygodna metoda wprowadzona w Javie 11 służąca do zapisywania ciągu znaków do pliku przy użyciu klasy Files . Umożliwia zapisanie ciągu znaków do pliku w jednym wierszu kodu. Oto przykład:

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

public class WriteToFileExample {
    public static void main(String[] args) {
        // create a string to write to a file
        String data = "Hello, world!";

        // create a file object
        Path file = Paths.get("output.txt");

        try {
            // write the string to the file using writeString() method
            Files.writeString(file, data);

            System.out.println("Successfully wrote text to file.");

        } catch (IOException e) {
            System.out.println("An error occurred.");
            e.printStackTrace();
        }
    }
}

W tym przykładzie najpierw tworzymy obiekt String o nazwie data , który zawiera tekst, który chcemy zapisać w pliku. Następnie tworzymy obiekt Path o nazwie file , który reprezentuje plik, do którego chcemy zapisywać, w tym przypadku o nazwie „output.txt”. Następnie używamy metody Files.writeString() do zapisania ciągu danych do pliku reprezentowanego przez obiekt pliku . Ta metoda przyjmuje dwa argumenty: obiekt Path reprezentujący plik, w którym ma zostać zapisany, oraz obiekt String zawierający dane do zapisu. Na koniec wypisujemy na konsoli komunikat o powodzeniu, jeśli operacja zapisu się powiodła, lub komunikat o błędzie, jeśli zostanie złapany wyjątek. Metoda writeString() to wygodny sposób zapisania ciągu znaków do pliku przy użyciu języka Java 11 lub nowszego.

Klasa PrintWriter

Klasa PrintWriter automatycznie opróżnia bufor wyjściowy po zapisaniu każdej linii, zapewniając natychmiastowy zapis danych do pliku. Dzięki temu jest to wygodny wybór do zapisywania dużych ilości danych tekstowych w pliku. Oto przykład:

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

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            PrintWriter writer = new PrintWriter(new FileWriter("output.txt"));
            writer.println(textToWrite);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

W tym przykładzie tworzymy obiekt PrintWriter o nazwie write z obiektem FileWrite , który zapisuje do pliku „output.txt”. Następnie używamy metody println() obiektu piszącego , aby zapisać tekstToWrite w pliku. Na koniec zamykamy obiekt Writer .

Klasa DataOutputStream

Klasa DataOutputStream służy do zapisywania prymitywnych typów danych Java do pliku w postaci strumienia bajtów . Oto przykład:

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

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";
        int numberToWrite = 42;

        try {
            DataOutputStream stream = new DataOutputStream(new FileOutputStream("output.txt"));
            stream.writeUTF(textToWrite);
            stream.writeInt(numberToWrite);
            stream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

W tym przykładzie tworzymy obiekt DataOutputStream o nazwie stream , który zapisuje do pliku „output.txt”. Następnie używamy metody writeUTF() obiektu strumienia do zapisania ciągu tekstowego TextToWrite i metody writeInt() do zapisania liczby całkowitej numberToWrite do pliku. Na koniec zamykamy obiekt strumienia .

Klasa FileChannel

Klasa FileChannel umożliwia zapisywanie danych w pliku przy użyciu operacji we/wy mapowanych w pamięci . Oto przykład:

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

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            File file = new File("output.txt");
            RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
            FileChannel channel = randomAccessFile.getChannel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(textToWrite.getBytes());
            buffer.flip();
            channel.write(buffer);
            randomAccessFile.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

W tym przykładzie najpierw tworzymy obiekt File o nazwie file z parametrem o nazwie „output.txt”. Następnie tworzymy obiekt RandomAccessFile o nazwie randomAccessFile z obiektem pliku i trybem „rw” jako parametrami. Następnie tworzymy obiekt FileChannel o nazwie channel , który jest inicjowany przy użyciu obiektu randomAccessFile . Następnie tworzymy obiekt ByteBuffer o nazwie bufor o pojemności 1024 bajtów i jako parametr umieszczamy ciąg tekstowy TextToWrite . Następnie odwracamy obiekt bufora , aby przygotować go do zapisu i zapisujemy go do obiektu kanału za pomocą metody write() . Na koniec zamykamy obiekt randomAccessFile .

Wniosek

Podsumowując, zapisywanie pliku przy użyciu języka Java jest częstym zadaniem podczas tworzenia oprogramowania, które można wykonać przy użyciu kilku wbudowanych klas i metod. W tym artykule omówiliśmy kilka przykładów zapisu do pliku, w tym użycie klas FileOutputStream , BufferedWriter , FileWriter , PrintWriter , DataOutputStream i FileChannel . Należy pamiętać, że podczas zapisywania do pliku właściwa obsługa błędów i zamykanie pliku po zapisie ma kluczowe znaczenie dla zapewnienia prawidłowego zapisania pliku i prawidłowego zwolnienia zasobów. Dzięki przykładom podanym w tym artykule początkujący mogą teraz mieć podstawową wiedzę na temat zapisu do pliku przy użyciu języka Java i mogą zacząć ćwiczyć i eksperymentować z różnymi przypadkami użycia.