File Handling in Java

File handling in Java refers to the process of reading from and writing to files on the filesystem using Java programs. It enables Java applications to interact with files, such as reading data from text files, writing data to files, creating new files, deleting files, and more.

In the below PDF we discuss about File Handling in Java in detail in simple language, Hope this will help in better understanding.

Example of File Handling in Java:

// Importing File Class
import java.io.File;

class Main {
public static void main(String[] args)
{

// File name specified
File obj = new File("Topperworld.txt");
System.out.println("File Created!");
}
}

Streams in Java:

The concept of Streams in Java facilitates the seamless flow of data, often used to achieve desired outcomes efficiently. In Java, Streams aren’t data structures but rather conduits for input/output operations.

Streams categorize into two main types: Input Streams and Output Streams.

1. Input Streams:
Input streams are used to read data from various input devices such as keyboards, networks, etc. While InputStream is an abstract class, its subclasses are used for reading data. These include ByteArrayInputStream, FileInputStream, AudioInputStream, etc.

Let’s create an InputStream:

InputStream buddy = new FileInputStream();

2. Output Stream:
Output streams are used to write data to output devices such as displays and files. The abstract superclass representing an output stream is OutputStream. Its subclasses include FileOutputStream, StringBufferOutputStream, ByteArrayOutputStream, PrintStream, ObjectOutputStream, and DataOutputStream.
Let’s create an OutputStream:

OutputStream buddy = new FileOutputStream();

File Operations in Java:

File operations in Java involve reading from and writing to files on the filesystem. Java provides classes and methods in the java.io package to perform file operations. These operations include creating, deleting, reading, and writing files. Here’s an overview of common file operations in Java:

Creating a File: To create a new file in Java, you can use the File class along with the createNewFile() method. Alternatively, you can use file output streams like FileOutputStream or BufferedWriter to write data to a file, which automatically creates the file if it does not exist.
Deleting a File: To delete an existing file in Java, you can use the delete() method of the File class. It deletes the file from the filesystem.
Reading from a File: To read data from a file, you can use file input streams like FileInputStream or BufferedReader. These classes provide methods to read data from the file, such as read() for reading bytes and readLine() for reading lines of text.
Writing to a File: To write data to a file, you can use file output streams like FileOutputStream or BufferedWriter. These classes provide methods to write data to the file, such as write() for writing bytes and writeLine() for writing lines of text.
Checking File Existence and Properties: You can use methods like exists() and isFile() of the File class to check if a file exists and if it is a regular file, respectively. Additionally, you can use methods like length() to get the size of the file and lastModified() to get the last modified timestamp of the file.

Here’s a simple example demonstrating file operations in Java:

import java.io.File;
import java.io.IOException;

public class FileOperationsExample {
public static void main(String[] args) {
// Creating a new file
File file = new File("example.txt");
try {
if (file.createNewFile()) {
System.out.println("File created successfully");
} else {
System.out.println("File already exists");
}

// Writing data to the file
// (Code for writing data to the file goes here)

// Reading data from the file
// (Code for reading data from the file goes here)

// Deleting the file
if (file.delete()) {
System.out.println("File deleted successfully");
} else {
System.out.println("Failed to delete the file");
}
} catch (IOException e) {
System.out.println("An error occurred: " + e.getMessage());
}
}
}

This example demonstrates file creation, writing data to the file (which is omitted for brevity), reading data from the file (also omitted), and finally, deleting the file.