Chapter- 6

File Handling in Java

Liang, Introduction to Java Programming, Eighth Edition, (c) 2011 Pearson Education, Inc. All rights reserved. 1
0132130807
Introduction of File handling
• File handling in Java allows you to create, read, update, and
delete files on the file system.
• Java provides various classes and methods in the `java.io`
and `java.nio.file` packages to facilitate these operations.
• In programming languages, file handling typically involves
opening a file, performing read or write operations on the file,
and then closing the file once the operations are completed.
• This ensures that the data is properly saved and the file
resources are released.
• File handling is essential for tasks such as reading
configuration files, saving user data, logging information, and
processing large datasets

Liang, Introduction to Java Programming, Eighth Edition, (c) 2011 Pearson Education, Inc. All rights reserved. 2
0132130807
Key Topics of File Handling
1. **File Class** - Represents a file or directory path in the file system.

2. **FileReader and FileWriter**- Used for reading from and writing to text files.

3. **BufferedReader and BufferedWriter**- Provide buffering for reading and writing,

improving performance.

4. **PrintWriter** - Provides convenient methods to write formatted text to files.

5. **FileInputStream and FileOutputStream**- Used for reading and writing binary files.

6. **Serialization** - Converting an object into a byte stream for saving to a file.

7. **NIO (New Input/Output)**- Introduces classes like `Path`, `Files` for advanced file operation.
File class
In Java, the File class is used to represent file and directory paths in the file system. This class is part of
the java.io package and provides methods to interact with files and directories. Here is a brief overview of
the File class in Java:
•Creation: You can create a File object by providing a file path or a directory path as a string:
File file = new File("path/to/file.txt");
•File Operations: The File class provides methods to perform various file operations such as checking if
a file exists, creating a new file, deleting a file, getting file information, etc.
•File file = new File("path/to/file.txt");
•// Check if the file exists
boolean fileExists = file.exists(); file.exists();
•Directory Operations: You can also use the File class to perform operations on directories such as
listing files in a directory, creating a new directory, deleting a directory, etc
File directory = new File("path/to/directory"); // List files in a directory
String[] filesInDirectory = directory.list();
•File Path Manipulation: The File class provides methods to manipulate file paths, such as getting the
parent directory, checking if a path is a directory, etc.
boolean isDirectory = file.isDirectory();
•The File class in Java is a versatile class that allows you to work with files and directories in a platform-
independent way. It is commonly used for file handling operations in Java applications.
Using the File Class java example
import java.io.File;

public class FileExample

{
public static void main(String[] args)
{
File file = new File("example.txt");
// Check if the file exists
if (file.exists()) {
System.out.println("File exists.");
}
else {
System.out.println("File does not exist.");
}
}
}
FileReader and FileWriter classes
In Java, FileReader and FileWriter classes are used for reading and writing character
data from and to files, respectively.These classes are used for text files and are built
on top of the InputStreamReader and OutputStreamWriterclasses, providing convenient
methods for handling character-based input and output.

FileReader
•Reading from Files: FileReader is used to read character data from files. It reads
data from a file one character at a time.
Closing the Reader: It's important to close the FileReader once you're done with it
to release system resources.
FileWriter
•Writing to Files: FileWriter is used to write character data to files. It writes data to a
file one character at a time.
Flushing and Closing: It's important to flush and close the FileWriter to ensure that
all data is written to the file and to release system resources.
Using BufferedReader and BufferedWriter
For better performance when reading and writing text files, it's common to
use BufferedReader and BufferedWriter in combination
with FileReader and FileWriter:
Reading from a File using FileReader and BufferedReader
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFileExample {

public static void main(String[] args)
{
String filePath = "example.txt";
try (BufferedReader br = new BufferedReader(new FileReader(filePath)))
{
String line;
while ((line = br.readLine()) != null)
{
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Writing to a File using FileWriter and BufferedWriter
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class WriteFileExample {

public static void main(String[] args) {
String filePath = "example.txt";

try (BufferedWriter bw = new BufferedWriter(new FileWriter(filePath))) {

bw.write("Hello, World!");
bw.newLine();
bw.write("Welcome to file handling in Java.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
PrintWriter
In Java, PrintWriter is a class that provides convenient methods for writing formatted text
to a file. It is often used for writing character data to text files. PrintWriter is built on top
of Writer and OutputStreamWriter classes, allowing for easy writing of text data to files.
Here's an overview of how to use PrintWriter in Java:
Writing Text to a File with PrintWriter
You can create a PrintWriter object by passing a file name or a File object to its
constructor. You can then use methods like print, println, and printf to write formatted text
to the file.
Appending to an Existing File
You can also create a PrintWriter that appends text to an existing file by passing a second
parameter with the value true to the constructor.
Closing the PrintWriter
It's good practice to close the PrintWriter once you are done with it to ensure that all data
is flushed and the file resources are released properly.
Exception Handling
Remember to handle any potential IOException that may occur during file operations to
gracefully manage errors.
PrintWriter in Java is a useful class for writing character data to files in a simple and
efficient manner, providing methods that make it easy to format and write text to files.
Using PrintWriter to Write to a File in java
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class PrintWriterExample {

public static void main(String[] args) {
String filePath = "example.txt";

try (PrintWriter pw = new PrintWriter(filePath)) {

pw.println("Printing to a file using PrintWriter.");
pw.printf("Number: %d, String: %s%n", 10, "Java");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
FileInputStream and FileOutputStream
In Java, FileInputStream and FileOutputStream are classes used for reading and writing binary
data from and to files, respectively. These classes are used for operations on binary files, which
can include images, audio files, video files, and any other type of non-text files.
Here's an overview of how to use FileInputStream and FileOutputStream in Java:
FileInputStream
•Reading from Files: FileInputStream is used to read binary data from files. It reads data from a
file byte by byte.
•Closing the Stream: It's important to close the FileInputStream once you are finished reading
from the file to release system resources.
FileOutputStream
•Writing to Files: FileOutputStream is used to write binary data to files. It writes data to a file byte
by byte.
•Flushing and Closing: It's important to flush and close the FileOutputStream to ensure that all
data is written to the file and to release system resources.
Using Buffered Streams for Better Performance
For better performance when reading and writing binary files, you can
use BufferedInputStream and BufferedOutputStream in combination
with FileInputStream and FileOutputStream:
•By using buffered streams, you can efficiently read and write binary data in larger chunks,
Reading and Writing Binary Files using FileInputStream and
FileOutputStream
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BinaryFileExample {
public static void main(String[] args) {
String filePath = "data.bin";
// Writing binary data
try (FileOutputStream fos = new FileOutputStream(filePath)) {
fos.write(65); // Writing the ASCII value of 'A'
fos.write(66); // Writing the ASCII value of 'B'
} catch (IOException e) {
e.printStackTrace();
}
// Reading binary data
try (FileInputStream fis = new FileInputStream(filePath)) {
int data;
while ((data = fis.read()) != -1) {
System.out.print((char) data); // Convert to character and print
}
} catch (IOException e)
{e.printStackTrace();
}
}
AnyQuestions?

Liang, Introduction to Java Programming, Eighth Edition, (c) 2011 Pearson Education, Inc. All rights reserved.
0132130807