Working with File I/O in Java

18. Working with File I/O in Java

File handling is an essential part of programming, and in Java, this is no different. The ability to read and write files is crucial for many types of applications, from data processing to content management systems. In this chapter, we will explore how Java handles Input/Output (I/O), more specifically, how to work with files using the classes and interfaces available in the standard Java API.

Streams and Readers/Writers

Before we go into the details of how to manipulate files in Java, it is important to understand the difference between Streams and Readers/Writers. Simply put, Streams are binary data flows and are used when dealing with binary data such as image or video files. Readers and Writers are for text characters and are best suited for reading and writing text data such as .txt or .csv files.

Fundamental I/O Classes

Java provides several classes in its java.io package for working with files. Some of the more fundamental classes include:

• File: Represents the path of a file or directory and can be used to create, delete, inspect and rename files or directories.
• FileInputStream and FileOutputStream: Allow reading and writing binary files, respectively.
• FileReader and FileWriter: Facilitate reading and writing text files, respectively.
• BufferedReader and BufferedWriter: Provide a buffer for reading and writing, which can improve performance when dealing with frequent I/O operations.

Reading Files with Java

To read a file in Java, you can use the FileInputStream class for binary files or FileReader for text files. Here is a basic example of how to read a text file:

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

This code uses a try-with-resources to ensure that the BufferedReader is closed after use, thus preventing resource leaks. The readLine() method reads the file line by line until the end of file (EOF) is reached.

Continue in our app.

You can listen to the audiobook with the screen off, receive a free certificate for this course, and also have access to 5,000 other free online courses.

Or continue reading below...

Download the app

Writing to Files with Java

To write to a file, you can use the FileOutputStream class for binary files or FileWriter for text files. Below is an example of how to write to a text file:

try (BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"))) {
    writer.write("First line\n");
    writer.write("Second line\n");
} catch (IOException e) {
    e.printStackTrace();
}

Just like reading, try-with-resources is used to close BufferedWriter after writing is complete. The write() method is used to write strings to the file.

Working with Binary Files

When it comes to binary files, you should use FileInputStream and FileOutputStream. Here is an example of how to copy a binary file:

try (FileInputStream in = new FileInputStream("input.bin");
     FileOutputStream out = new FileOutputStream("output.bin")) {
    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = in.read(buffer)) != -1) {
        out.write(buffer, 0, bytesRead);
    }
} catch (IOException e) {
    e.printStackTrace();
}

This example reads the input file in 1024 byte chunks and writes each chunk to the output file until the end of the input file is reached.

Handling I/O Exceptions

I/O operations can fail for a variety of reasons, such as files that do not exist, lack of permissions, or hardware problems. This is why exception handling is crucial when working with I/O in Java. I/O operations throw a IOException that must be caught or declared in the method header.

New I/O APIs

With the introduction of Java 7, the I/O API has been expanded with the java.nio.file package, which offers a more modern and flexible approach to working with files and directories. Classes like Path, Paths and Files made I/O operations more intuitive and powerful.

Conclusion

Working with files in Java is an essential skill for any programmer. Through the classes and methods provided by the I/O API, it is possible to perform complex operations of msimple and efficient way. It's important to remember to always handle I/O exceptions appropriately and use the latest APIs when possible to take advantage of the improvements and additional functionality they offer.

Practice reading and writing files of different formats and sizes will help you become familiar with the nuances of I/O in Java and prepare you to handle the data storage and processing needs of your applications.