Java – Sumulat sa File

Ang isa sa mga pinakakaraniwang gawain sa pagbuo ng software ay ang kakayahang magbasa at magsulat ng mga file. Sa Java, ang pagsulat sa isang file ay isang direktang proseso na maaaring gawin gamit ang mga built-in na klase at pamamaraan. Sa artikulong ito, tutuklasin natin kung paano sumulat sa isang file gamit ang Java at talakayin ang iba't ibang klase at pamamaraang kasangkot. Nagbibigay ang Java ng mga built-in na klase tulad ng FileWriter at PrintWriter upang magsulat sa isang file sa Java.

Java Write to File Halimbawa

Upang magsimula, tingnan natin ang isang simpleng halimbawa ng pagsulat sa isang file sa Java. Narito ang isang halimbawa kung paano magsulat ng string sa isang file sa Java gamit ang klase ng FileWriter :

Klase ng FileWriter

Ang klase ng FileWriter ay isa pang paraan upang magsulat sa isang file sa Java. Ito ay isang klase ng stream ng character na nagbibigay-daan sa iyong magsulat ng data ng character sa isang file. Narito ang isang halimbawa na nagpapakita kung paano gamitin ang klase ng FileWriter upang magsulat ng String sa isang file:

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

Sa halimbawang ito, gumawa muna kami ng String object na pinangalanang data na naglalaman ng text na gusto naming isulat sa isang file. Pagkatapos ay lumikha kami ng isang FileWriter object na may pangalan ng file na gusto naming sulatan, sa kasong ito, pinangalanang output.txt . Susunod, ginagamit namin ang write() na paraan ng FileWriter object upang isulat ang string ng data sa file. Ang pamamaraang ito ay tumatagal ng argumentong String na naglalaman ng data na isusulat. Sa wakas, isinasara namin ang object ng FileWriter upang ilabas ang mga mapagkukunan ng file at mag-print ng mensahe ng tagumpay sa console kung matagumpay ang pagpapatakbo ng pagsulat o isang mensahe ng error kung may nahuli. Ang klase ng FileWriter ay isang simpleng paraan upang magsulat ng data ng character sa isang file sa Java.

Klase ng FileOutputStream

Ang klase ng FileOutputStream ay ginagamit upang magsulat ng data sa isang file bilang isang stream ng mga byte. Narito ang isang halimbawa:

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

Sa halimbawang ito, gumawa kami ng FileOutputStream object na pinangalanang stream na may "output.txt" file name para sulatan. Pagkatapos ay i-convert namin ang textToWrite string sa isang byte array gamit ang getBytes() method at isulat ang byte array sa stream object gamit ang write() method. Sa wakas, isinasara namin ang stream object.

BufferedWriter Class

Ang klase ng BufferedWriter ay ginagamit upang magsulat ng teksto sa isang file na may mga kakayahan sa pag-buffer. Narito ang isang halimbawa:

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

Sa halimbawang ito, gumawa kami ng BufferedWriter object na pinangalanang writer na may FileWriter object na nagsusulat sa "output.txt" file. Pagkatapos ay ginagamit namin ang write() na paraan ng object na manunulat upang isulat ang textToWrite sa file. Sa wakas, isinasara namin ang object ng manunulat .

WriteString() na pamamaraan

Ang writeString() method ay isang maginhawang paraan na ipinakilala sa Java 11 para sa pagsusulat ng String sa isang file gamit ang Files class. Pinapayagan ka nitong magsulat ng String sa isang file sa isang linya ng code. Narito ang isang halimbawa:

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

Sa halimbawang ito, gumawa muna kami ng String object na pinangalanang data na naglalaman ng text na gusto naming isulat sa isang file. Pagkatapos, gumawa kami ng Path object na pinangalanang file na kumakatawan sa file na gusto naming sulatan, sa kasong ito, pinangalanang "output.txt". Susunod, ginagamit namin ang paraan ng Files.writeString() upang isulat ang string ng data sa file na kinakatawan ng object ng file . Ang pamamaraang ito ay tumatagal ng dalawang argumento: ang Path object na kumakatawan sa file na susulatan, at ang String object na naglalaman ng data na isusulat. Panghuli, nag-print kami ng mensahe ng tagumpay sa console kung matagumpay ang pagpapatakbo ng pagsulat o isang mensahe ng error kung may nahuli. Ang writeString() na paraan ay isang maginhawang paraan upang magsulat ng String sa isang file gamit ang Java 11 o mas bago.

Klase ng PrintWriter

Awtomatikong pinapa-flush ng klase ng PrintWriter ang buffer ng output pagkatapos maisulat ang bawat linya, na tinitiyak na ang data ay agad na naisulat sa file. Ginagawa nitong isang maginhawang pagpipilian para sa pagsulat ng malalaking halaga ng data ng teksto sa isang file. Narito ang isang halimbawa:

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

Sa halimbawang ito, gumawa kami ng isang PrintWriter object na pinangalanang writer na may FileWrite object na nagsusulat sa "output.txt" file. Pagkatapos ay ginagamit namin ang println() na paraan ng object ng manunulat upang isulat ang textToWrite sa file. Sa wakas, isinasara namin ang object ng manunulat .

Klase ng DataOutputStream

Ang klase ng DataOutputStream ay ginagamit upang magsulat ng mga primitive na uri ng data ng Java sa isang file bilang isang stream ng mga byte. Narito ang isang halimbawa:

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

Sa halimbawang ito, gumawa kami ng object na DataOutputStream na pinangalanang stream , na nagsusulat sa "output.txt" na file. Pagkatapos ay ginagamit namin ang writeUTF() na paraan ng stream object upang isulat ang textToWrite string at ang writeInt() na paraan upang isulat ang numberToWrite integer sa file. Sa wakas, isinasara namin ang stream object.

Klase ng FileChannel

Ang klase ng FileChannel ay nagbibigay ng paraan upang magsulat ng data sa isang file gamit ang memory-mapped I/O. Narito ang isang halimbawa:

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

Sa halimbawang ito, gumawa muna kami ng File object na pinangalanang file na may pangalan ng file na "output.txt" bilang isang parameter. Pagkatapos ay lumikha kami ng isang RandomAccessFile object na pinangalanang randomAccessFile na may file object at ang "rw" mode bilang mga parameter. Pagkatapos ay lumikha kami ng isang bagay na FileChannel na pinangalanang channel , na pinasimulan gamit ang randomAccessFile object. Pagkatapos ay lumikha kami ng isang ByteBuffer object na pinangalanang buffer na may kapasidad na 1024 bytes at ilagay ang textToWrite string bilang parameter. Pagkatapos ay i-flip namin ang buffer object upang ihanda ito para sa pagsusulat at isulat ito sa channel object gamit ang write() method. Sa wakas, isinasara namin ang randomAccessFile object.

Konklusyon

Sa konklusyon, ang pagsulat sa isang file gamit ang Java ay isang karaniwang gawain sa pagbuo ng software na maaaring gawin gamit ang ilang mga built-in na klase at pamamaraan. Sa artikulong ito, tinalakay namin ang ilang halimbawa kung paano magsulat sa isang file, kabilang ang paggamit ng mga klase ng FileOutputStream , BufferedWriter , FileWriter , PrintWriter , DataOutputStream , at FileChannel . Mahalagang tandaan na kapag sumusulat sa isang file, ang wastong paghawak ng error at pagsasara ng file pagkatapos ng pagsulat ay mahalaga upang matiyak na ang file ay maayos na nai-save at ang mga mapagkukunan ay nailabas nang maayos. Sa mga halimbawang ibinigay sa artikulong ito, ang mga nagsisimula ay maaari na ngayong magkaroon ng pangunahing pag-unawa sa kung paano sumulat sa isang file gamit ang Java at maaaring magsimulang magsanay at mag-eksperimento sa iba't ibang mga kaso ng paggamit.