Remove Line Breaks from a File in Java

Handling files is a common task, and sometimes it becomes necessary to manipulate the content within these files. One such operation is removing line breaks from a file. Line breaks can be in different formats such as '\n' (Unix/Linux), '\r\n' (Windows), or '\r' (older Macintosh systems).

Line breaks create new lines in text files, sometimes disrupting our data processing. Removing these line breaks can be essential for data preprocessing, parsing, or formatting tasks. This article will explore various approaches to removing line breaks from files in Java.

1. Text File Example with Line Breaks

File Content (javacodegeeks.txt):

This is a line of text
in a text file.

Here's another line
with some content.

And a final line
to wrap things up.

Explanation:

This text file, named javacodegeeks.txt, contains several lines of text. Each new line is marked by a line break character, typically represented by \n (newline) in Unix-based systems or \r\n (carriage return + newline) in Windows systems.

Therefore, if we use the code example provided in this article to remove line breaks from this file, the resulting output would be:

This is a line of textin a text file.Here's another linewith some content.And a final lineto wrap things up.

All the lines would be concatenated together without any separation.

Note: Files might include additional whitespace characters (e.g., spaces or tabs) before or after line breaks. While these whitespace characters are not part of the line breaks themselves, they can affect the output if not properly handled during line break removal.

2. Replacing Specific Line Break Characters

This approach targets the most common line break characters used in different operating systems.

import java.nio.file.Paths;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public class RemoveLineBreaksReplace {  
    

   public static String readFromFile(String filename) throws Exception {
        Path filePath = Paths.get("src/main/resources/" + filename);
        return Files.readString(filePath, StandardCharsets.UTF_8);
    }
   
   
    public static String removeLineBreaksReplace(String content) throws Exception {
        // Replace newline character with an empty string
        String noLineBreaks = content.replace("\n", "");
        // Replace carriage return character with an empty string
        noLineBreaks = noLineBreaks.replace("\r", "");
        return noLineBreaks;
    }
    
    
    public static void main(String[] args) {
        try {
            // Call the removeLineBreaksReplace method with content as argument
            String content = readFromFile("javacodegeeks.txt");
            String result = removeLineBreaksReplace(content);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

In this code:

• The readFromFile method takes the filename as input and constructs the path relative to the src/main/resources directory.
• We use Files.readString(Path path, Charset cs) method to directly read the content of the file as a string. The obtained content is passed to the removeLineBreaksReplace method for further processing.
• The removeLineBreaksReplace method takes a String text as input and employs the replace method twice. The first replaces all occurrences of the newline character ("\n") with an empty string (""). This caters to Unix-based systems. The second replace targets the carriage return character ("\r"), commonly used in Windows line endings, and replaces them with empty strings as well.
• The method returns the modified String noLineBreaks without line breaks.

The output is:

3. Using Regular Expressions

We can use regular expressions which offers a more versatile approach to handling various line break combinations like this:

public class RemoveLineBreaksRegex {

    public static String readFromFile(String filename) throws Exception {
        Path filePath = Paths.get("src/main/resources/" + filename);
        return Files.readString(filePath, StandardCharsets.UTF_8);
    }

    public static String removeLineBreaksRegex(String text) {
        // Remove any combination of \r and \n with an empty string
        return text.replaceAll("[\\r\\n]+", "");
    }

    public static void main(String[] args) {
        try {
            // Call the removeLineBreaksReplace method with content as argument
            String content = readFromFile("javacodegeeks.txt");
            String result = removeLineBreaksRegex(content);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

In this code:

• The removeLineBreaksRegex method also accepts a String text as input.
• It utilizes the replaceAll method with a regular expression.
• We use replaceAll("[\\r\\n]+", "") to match any combination of \r and \n with an empty string. The regular expression [\\r\\n]+ matches one or more occurrences (+) of either \r (carriage return) or \n (newline) characters. This ensures compatibility across different operating systems.
• The replacement string is empty (""), effectively removing all matched line breaks.

Note that we can consider replacing line breaks with a space (" ") instead of an empty string if we want words from different lines to be concatenated.

4. Including System.getProperty("line.separator")

We can incorporate System.getProperty("line.separator") to handle different line break characters across operating systems. This approach offers flexibility compared to replacing specific characters like \n and \r as it adapts to the system’s default line separator.

Example:

public class RemoveLineBreaksReplaceSystemProperty {

    public static void main(String[] args) throws IOException {

        // Read the file content
        String content = new String(Files.readAllBytes(Paths.get("src/main/resources/javacodegeeks.txt")));

        // Replace line separator with an empty string       
        String noLineBreaks = content.replace(System.getProperty("line.separator"), "");

        try ( // Write the modified content to a new file (optional)
                BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/output.txt"))) {
            writer.write(noLineBreaks);
        }

        System.out.println(noLineBreaks);
    }
}

Explanation:

• This code reads the entire file content into a String variable content.
• The System.getProperty("line.separator") method retrieves the platform-specific line separator string (e.g., \n for Unix-based systems, \r\n for Windows).
• The replace method is used to replace all occurrences of this line separator String with an empty string (""), effectively removing the line breaks regardless of the operating system.

5. Combining readAllLines() and join()

This approach utilizes the Files.readAllLines method for a more direct solution:

public class RemoveLineBreaksReadAllLines {

    public static String removeLineBreaksReadAllLines(String filename) throws IOException {

        Path filePath = Paths.get("src/main/resources/" + filename);

        List lines = Files.readAllLines(filePath, StandardCharsets.UTF_8);

        // Join the List into a single String
        String content = String.join("", lines);

        return content;

    }

    public static void main(String[] args) {
        try {
            // Call the removeLineBreaksReadAllLines method 
            String result = removeLineBreaksReadAllLines("javacodegeeks.txt");
            System.out.println(result);
        } catch (IOException e) {
        }
    }
}

Explanation:

• This code reads the entire file content into a List of Strings using Files.readAllLines.
• The join method of the String class is then employed to concatenate all elements in the lines List.
• An empty string ("") is specified as the delimiter, effectively removing any line breaks present in the original content.
• The resulting String content represents the entire file content without line breaks.

6 Using BufferedReader and StringBuilder

Another straightforward approach is to read the file line by line using a BufferedReader, and then append each line to a StringBuilder without including the line breaks. Here’s how it can be done:

import java.io.IOException;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedReader;

public class RemoveLineBreaksBufferedReader {

     public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/javacodegeeks.txt"));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            reader.close();

            BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/output.txt"));
            writer.write(sb.toString());
            writer.close();

            System.out.println("Line breaks removed successfully.");
        } catch (IOException e) {
        }
    }
}

Explanation:

The main part of the code is enclosed within a try-catch block. This is done to handle any potential IOExceptions (input/output exceptions) that might occur during file operations. A BufferedReader named reader is created, which is used to read from the input file named "javacodegeeks.txt" located in the "src/main/resources" directory.

Inside a while loop, each line from the input file is read using the readLine() method of BufferedReader and appended to a StringBuilder named sb. This effectively removes line breaks from the file content because readLine() method does not include the line terminator.

After all lines have been read from the input file, the BufferedReader (reader) is closed using the close() method. A BufferedWriter named writer is created to write to the output file named "output.txt" located in the same directory. The content of the StringBuilder (sb), which now contains the entire file content without line breaks, is written to the output file using the write() method of BufferedWriter.

7. Conclusion

In Java, there are several approaches to remove line breaks from files. We can choose the method that best suits our requirements and coding preferences. Remember to handle exceptions appropriately and consider performance implications, especially for large files. With these techniques at our disposal, we can manipulate file contents according to our needs.

8. Download the Source Code

This was an article on how to Remove Line Breaks from a File in Java.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.