11. Basic File Handling

● File handling refers to reading from and writing to files using Java programs. ● Files allow permanent storage of data, unlike variables that lose values after program execution.

File handling is the process through which a Java program can read data from files and write data to files. This is an essential capability because it allows programs to store information permanently. Unlike variables in a program, which only hold data during the program's execution time, files can retain data even after the program ends. This means that data stored in files can be accessed at any time in the future.

Think of file handling like a library. Just as books in a library can be borrowed and returned for later use, file handling allows a program to access information stored in files whenever needed, providing a way to keep data safe and organized over time.

● Text files: Store character data (e.g., .txt files). ● Binary files: Store data in binary format (not used in Class 10 syllabus).

In Java, there are generally two types of files: text files and binary files. Text files, such as those that end in .txt, store data in a human-readable format where characters make sense to us and can be easily understood. On the other hand, binary files store data in a format that is not human-readable; they represent data in binary code, which is used for various data types and is mainly utilized in higher-level programming contexts. Understanding the difference between these file types is crucial when deciding how to handle and process data.

Imagine reading a cookbook. The printed recipes are like text files—you can read and understand the instructions easily. Now, think of a software program storing images or songs; these are like binary files. They can't be easily understood at a glance but are essential for software to function correctly.

Class Purpose FileReader Reads characters from a file BufferedReader Reads text efficiently line by line FileWriter Writes characters to a file PrintWriter Writes formatted text to a file

Java provides specific classes to handle files efficiently. The FileReader class is used for reading character data from files, while BufferedReader is a more efficient way to read text, allowing line-by-line processing. For writing data to files, you can use the FileWriter class, and if you need to write data in a formatted way, PrintWriter is the go-to class. Knowing these classes enables programmers to choose the right tool based on their specific needs for reading and writing files.

Think of the classes as different tools in a toolbox. If you want to read a book, you would use a specific tool that lets you turn the pages easily; this is like BufferedReader. If you need to write something down, you would select a specific pen—that's what PrintWriter does for your output.

import java.io.*;
class ReadFile {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("sample.txt"));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
}
}

This Java code sample demonstrates how to read content from a file named 'sample.txt'. It uses a BufferedReader to read the file one line at a time. The readLine() method retrieves each line until there are no more lines to read (indicated by null). After reading, it's essential to close the BufferedReader to free up system resources. This process allows the program to display the contents of the file to the console.

Imagine you have a long letter and you want to read it out loud. You would look at each line one by one until you finish. The code is doing something similar by reading each line of the file sequentially.

import java.io.*;
class WriteFile {
public static void main(String[] args) throws IOException {
PrintWriter pw = new PrintWriter(new FileWriter("output.txt"));
pw.println("This is a sample file.");
pw.println("File handling in Java.");
pw.close();
}
}

This Java code illustrates how to write data into a file named 'output.txt'. By using PrintWriter and FileWriter, it can create a new file or overwrite an existing one with specific text. The println() method is used to write strings to the file, and closing the PrintWriter ensures that all data is properly saved. This demonstrates the fundamental ability of Java programs to output data for storage.

Think of writing in a diary. You're putting your thoughts and experiences onto the pages; similar to that, this code captures the text and saves it into a file for later reflection.

PrintWriter pw = new PrintWriter(new FileWriter("output.txt", true));
pw.println("This line is appended.");
pw.close();

Appending to a file in Java can be done using the PrintWriter class with an option set to true, which tells the program to add new content at the end of the existing file instead of overwriting it. In this code, it adds a new line to 'output.txt' without deleting the previous content. It's important to close the writer after appending to save the changes.

Think of a scrapbook where you keep adding new pictures and notes. Each time you add something, it goes to the end of the collection without removing what was already there. The code does just that—adds new information while preserving the old.

● File handling methods may throw IOException. ● Must be handled using throws keyword or try-catch block. Example with try-catch:

try {
BufferedReader br = new BufferedReader(new FileReader("sample.txt"));
// read file
br.close();
} catch (IOException e) {
System.out.println("File not found or error reading file.");
}

When working with file operations in Java, there is always a possibility of encountering errors, such as a file not being found or a read/write issue. These errors are categorized as IOException. To handle these situations gracefully, Java requires programmers to use either a 'throws' declaration or a 'try-catch' block. In the example, a 'try-catch' structure is used to attempt file reading and catch any IO exceptions, ensuring that the program explains the error rather than crashing.

It's like trying to open a door that’s locked. You might try to turn the handle (the 'try' part), and if it doesn't work, instead of giving up (crashing), you might call for a locksmith to figure out what's wrong (the 'catch' part). The program handles errors smoothly like this.

● Useful for data persistence, such as storing user records, logs, and reports. ● Enables reading and writing of large data sets without keeping everything in memory.

File handling is crucial in programming because it allows for data persistence—the ability to keep data available across multiple runs of a program. This is important for applications that require user records, logs, and reports. Furthermore, it enables applications to work with large amounts of data that cannot be held all at once in memory, allowing for efficient processing without overwhelming system resources.

Imagine running a restaurant. You wouldn't want to remember every order from customers all day; instead, you write them down in a notebook. This way, you can refer back to the notes anytime to fulfill orders and keep track. Similarly, file handling allows programs to 'write down' data permanently for future reference.

--