Java – Tulis ke Fail

Salah satu tugas yang paling biasa dalam pembangunan perisian ialah keupayaan untuk membaca dan menulis fail. Di Java, menulis ke fail adalah proses mudah yang boleh dilakukan menggunakan kelas dan kaedah terbina dalam. Dalam artikel ini, kami akan meneroka cara menulis ke fail menggunakan Java dan membincangkan pelbagai kelas dan kaedah yang terlibat. Java menyediakan kelas terbina dalam seperti FileWriter dan PrintWriter untuk menulis ke dalam fail dalam Java.

Java Write to File Contoh

Sebagai permulaan, mari kita lihat contoh mudah menulis ke fail dalam Java. Berikut ialah contoh cara menulis rentetan pada fail dalam Java menggunakan kelas FileWriter :

Kelas FileWriter

Kelas FileWriter ialah cara lain untuk menulis ke fail dalam Java . Ia ialah kelas aliran aksara yang membolehkan anda menulis data aksara ke fail. Berikut ialah contoh yang menunjukkan cara menggunakan kelas FileWriter untuk menulis String pada fail:

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();
        }
    }
}

Dalam contoh ini, kita mula-mula mencipta objek String bernama data yang mengandungi teks yang ingin kita tulis pada fail. Kami kemudian mencipta objek FileWriter dengan nama fail yang ingin kami tulis, dalam kes ini, dinamakan output.txt . Seterusnya, kami menggunakan kaedah write() objek FileWriter untuk menulis rentetan data pada fail. Kaedah ini mengambil argumen String yang mengandungi data untuk ditulis. Akhir sekali, kami menutup objek FileWriter untuk melepaskan sumber fail dan mencetak mesej kejayaan ke konsol jika operasi tulis berjaya atau mesej ralat jika pengecualian ditangkap. Kelas FileWriter ialah cara mudah untuk menulis data aksara ke fail dalam Java.

Kelas FileOutputStream

Kelas FileOutputStream digunakan untuk menulis data ke fail sebagai aliran bait. Berikut ialah contoh:

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();
        }
    }
}

Dalam contoh ini, kami mencipta objek FileOutputStream bernama strim dengan nama fail "output.txt" untuk ditulis. Kami kemudian menukar rentetan textToWrite kepada tatasusunan bait menggunakan kaedah getBytes() dan tulis tatasusunan bait ke objek strim menggunakan kaedah write() . Akhirnya, kami menutup objek aliran .

Kelas BufferedWriter

Kelas BufferedWriter digunakan untuk menulis teks ke fail dengan keupayaan penimbalan . Berikut ialah contoh:

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();
        }
    }
}

Dalam contoh ini, kami mencipta objek BufferedWriter bernama penulis dengan objek FileWriter yang menulis ke fail "output.txt". Kami kemudian menggunakan kaedah write() objek penulis untuk menulis textToWrite ke fail. Akhirnya, kami menutup objek penulis .

Kaedah WriteString().

Kaedah writeString () ialah kaedah mudah yang diperkenalkan dalam Java 11 untuk menulis String pada fail menggunakan kelas Fail . Ia membolehkan anda menulis String pada fail dalam satu baris kod. Berikut ialah contoh:

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();
        }
    }
}

Dalam contoh ini, kita mula-mula mencipta objek String bernama data yang mengandungi teks yang ingin kita tulis pada fail. Kami kemudian mencipta fail bernama objek Path yang mewakili fail yang ingin kami tulis, dalam kes ini, dinamakan "output.txt". Seterusnya, kami menggunakan kaedah Files.writeString() untuk menulis rentetan data pada fail yang diwakili oleh objek fail . Kaedah ini mengambil dua hujah: objek Path yang mewakili fail untuk menulis, dan objek String yang mengandungi data untuk ditulis. Akhir sekali, kami mencetak mesej kejayaan ke konsol jika operasi tulis berjaya atau mesej ralat jika pengecualian ditangkap. Kaedah writeString () ialah cara yang mudah untuk menulis String pada fail menggunakan Java 11 atau lebih baru.

Kelas PrintWriter

Kelas PrintWriter secara automatik membuang penimbal keluaran selepas setiap baris ditulis, memastikan data ditulis dengan segera ke fail. Ini menjadikannya pilihan yang mudah untuk menulis sejumlah besar data teks ke fail. Berikut adalah contoh:

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();
        }
    }
}

Dalam contoh ini, kami mencipta objek PrintWriter bernama penulis dengan objek FileWrite yang menulis ke fail "output.txt". Kami kemudian menggunakan kaedah println() objek penulis untuk menulis textToWrite ke fail. Akhirnya, kami menutup objek penulis .

Kelas DataOutputStream

Kelas DataOutputStream digunakan untuk menulis jenis data Java primitif kepada fail sebagai aliran bait. Berikut ialah contoh:

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();
        }
    }
}

Dalam contoh ini, kami mencipta objek DataOutputStream bernama stream , yang menulis pada fail "output.txt". Kami kemudian menggunakan kaedah writeUTF() bagi objek aliran untuk menulis rentetan textToWrite dan kaedah writeInt() untuk menulis integer numberToWrite pada fail. Akhirnya, kami menutup objek aliran .

Kelas FileChannel

Kelas FileChannel menyediakan cara untuk menulis data ke fail menggunakan I/O yang dipetakan memori . Berikut ialah contoh:

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();
        }
    }
}

Dalam contoh ini, kami mula-mula mencipta fail bernama objek Fail dengan nama fail "output.txt" sebagai parameter. Kami kemudian mencipta objek RandomAccessFile bernama randomAccessFile dengan objek fail dan mod "rw" sebagai parameter. Kami kemudian mencipta objek FileChannel bernama channel , yang dimulakan menggunakan objek randomAccessFile . Kami kemudian mencipta objek ByteBuffer bernama penimbal dengan kapasiti 1024 bait dan meletakkan rentetan textToWrite sebagai parameter. Kami kemudian membalikkan objek penimbal untuk menyediakannya untuk menulis dan menulisnya ke objek saluran menggunakan kaedah write() . Akhirnya, kami menutup objek rawakAccessFile .

Kesimpulan

Kesimpulannya, menulis ke fail menggunakan Java adalah tugas biasa dalam pembangunan perisian yang boleh dilakukan menggunakan beberapa kelas dan kaedah terbina dalam. Dalam artikel ini, kami telah membincangkan beberapa contoh cara menulis ke dalam fail, termasuk penggunaan kelas FileOutputStream , BufferedWriter , FileWriter , PrintWriter , DataOutputStream , dan FileChannel . Adalah penting untuk ambil perhatian bahawa apabila menulis ke fail, pengendalian ralat yang betul dan penutupan fail selepas menulis adalah penting untuk memastikan fail disimpan dengan betul dan sumber dikeluarkan dengan betul. Dengan contoh yang disediakan dalam artikel ini, pemula kini boleh mempunyai pemahaman asas tentang cara menulis ke fail menggunakan Java dan boleh mula berlatih dan bereksperimen dengan kes penggunaan yang berbeza.