How to Use Multiline Strings in Java

Java, traditionally known for its verbosity, has evolved significantly over its versions, introducing more concise ways to handle common programming patterns. One such improvement is in the handling of multiline strings. Before Java introduced more straightforward support for multiline strings, developers had to resort to various workarounds to represent them. This article explores the different ways to produce multiline strings in Java, from traditional concatenation techniques to the latest language features.

Using String Concatenation

Prior to Java 8, the most common way to create multiline strings was through string concatenation using the + operator or the StringBuilder class. While this method was straightforward, it was also verbose and error-prone.

Example Using + Operator

String multilineString = "This is the first line.\n" +
                         "This is the second line.\n" +
                         "This is the third line.";
System.out.println(multilineString);

Example Using StringBuilder

StringBuilder sb = new StringBuilder();
sb.append("This is the first line.\n");
sb.append("This is the second line.\n");
sb.append("This is the third line.");
String multilineString = sb.toString();
System.out.println(multilineString);

Both approaches achieve the same result, but they require manual insertion of newline characters (\n) and increase the risk of mistakes in longer strings.

Using String.join

Java 8 introduced the String.join() method, which provides a more readable way to concatenate multiple strings with a specified delimiter, including new lines.

String multilineString = String.join("\n",
    "This is the first line.",
    "This is the second line.",
    "This is the third line."
);
System.out.println(multilineString);

This method enhances readability and reduces the risk of omitting newline characters or delimiters.

Using Text Blocks (Java 13+)

Java 13 introduced a feature long-awaited by the community—text blocks. Text blocks allow for the easy creation of multiline strings without the need for manual concatenation or the insertion of newline characters. A text block is initiated and closed with three double quotes ("""), and any text within the delimiters is considered part of the string, including new lines and indentation.

String multilineString = """
    This is the first line.
    This is the second line.
    This is the third line.
    """;
System.out.println(multilineString);

Text blocks significantly improve the legibility of multiline strings, especially when dealing with JSON, SQL queries, or other text-based data formats within Java code.

Using StringWriter

import java.io.StringWriter;

public class StringWriterExample {
    public static void main(String[] args) {
        StringWriter stringWriter = new StringWriter();

        // Writing multiple lines to the StringWriter
        stringWriter.write("This is the first line.\n");
        stringWriter.write("This is the second line.\n");
        stringWriter.write("This is the third line.\n");

        // Convert StringWriter content to a String
        String report = stringWriter.toString();

        // Display the report
        System.out.println(report);
    }
}

Explanation

• A StringWriter object is created to collect the text.
• The write method of StringWriter is used to append text to the buffer. Newline characters (\n) are manually added to create the multiline effect.
• After all the lines are written, the toString() method of StringWriter is called to retrieve the collected content as a single String.
• Finally, the multiline string is printed to the console.

Using Guava’s Joiner

First, ensure Guava is included in your project. If you’re using Maven, add the following dependency to your pom.xml:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.0-jre</version> <!-- Use the latest version available -->
</dependency>

Guava Joiner Example for Multiline Strings

import com.google.common.base.Joiner;

public class GuavaJoinerExample {
    public static void main(String[] args) {
        // Define the strings to join
        String[] lines = {
            "This is the first line.",
            "This is the second line.",
            "This is the third line."
        };

        // Create a Joiner instance that uses newline as a separator
        Joiner joiner = Joiner.on("\n");

        // Join the lines
        String report = joiner.join(lines);

        // Display the report
        System.out.println(report);
    }
}

Explanation

• An array of strings lines is defined, holding the lines of text to be joined.
• A Joiner instance is created with \n (newline) as the delimiter. This Joiner is configured to concatenate the strings in the array, inserting a newline character between each.
• The join method of Joiner is called with the lines array as an argument. This method returns a single String containing all the array elements, separated by newline characters.
• Finally, the concatenated multiline string (report) is printed to the console.

Advantages of Using Guava’s Joiner

• Readability: The Joiner class offers a fluent and readable API for joining strings.
• Null Safety: Joiner can be configured to skip null values or replace them with a predefined text, avoiding NullPointerException.
• Reusability: A Joiner instance can be reused across different parts of the application, ensuring consistent string joining behavior.

Guava’s Joiner class provides a clean and flexible way to concatenate strings, making it especially useful for generating multiline strings or joining collections and arrays of strings with a specific separator. While StringWriter serves a broader purpose of writing characters to a string buffer, Joiner focuses on joining strings with precise control over separators and null handling, showcasing the utility of Guava’s rich collection of utilities for common Java tasks.

Considerations and Best Practices

• Readability: Choose the method that maximizes readability and maintainability for your specific use case. Text blocks are generally the most readable option for multiline strings.
• Performance: For simple concatenations, + is sufficient and readable. For more complex scenarios, especially in loops, consider using StringBuilder or String.join.
• Compatibility: Text blocks require Java 13 or higher. If you’re working on projects that need to be compatible with older Java versions, you’ll need to use the traditional methods.
• Indentation in Text Blocks: Be mindful of the indentation in text blocks, as it is preserved in the resulting string. Use the .stripIndent() method to remove incidental white space if necessary.

Conclusion

The evolution of Java has brought more elegant solutions for handling multiline strings, reducing the verbosity and complexity traditionally associated with the language. While string concatenation and the String.join method provide backward-compatible options, text blocks offer a modern, readable approach for defining multiline strings in Java 13 and beyond. By understanding and applying these different techniques appropriately, Java developers can write cleaner, more maintainable code involving multiline strings.

• Author
• Recent Posts

Follow me

Anastasios Antoniadis

Anastasios Antoniadis is the founder and editor-in-chief of BORDERPOLAR... He is a software engineer, blogger, and avid gamer covering tech, gaming, and coding guides for over 4 years. He is a 2014 graduate of the Department of Informatics and Telecommunications of the University of Athens, an M.Sc. holder in Computer Science, and a Ph.D. student in Program Analysis.

Follow me

Latest posts by Anastasios Antoniadis (see all)

• Car Dealership Tycoon Codes: Free Cash for March 2024 - April 9, 2024
• World Solver - April 9, 2024
• Roblox Game Trello Board Links & Social Links (Discord, YT, Twitter (X)) - April 9, 2024