Pengendalian Fail dalam Java

Pengendalian fail merujuk kepada bekerja dengan fail dalam java. Membaca fail & menulis ke dalam fail java dikenali sebagai pengendalian fail dalam java. FIle ialah bekas yang boleh mengandungi pelbagai jenis maklumat. Fail boleh mengandungi teks, imej, video, jadual, dsb.

IKLAN Kursus Popular dalam kategori ini JAVA MASTERY - Pengkhususan | 78 Siri Kursus | 15 Ujian Olok-olok

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Dalam java, kelas Fail membolehkan kami bekerja dengan jenis fail yang berbeza. Kelas fail ialah ahli pakej java.io. Java menyediakan pelbagai kaedah untuk membaca, menulis, mengemas kini & memadam fail.

Jenis Operasi

Jenis operasi yang berbeza yang boleh dilakukan pada fail diberikan di bawah:

• Mencipta fail
• Mengemas kini fail
• Memadamkan fail
• Memuat naik fail ke lokasi tertentu
• Membuka fail
• Menutup fail

Sintaks:

Untuk bekerja dengan fail dalam program, anda perlu mengimport pakej java.io. Mengimport pakej ini akan memberi anda kelas Fail yang boleh anda mulakan dengan merujuk fail dalam pembina kelas Fail.

//importing file class
import java.io.File;
//File name passed to the object
File fileObj = new File("file.txt");

Bagaimanakah Pengendalian fail berfungsi?

Di Java, pengendalian Fail berlaku melalui konsep penstriman. Operasi Input/Output pada fail dilakukan melalui penstriman. Strim merujuk kepada jujukan data.

Dalam java, Stream terdiri daripada dua jenis:

• Strim Watak: Strim watak merujuk kepada strim yang melibatkan watak. Pemprosesan data berlaku dengan Strim aksara dalam fail.
• Strim Byte: Kami memanggil strim yang memindahkan data dalam bait sebagai strim bait. Pemprosesan data berlaku dengan Strim bait dalam fail.

Kaedah Pengendalian Fail

Beberapa kaedah diberikan di bawah untuk melaksanakan operasi yang berbeza dalam java:

1. createNewFile(): kaedah createNewFile digunakan untuk mencipta fail kosong. Ia mengembalikan respons sebagai boolean.
2. getName(): Kaedah ini digunakan untuk mendapatkan nama fail. Ia mengembalikan rentetan, iaitu, nama fail sebagai balasan.
3. getAbsolutePath(): Ia mengembalikan laluan mutlak fail. Jenis pemulangan kaedah ini ialah rentetan.
4. canRead(): Kaedah ini menyemak sama ada fail boleh dibaca atau tidak. Ia mengembalikan nilai boolean.
5. canWrite(): Kaedah ini menyemak sama ada fail boleh ditulis atau tidak. Ia mengembalikan nilai boolean.
6. delete(): Kaedah ini digunakan dalam memadam fail. Ia mengembalikan nilai boolean.
7. wujud(): Gunakan kaedah ini untuk menyemak sama ada fail wujud. Ia mengembalikan nilai boolean.
8. length(): Kaedah ini mengembalikan saiz fail dalam bait. Jenis pemulangan kaedah ini adalah panjang.
9. list(): Kaedah ini mengembalikan tatasusunan fail yang tersedia dalam direktori. Ia mengembalikan tatasusunan nilai rentetan.
10. mkdir(): Untuk mencipta direktori baharu, gunakan kaedah ini. Ia mengembalikan nilai boolean.

Contoh Pengendalian Fail dalam Java

Di bawah ialah contoh Pengendalian Fail dalam Java:

Contoh #1

Dalam contoh ini, program menggunakan pelbagai kaedah untuk mendapatkan butiran khusus. Dalam aplikasi ini, kaedah berbeza digunakan untuk mendapatkan maklumat berkaitan fail, seperti:

1. Mendapatkan semula laluan mutlak fail.
2. Menyemak sama ada fail boleh ditulis atau tidak.
3. Menyemak sama ada fail itu boleh dibaca atau tidak.
4. Mengambil semula nama fail.
5. Mendapatkan semula saiz fail.
6. Mendapatkan senarai fail yang terdapat dalam direktori yang ditentukan, dsb.

Kod:

Mengimport pakej io kelas yang berbeza.

import java.io.File;
import java.io.IOException;
public class FileHandlingExample2 {
public static void main(String[] args) {
// Creating an object of a file
File fileObj = new File("D:/Programs/fileHandlingOperations.txt");
if (fileObj.exists()) {
//retrieving the path of the specified file
System.out.println("\nSpecified file path: " + fileObj.getAbsolutePath());
//checking whether the file is writable or not
System.out.println("\nIs the file Writable: " + fileObj.canWrite());
//checking whether the file is Readable or not
System.out.println("\nIs the file Readable " + fileObj.canRead());
//retrieving file name
System.out.println("\nFile name: " + fileObj.getName());
//retrieving file size
System.out.println("\nFile size (in bytes) " + fileObj.length());
File fileDirObj = new File("D:/Programs/");
String[] fileList = fileDirObj.list();
//displaying here the list of files available in the directory
for (int i = 0; i < fileList.length; i++) {
System.out.print("\n" + fileList[i]);
}
System.out.println("\n");
}
else {
System.out.println("Specified file does not exist.");
}
}
}

Output:

Dalam contoh yang diberikan di atas, kita dapat melihat cara kaedah yang berbeza menyediakan maklumat yang diperlukan untuk melakukan semakan berbeza yang berkaitan dengan fail.

Contoh #2

Contoh ini menunjukkan cara kaedah berbeza digunakan dalam program untuk jenis operasi yang berbeza. exists() kaedah yang digunakan dalam atur cara untuk menyemak sama ada fail wujud tidak; selepas itu, keadaan if..else.. diletakkan.

In the If condition, it checks first whether the existing file is writable or not; if the existing file remains writable, then the code block under the if section uses the FileWriter class method to write content into the existing file.

Code:

Importing io package different classes.

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileHandlingExample {
public static void main(String[] args) {
try {
File fileObj = new File("D:/Programs/fileHandlingOperations.txt");
if(fileObj.exists()){
System.out.println("File already exists.");
if(fileObj.canWrite()){
//creating object of FileWriter class to write things on file
FileWriter fwObj = new FileWriter("D:/Programs/fileHandlingOperations.txt");
// Writes this content into the specified file
fwObj.write("It is a basic example of writing in file!");
//closing the files once writing completed
fwObj.close();
System.out.println("\nContent has been written to the file.");
}else{
System.out.println("\nFile is not in writable mode.");
}
;
}else{
if (fileObj.createNewFile()) {
System.out.println("New File created: " + fileObj.getName());
}
}
}
catch (IOException ioError) {
System.out.println("An error occurred.");
ioError.printStackTrace();
}
}
}

Output:

In the above-given example, After compilation, running the program the first time will create a file with the specified name in the program.

Running the program a second time will write the content in the existing file.

Conclusion

The article above explains what a file is, how to perform operations on it, and how file handling works. It was also demonstrated in the above section about classes & methods that can be used to work with files in java.

Atas ialah kandungan terperinci Pengendalian Fail dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!