Start Learning Free
Previous Tutorial
20
DecFile Handling in Java Complete Guide
12 Sep 2024
Beginner
613 Views
16 min read
Learn with an interactive course and practical hands-on labs
Java Online Course Free with Certificate
File Handling in Java
File handling in Java is an important programming aspect because it allows programs to interface with files to read, write, and manipulate data. Java's I/O (Input/Output) module includes a complete collection of file management utilities. Understanding Java's file-handling capabilities is critical for developing robust applications, whether you're working with text files, binary files, or custom file formats.
In this Java Tutorial, we will learn How file handling in Java works and we will also see its different operations.
Why is File Handling in Java Required?
File handling is necessary for:
- Data persistence: Saving data to files assures that it can be retrieved later, even if a program has stopped running.
- Data communication: Files enable data communication between different programs or systems.
- Large data storage: Files enable the storage of large datasets that would not fit in memory.
- Log management: Storing logs in files allows you to follow program activity and troubleshoot difficulties.
Key Concepts: Java I/O and Streams
The key concepts of file handling in Java are Java I/O and streams.Java uses streams to accomplish I/O operations. A stream is a sequence of data. Java supports two types of streams:
- Byte Streams: Handle data in raw binary format.
- Character Streams: Manage data in the form of characters.
1. Byte Streams
Byte streams are used to read and write data on the byte level.
They are handy for working with binary data, such as photos or audio files.
- InputStream: InputStream reads byte data.
- OutputStream: OutputStream writes byte data.
InputStream
The Java InputStream class is the ancestor of all input streams. The input stream reads data from a variety of input devices, such as the keyboard and network. InputStream is an abstract class, hence it is not helpful on its own. However, its subclasses serve to retrieve data.
The InputStream class has multiple subclasses, including the following:
- AudioInputStream
- ByteArrayInputStream
- FileInputStream
- FilterInputStream
- StringBufferInputStream
- ObjectInputStream
1. How to Create an InputStream
// Here we are Creating an InputStream
InputStream obj = new FileInputStream();
2. Different Methods of InputStream
| Method Name | Usage |
| read() | It reads one byte of data from the input stream. |
| read(byte[] array)() | It reads a byte from the stream and stores that byte in the specified array. |
| mark() | Marks the position in the input stream until the data has been read. |
| available() | It returns the number of bytes available in the input stream. |
| markSupported() | Check if the mark() method and the reset() method is supported in the stream. |
| reset() | It returns the control to the point where the mark was set inside the stream. |
| skips() | It skips and removes a particular number of bytes from the input stream. |
| close() | It closes the input stream. |
2. Output Stream
The output stream is used to write data to a variety of output devices, including the monitor, file, etc. OutputStream is an abstract class that denotes an output stream. OutputStream is an abstract class, hence it isn't helpful on its own. However, its subclasses are utilized to create data.
The OutputStream class has multiple subclasses, which are listed below:
- ByteArrayOutputStream
- FileOutputStream
- StringBufferOutputStream
- ObjectOutputStream
- DataOutputStream
- PrintStream
1. How to create an OutputStream
// Creating an OutputStream
OutputStream obj = new FileOutputStream();
2. Different Methods of OutputStream
| Method Name | Usage |
| write() | It writes the specified byte to the output stream. |
| write(byte[] array) | It writes the bytes inside a specific array of the output stream. |
| close() | It closes the output stream. |
| flush() | It forces to write all the data present in an output stream to the destination. |
2. Character Streams
Character streams represent data as characters. They are useful for text data, as they ensure appropriate character encoding and decoding.
- Reader: It reads character data.
- Writer: It produces character data.
Example
FileReader reader = new FileReader("input.txt");
int data = reader.read();
Core File Handling Classes in Java
Java has a number of classes that simplify file-handling procedures. These classes are found in the"java.io" and"java.nio.file"packages. there are three types of file-handling classes in Java they are as follows.- File Class
- FileReader and FileWriter
- BufferedReader and BufferedWriter
1. File Class
The File class denotes a file or directory path. It includes methods for creating, deleting, and retrieving information about files and directories.
Example
File file = new File("example.txt");
if (file.exists()) {
System.out.println("File exists");
} else {
System.out.println("File does not exist");
}
Java File Class Methods
The table below displays numerous File Class methods:
| Method Name | Description | Return Type |
| canRead() | It tests whether the file is readable or not. | Boolean |
| canWrite() | It tests whether the file is writable or not. | Boolean |
| createNewFile() | It creates an empty file. | Boolean |
| delete() | It deletes a file. | Boolean |
| exists() | It tests whether the file exists or not. | Boolean |
| length() | Returns the size of the file in bytes. | Long |
| getName() | Returns the name of the file. | String |
| list() | Returns an array of the files in the directory. | String[] |
| mkdir() | Creates a new directory. | Boolean |
| getAbsolutePath() | Returns the absolute pathname of the file. | String |
2. FileReader and FileWriter
FileReader and FileWriter are used to read and write character data from and to files. They're perfect for working with text documents.
Example of writing data
FileWriter writer = new FileWriter("example.txt");
writer.write("Welcome to Scholarhat!");
writer.close();
Example of reading data:
FileReader reader = new FileReader("example.txt");
int data;
while ((data = reader.read()) != -1) {
System.out.print((char) data);
}
reader.close();
3. Buffered Reader and BufferedWriter
BufferedReader and BufferedWriter boost performance by buffering input and output streams. They are useful for managing huge files.
Example of reading data with a buffered reader
BufferedReader br = new BufferedReader(new FileReader("example.txt"));
String line;
while ((line = br.readLine()) != null) {
System.out.println("Welcome to ScholarHat");
}
br.close();
Different Operations of File Handling in Java
1. Create File
Here, You can create a new file using the File class:
File file = new File("newFile.txt");
if (file.createNewFile()) {
System.out.println("File created successfully.");
} else {
System.out.println("File already exists.");
}
2. Write File
You can write data to files using FileWriter or BufferedWriter:FileWriter writer = new FileWriter("example.txt");
writer.write("This is file content.");
writer.close();
3. Read File
Use FileReader or BufferedReader to read data from files:BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
reader.close();
Delete Files
You can delete a file using the delete() method of the File class:File file = new File("example.txt");
if (file.delete()) {
System.out.println("File deleted successfully.");
} else {
System.out.println("Failed to delete file.");
}
Advanced File Operations
There are two advanced File Operations related to file handling in Java they are as follows
- Copying and Moving Files
- File Attributes: Size, Path, and Permissions
1. Copying and Moving Files
Java's Files class (from java.nio.file) allows you to efficiently copy and move files:
Files.copy(Paths.get("source.txt"), Paths.get("destination.txt"));
Files.move(Paths.get("source.txt"), Paths.get("newLocation.txt"));
2. File attributes
File attributes include size, path, and permissions. The File class allows you to access file attributes like size, location, and permissions.File file = new File("example.txt");
System.out.println("File size: " + file.length() + " bytes");
System.out.println("File path: " + file.getAbsolutePath());
System.out.println("Is file writable? " + file.canWrite());
Working with Different File Formats
1. Text Files
Text files contain data in a human-readable format. To work with text files, use character streams (FileReader and FileWriter).2. Binary files
Binary files hold data in a binary format, which is commonly used for photos, movies, and generated code. To handle binary files, use byte streams (FileInputStream and FileOutputStream).3. CSV files
CSV (Comma-Separated Values) files are text files that store tabular data. BufferedReader and FileWriter allow you to read and write CSV files.Example of reading CSV data:
BufferedReader br = new BufferedReader(new FileReader("data.csv"));
String line;
while ((line = br.readLine()) != null) {
String[] values = line.split(",");
System.out.println(Arrays.toString(values));
}
br.close();
Properties Files
Properties files are used to store configuration data. Java provides the Properties class for reading and writing key-value pairs.Properties props = new Properties();
props.load(new FileReader("config.properties"));
String value = props.getProperty("key");
System.out.println("Value: " + value);
Exception Handling in File Operations
File handling operations frequently throw checked exceptions, such as IOException or FileNotFoundException. To handle these exceptions, utilize a try-catch block.try {
FileReader reader = new FileReader("example.txt");
int data;
while ((data = reader.read()) != -1) {
System.out.print((char) data);
}
reader.close();
} catch (FileNotFoundException e) {
System.out.println("File not found: " + e.getMessage());
} catch (IOException e) {
System.out.println("Error reading file: " + e.getMessage());
}
Conclusion
File management in Java offers a reliable method for creating, reading, writing, and manipulating files. Whether you're dealing with text files, binary files, or particular formats such as CSV or properties files, Java's I/O package and java.nio.file package provides diverse capabilities for all file-handling requirements. Properly managing file operations and resolving errors guarantees that your Java applications deal with files in a reliable and fast manner. Also, consider our Full-Stack Java Developer Certification Training Course for better understanding of Java core concepts. Enjoy coding..!
FAQs
- Reusability: File handling allows us to preserve the information/data generated after we run the program.
- Saves Time: Some programs might require a large amount of input from their users.
File handling provides a mechanism to store the output of a program in a file and to perform various operations on it.
You can use Java handlers to respond to received events and execute corresponding business logic.