File Handling in Java

File handling refers to working with the file in java. Reading files & writing into java files is known as file handling in java. The FIle is a container that can contain different types of information. The file can contain text, images, videos, tables, etc.

ADVERTISEMENT Popular Course in this category JAVA MASTERY - Specialization | 78 Course Series | 15 Mock Tests

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

In java, the File class enables us to work with different types of files. File class is a member of the java.io packages. Java provides various methods to read, write, update & delete files.

Types of Operation

Different types of operation which can be performed on a file is given below:

• Creating a file
• Updating a file
• Deleting a file
• Uploading a file to a specific location
• Opening file
• Closing file

Syntax:

To work with files in the program, you need to import the java.io package. Importing this package will provide you with a File class that you can initialize by referencing the file in the constructor of the File class.

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

How does file Handling work?

In Java, File handling takes place by streaming concepts. Input/Output operations on a file perform through streaming. Stream refers to a sequence of data.

In java, Stream is of two types:

• Character Stream: A character stream refers to a stream that involves the characters. Data processing takes place with the Stream of characters in the files.
• Byte Stream: We call a stream that transfers data in bytes a byte stream. Data processing takes place with the Stream of bytes in the files.

File Handling Methods

Some of the methods are given below for performing different operations in java:

1. createNewFile(): createNewFile method is used to create an empty file. It returns the response as a boolean.
2. getName(): This method is used to get the file name. It returns the string, i.e., the file’s name in response.
3. getAbsolutePath(): It returns the absolute path of the file. The return type of this method is a string.
4. canRead(): This method checks whether the file is readable or not. It returns a boolean value.
5. canWrite(): This method checks whether the file is writable or not. It returns a boolean value.
6. delete(): This method is used in deleting a file. It returns a boolean value.
7. exists(): Use this method to check if a file exists. It returns a boolean value.
8. length(): This method returns the file size in bytes. The return type of this method is long.
9. list(): This method returns an array of the files available in the directory. It returns an array of string values.
10. mkdir(): To create a new directory, use this method. It returns a boolean value.

Examples of File Handling in Java

Below are examples of File Handling in Java:

Example #1

In this example, the program uses various methods to get specific details. In this application, different methods are used to get information related to files, such as:

1. Retrieving the absolute path of the file.
2. Checking whether the file is writable or not.
3. Checking whether the file is readable or not.
4. Retrieving file name.
5. Retrieving file size.
6. Obtaining a list of the files that are present in the specified directory, etc.

Code:

Importing io package different classes.

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 
<p><strong>Output</strong>:</p>
<p>In the above-given example, we can see how different methods provide the information needed to perform the different checks related to files.</p>
<p><img  src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/172500341831730.jpg?x-oss-process=image/resize,p_40" class="lazy" alt="File Handling in Java" ></p>
<h4 id="Example">Example #2</h4>
<p>This example shows how different methods are used in the program for different types of operations. exists() method used in the program to check if a file exists is not; after that, the if..else.. condition is placed.</p>
<p>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.</p>
<p><strong>Code:</strong></p>


<p>Importing io package different classes.</p>
<pre class="brush:php;toolbar:false">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.

The above is the detailed content of File Handling in Java. For more information, please follow other related articles on the PHP Chinese website!