Introduction

File handling is a crucial aspect of many Java applications, whether you’re developing simple command-line tools or complex enterprise systems. Java 8 offers a variety of methods to read and write files, each suited to different use cases. From traditional approaches using FileInputStream and FileReader to modern techniques leveraging lambda expressions and the java.nio.file package, Java 8 provides developers with powerful tools for efficient file processing.

In this short tutorial, we’ll explore multiple methods to read and write files in Java 8. You’ll learn how to read text files using BufferedReader, take advantage of the Files class introduced in Java 7, and simplify your code with lambda expressions. On the writing side, we’ll cover the use of FileOutputStream, FileWriter, and PrintWriter to help you choose the right approach for your needs. By the end of this tutorial, you’ll have a solid understanding of file handling in Java 8 and be equipped to handle files efficiently in your applications.

How to read files in java 8

In Java 8, reading files can be accomplished through several methods, each suited to different scenarios. Whether you’re dealing with large text files, need to handle character encoding, or prefer more modern approaches like lambda expressions, Java 8 provides the flexibility to do so efficiently. Below, we’ll explore various techniques to read files in Java 8, with code examples and explanations.

1. Using FileInputStream and BufferedReader

This method is useful when you need to read text from a character input stream, especially when dealing with raw binary files. Buffering characters with BufferedReader enhances the efficiency of the reading process.

Example:

javaCopy codeimport java.io.*;

File file = new File("myFile.zip");

try (FileInputStream fis = new FileInputStream(file);
     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
     
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (FileNotFoundException e) {
    // File not found
    e.printStackTrace();
} catch (IOException e) {
    // Error when reading the file
    e.printStackTrace();
}

2. Using FileReader and BufferedReade

This approach is similar to the previous one, but here we use FileReader instead of FileInputStream. FileReader is specifically designed for reading character files. However, it uses the platform’s default charset, so if you need to specify a different charset, consider using InputStreamReader.

Example:

javaCopy codeimport java.io.*;

File file = new File("myFile.txt");

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (FileNotFoundException e) {
    // File not found
    e.printStackTrace();
} catch (IOException e) {
    // Error when reading the file
    e.printStackTrace();
}

---

3. Using Files.newBufferedReader() in Java 7 and Above

Introduced in Java 7, the java.nio.file.Files class provides several static methods for file operations. Files.newBufferedReader() is similar to the previous methods but allows specifying the character encoding, and it integrates seamlessly with the try-with-resources statement for better resource management.

Example:

javaCopy codeimport java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

Path path = Paths.get("c:/tmp/myfile.csv");
Charset charset = Charset.forName("UTF-8");

try (BufferedReader reader = Files.newBufferedReader(path, charset)) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

4. Using Lambda Expressions in Java 8

Lambda expressions, introduced in Java 8, can significantly reduce the amount of boilerplate code. In this example, we read and print the content of a file in a single line using the Files.lines() method combined with a lambda expression.

Example:

javaCopy codeimport java.io.File;
import java.io.IOException;
import java.nio.file.Files;

try {
    Files.lines(new File("c:/myfile.txt").toPath())
         .forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

---

How to write files in java 8

Writing data to files is a common task in Java development. Java 8 offers several ways to handle file writing, each with its unique advantages. Whether you’re writing simple text files or need more control over the output, Java provides the flexibility you need. Below, we’ll explore different methods to write files in Java 8, along with code examples and best practices.

1. Using FileOutputStream and BufferedWriter

FileOutputStream is a low-level stream that writes bytes to a file. When combined with BufferedWriter, it can efficiently write text data by buffering the characters, reducing the number of I/O operations.

Example:

javaCopy codeimport java.io.*;

File fout = new File("myOutFile.txt");

try (FileOutputStream fos = new FileOutputStream(fout);
     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos))) {
     
    bw.write("Write something to the file...");
    bw.newLine();
} catch (FileNotFoundException e) {
    // File was not found
    e.printStackTrace();
} catch (IOException e) {
    // Problem when writing to the file
    e.printStackTrace();
}

2. Using FileWriter

FileWriter is a convenient class for writing character-based data directly to a file. It’s particularly useful for simple text files, but it does not allow specifying a charset, which might be a limitation if you need to work with different encodings.

Example:

javaCopy codeimport java.io.*;

try (FileWriter fw = new FileWriter("myOutFile.txt")) {
    fw.write("Example of content");
} catch (FileNotFoundException e) {
    // File not found
    e.printStackTrace();
} catch (IOException e) {
    // Error when writing to the file
    e.printStackTrace();
}

3. Using PrintWriter

PrintWriter offers additional features for formatted output, making it suitable for writing formatted text to files. It supports all the methods found in PrintStream, such as print() and println(), but does not handle raw bytes, which limits its use to text data.

Example:

javaCopy codeimport java.io.*;

try (PrintWriter pw = new PrintWriter("myOutFile.txt")) {
    pw.write("Example of content");
} catch (FileNotFoundException e) {
    // File not found
    e.printStackTrace();
} catch (IOException e) {
    // Error when writing to the file
    e.printStackTrace();
}

4. Using OutputStreamWriter

OutputStreamWriter is a bridge between byte streams and character streams. It allows you to specify the charset, making it ideal for scenarios where you need to write text data with a specific encoding.

Example:

javaCopy codeimport java.io.*;

File fout = new File("myOutFile.txt");

try (FileOutputStream fos = new FileOutputStream(fout);
     OutputStreamWriter osw = new OutputStreamWriter(fos)) {
     
    osw.write("Some content...");
} catch (FileNotFoundException e) {
    // File not found
    e.printStackTrace();
} catch (IOException e) {
    // Error when writing to the file
    e.printStackTrace();
}

The bottom line

Java 8 offers a variety of methods for both reading and writing files, each tailored to different needs. Whether you’re working with simple text data, formatted output, character-based content with specific encodings, or prefer the classic approach with FileInputStream and BufferedReader versus modern techniques like Files.newBufferedReader() and lambda expressions, Java provides the tools to handle it efficiently. Understanding these methods and when to use them will help you work with files more effectively in your applications. Always choose the method that best suits your needs, considering factors like file size, character encoding, and code readability. By following best practices such as using try-with-resources for automatic resource management, you can ensure your file handling code is robust and efficient.