Merge two text input files, alternating lines, using the Java stream API

ONLINECAST

3 min read

·

07-10-2024

7

0

Share

Merging Text Files Line-by-Line with Java Streams: A Streamlined Approach

Merging two text files, alternating lines from each, is a common task in text processing. While traditional approaches using loops and file I/O are possible, Java's Stream API provides a more elegant and concise solution. This article will demonstrate how to achieve this merge operation efficiently using Java streams.

The Problem and its Solution

Imagine you have two text files, file1.txt and file2.txt, and you want to create a new file merged.txt containing lines from both files in an alternating pattern. For example:

file1.txt:

Line 1 from file 1
Line 3 from file 1
Line 5 from file 1

file2.txt:

Line 2 from file 2
Line 4 from file 2
Line 6 from file 2

merged.txt (desired output):

Line 1 from file 1
Line 2 from file 2
Line 3 from file 1
Line 4 from file 2
Line 5 from file 1
Line 6 from file 2

Here's a Java code snippet using the stream API to accomplish this:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.stream.Stream;

public class MergeFiles {

    public static void main(String[] args) throws IOException {
        String file1 = "file1.txt";
        String file2 = "file2.txt";
        String mergedFile = "merged.txt";

        try (BufferedReader reader1 = new BufferedReader(new FileReader(file1));
             BufferedReader reader2 = new BufferedReader(new FileReader(file2));
             BufferedWriter writer = new BufferedWriter(new FileWriter(mergedFile))) {

            Stream<String> lines1 = reader1.lines();
            Stream<String> lines2 = reader2.lines();

            // Merge the streams, alternating lines
            Stream.iterate(new Object[] { lines1, lines2 },
                    pair -> new Object[] { ((Stream<?>) pair[0]).skip(1), ((Stream<?>) pair[1]).skip(1) })
                    .limit(Math.max(lines1.count(), lines2.count()))
                    .flatMap(pair -> Stream.of(((Stream<?>) pair[0]).findFirst().orElse(""),
                            ((Stream<?>) pair[1]).findFirst().orElse("")))
                    .filter(line -> !line.isEmpty())
                    .forEach(line -> {
                        try {
                            writer.write(line);
                            writer.newLine();
                        } catch (IOException e) {
                            System.err.println("Error writing to file: " + e.getMessage());
                        }
                    });
        }
    }
}

Explanation of the Code:

1. File Handling: The code uses BufferedReader to read lines from the input files and BufferedWriter to write the merged output to the merged.txt file.

2. Stream Creation: reader1.lines() and reader2.lines() create streams of lines from the respective input files.

3. Alternating Merging: Stream.iterate() generates an infinite stream of pairs of streams, each pair representing the remaining lines of the two input files after skipping the first line from each. limit() ensures the iteration stops after processing the longest of the two input files.

4. Flattening and Filtering: flatMap() flattens the stream of pairs into a stream of individual lines, alternating between the two input files. filter() removes empty lines in case one file is shorter than the other.

5. Writing to File: forEach() iterates through the merged lines and writes them to the output file using the BufferedWriter.

Benefits of Using Streams:

• Conciseness: Streams provide a declarative and concise way to express the merging logic compared to traditional looping approaches.
• Readability: The code is easier to understand and maintain, as it clearly separates the operations of reading, processing, and writing data.
• Flexibility: Streams offer a variety of intermediate operations (like filter, map, flatMap, etc.) that allow you to easily customize the merging logic based on your specific requirements.

Additional Considerations:

• Error Handling: Ensure robust error handling for potential issues like file not found, file read/write errors, and invalid input data.
• Large Files: For large files, consider using a buffered approach to read and write data in chunks to improve performance.
• Alternative Methods: For even more flexibility, consider libraries like Apache Commons IO, which provides more advanced file manipulation tools.

This article has illustrated a streamlined approach to merging text files line-by-line using the Java stream API. By leveraging the power and conciseness of streams, you can effectively solve this common text processing task with a more elegant and efficient solution.