Text Blocks in Java (Multi-line Strings) – Explained with Examples

Working with multi-line strings has traditionally been cumbersome in Java.
Before Java 13, if you wanted to define a string that spanned multiple lines, you had to manually add newline characters (\n) and concatenate strings, which made the code messy and hard to read.

Thankfully, Java introduced a feature called Text Blocks to solve this problem.
Text Blocks make working with multi-line strings much easier, cleaner, and more readable.

In this blog post, we'll cover:

What are Text Blocks?
Why use Text Blocks?
Syntax of Text Blocks
Examples and Use Cases
Common Mistakes
Best Practices
Frequently Asked Questions (FAQ)

Let's dive in!

What are Text Blocks in Java?

Text Blocks are a new way to declare multi-line string literals introduced in Java 13 (as a preview feature) and became a standard feature in Java 15.

In simple words, a Text Block is a multi-line string literal that:

Eliminates the need for most escape sequences
Automatically formats the string
Improves the readability of the code

A Text Block is enclosed within three double-quote marks (""").

Why Use Text Blocks?

Here are some key benefits of using Text Blocks:

Improved Readability: No more ugly concatenation or manual newline (\n) characters.
Easier Maintenance: Strings look exactly like their intended format.
Fewer Escape Sequences: No need to escape double quotes inside the text block.
Consistent Formatting: Java automatically adjusts indentation.

In short, Text Blocks make your Java code cleaner, simpler, and easier to understand.

Syntax of Text Blocks

Here’s the basic syntax:

String textBlock = """
    This is a text block.
    It can span multiple lines,
    and maintains the formatting!
    """;

Start with three double quotes """
Optional line break after the opening quotes
Indentation is automatically managed
End with three double quotes """

Important: The closing """ must appear on a new line.

Examples and Use Cases

Let’s explore how Text Blocks can be used in real-world Java code.

1. HTML Content Example

Before Text Blocks:

String html = "<html>\n" +
              "    <body>\n" +
              "        <h1>Hello, World!</h1>\n" +
              "    </body>\n" +
              "</html>";

After Text Blocks:

String html = """
    <html>
        <body>
            <h1>Hello, World!</h1>
        </body>
    </html>
    """;

Much cleaner, right?

2. SQL Queries Example

Before Text Blocks:

String sql = "SELECT id, name\n" +
             "FROM users\n" +
             "WHERE active = 1\n" +
             "ORDER BY name;";

After Text Blocks:

String sql = """
    SELECT id, name
    FROM users
    WHERE active = 1
    ORDER BY name;
    """;

Using Text Blocks makes SQL queries in Java code look like actual SQL.

3. JSON Strings Example

String json = """
    {
        "name": "John Doe",
        "age": 30,
        "city": "New York"
    }
    """;

No more awkward escaping for quotes (\") inside the JSON!

Common Mistakes

Here are some things you need to watch out for:

Missing New Line after Opening Quotes: It's recommended (but not mandatory) to have a line break right after opening """.
Misplaced Closing Quotes: Always place closing quotes on a new line.
Whitespace Sensitivity: Be mindful of indentation — Java calculates based on the minimum indent across all non-blank lines.

Example of an invalid Text Block:

String invalid = """This won't work""";  // Incorrect! Must have line breaks

Best Practices for Using Text Blocks

To get the most out of Text Blocks, follow these tips:

Always format your text as you want it to appear.
Maintain consistent indentation inside the text block.
Use Text Blocks for large text data, like HTML, SQL, XML, JSON, etc.
Still validate your content — Text Blocks help with formatting but won't fix logic or syntax errors inside the string.

Frequently Asked Questions (FAQ)

Q1: Are Text Blocks available in Java 8 or 11?
No. Text Blocks were introduced as a preview in Java 13 and finalized in Java 15.

Q2: Can I use escape sequences in Text Blocks?
Yes. You can still use escape sequences like \n, \t, etc., if needed.

Q3: What happens to the leading spaces in a Text Block?
Java automatically removes common leading white spaces across all lines to keep the formatting neat.

Q4: Can Text Blocks be concatenated like normal strings?
Yes. You can concatenate Text Blocks with other strings using the + operator.

Example:

String fullMessage = """
    Hello,
    Welcome to the Java World!
    """ + "\nLet's start learning.";

Conclusion

Text Blocks are a game-changer for Java developers when working with multi-line strings.
They make your code cleaner, more readable, and easier to maintain.

If you haven't started using them yet, now's the perfect time to upgrade your Java skills and take advantage of this powerful feature!

Happy Coding! 🚀

🔔 Pro Tip:
If you’re using an IDE like IntelliJ IDEA or Eclipse, they already have built-in support for Java Text Blocks with proper formatting and syntax highlighting.