Replace Specific Word From File With Java

1. Introduction

In this tutorial, we’ll see how we can replace a specific word in a file using various standard Java packages and the Apache Commons IO library.

2. Sample Data

We’ll use the sample data and parameters defined below for all our examples in this tutorial.

Firstly, let’s start by creating a simple file named data.txt that we’ll use as an input file:

This is a sample file.
This is a sample file.
This is a sample file.

Furthermore, we’ll use the following sample values, like the file path, the output file path, and the output to verify:

private static final String FILE_PATH = "src/test/resources/data.txt";
private static final String FILE_OUTPUT_PATH = "src/test/resources/data_output.txt";
private static final String OUTPUT_TO_VERIFY 
  = "This is a test file."+System.lineSeparator()+"This is a test file."+System.lineSeparator()+"This is a test file.";

3. Using BufferedReader

Let’s explore the BufferedReader class, which allows us to read a file line by line.

First, we’ll traverse the file line by line and use a StringBuilder to append the whole line. We’ll also append the new line character while appending the data. With this, we’ll have the file content stored with us. Then, we’ll use the String replace() method to replace the required word in the whole file content, and then write back the data to the file:

@Test
void givenFile_whenUsingBufferedReader_thenReplacedWordCorrect() throws IOException {
    StringBuilder fileContent = new StringBuilder();
    try (BufferedReader br = Files.newBufferedReader(Paths.get(FILE_PATH))) {
        String line;
        while ((line = br.readLine()) != null) {
            fileContent.append(line).append(System.lineSeparator());
        }
        String replacedContent = fileContent.toString().replace("sample", "test").trim();
        try (FileWriter fw = new FileWriter(FILE_OUTPUT_PATH)) {
            fw.write(replacedContent);
        }
        assertEquals(OUTPUT_TO_VERIFY, replacedContent);
    }
}

With this approach, we have replaced the word in the whole file and written back the updated content to the file using FileWriter.

4. Using Scanner

We can achieve the same result with a similar approach using the Scanner class:

@Test
void givenFile_whenUsingScanner_thenReplacedWordCorrect() throws IOException {
    StringBuilder fileContent = new StringBuilder();
    try (Scanner scanner = new Scanner(new File(FILE_PATH))) {
        while (scanner.hasNextLine()) {
            fileContent.append(scanner.nextLine()).append(System.lineSeparator());
        }
        String replacedContent = fileContent.toString().replace("sample", "test").trim();
        try (FileWriter fw = new FileWriter(FILE_OUTPUT_PATH)) {
            fw.write(replacedContent);
        }
        assertEquals(OUTPUT_TO_VERIFY, replacedContent);
    }
}

5. Using NIO2 Files

Let’s explore the NIO2 Files API. Its lines() method provides a stream to read a file line by line. Using the lambda function, we’ll replace the word with the desired word in each line:

@Test
void givenFile_whenUsingFilesAPI_thenReplacedWordCorrect() throws IOException{
    try (Stream lines = Files.lines(Paths.get(FILE_PATH))) {
        List list = lines.map(line -> line.replace("sample", "test"))
          .collect(Collectors.toList());
        Files.write(Paths.get(FILE_OUTPUT_PATH), list, StandardCharsets.UTF_8);
        assertEquals(OUTPUT_TO_VERIFY, String.join(System.lineSeparator(), list));
    }
}

First, we’ve created the list with the updated file data, and then we write the updated data using the Files.write() method.

6. Using Apache Commons IO

We can use the Apache Commons IO library. We’ll use the FileUtils class. This class provides the readLines() method, using which we can read the whole file into a list.

Similarly, we’ll use the approach of StringBuilder along with the String replace() method:

@Test
void givenFile_whenUsingFileUtils_thenReplacedWordCorrect() throws IOException{
    StringBuilder fileContent = new StringBuilder();
    List lines = FileUtils.readLines(new File(FILE_PATH), "UTF-8");
    lines.forEach(line -> fileContent.append(line).append(System.lineSeparator()));
    String replacedContent = fileContent.toString().replace("sample", "test").trim();
    try (FileWriter fw = new FileWriter(FILE_OUTPUT_PATH)) {
        fw.write(replacedContent);
    }
    assertEquals(OUTPUT_TO_VERIFY, replacedContent);
}

Again, we’ll write the updated data using the FileWriter. Note that this approach causes a file to be stored in memory twice, once as the original and once with updated data. While this is acceptable for small files, it may cause memory issues or performance degradation with large files.

7. Using Memory-Efficient Approach

Each of the above approaches stores the updated file content in memory, which increases memory usage.

Let us take a look at the memory-efficient approach. While reading the file line by line, we’ll continuously write that line to the file using Files.writeString() method:

@Test
void givenLargeFile_whenUsingFilesAPI_thenReplacedWordCorrect() throws IOException {
    try (Stream lines = Files.lines(Paths.get(FILE_PATH))) {
        Files.writeString(Paths.get(FILE_OUTPUT_PATH), "",
          StandardCharsets.UTF_8, StandardOpenOption.CREATE,StandardOpenOption.TRUNCATE_EXISTING);
        lines.forEach(line -> {
            line = line.replace("sample", "test") + System.lineSeparator();
            try {
                Files.writeString(Paths.get(FILE_OUTPUT_PATH),line,StandardCharsets.UTF_8, 
                  StandardOpenOption.APPEND);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
        assertEquals(OUTPUT_TO_VERIFY, Files.readString(Paths.get(FILE_OUTPUT_PATH)).trim());
    }
}

As a result, we’ll replace the word and continuously write the updated data in the file. Note that this stores an extra new line at the end of the file. While reading the data back from the file, we can use the trim() method.

This approach allows us not to store the whole file in memory, but also causes high IO operations, increasing CPU usage.

8. Conclusion

In this article, we have looked at the different ways to replace a specific word in a file with Java IO & NIO packages and Apache Commons. We should pick the approach considering whether an application can sustain more CPU usage or more memory usage.

All of the code in this article is available over on GitHub.