Java Text Blocks

Last updated: January 8, 2024

Written by: Martin van Wingerden

Reviewed by: Jonathan Cook

Java String

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

In a previous tutorial, we saw how we can use multi-line strings in any Java version.

In this tutorial, we’ll see in detail how to use the Java 15 text blocks feature to declare multi-line strings most efficiently.

2. Usage

Since Java 15, text blocks are available as a standard feature. With Java 13 and 14, we needed to enable it as a preview feature.

Text blocks start with a “”” (three double-quote marks) followed by optional whitespaces and a newline. The most simple example looks like this:

String example = """
     Example text""";

Note that the result type of a text block is still a String. Text blocks just provide us with another way to write String literals in our source code.

Inside the text blocks, we can freely use newlines and quotes without the need for escaping line breaks. It allows us to include literal fragments of HTML, JSON, SQL, or whatever we need, in a more elegant and readable way.

In the resulting String, the (base) indentation and the first newline are not included. We’ll take a look at the handing of indentation in the next section.

3. Indentation

Luckily, when using text blocks, we can still indent our code properly. To achieve that, part of the indentation is treated as the source code while another part of the indentation is seen as a part of the text block. To make this work, the compiler checks for the minimum indentation in all non-empty lines. Next, the compiler shifts the complete text block to the left.

Consider a text block containing some HTML:

public String getBlockOfHtml() {
    return """
            <html>

                <body>
                    <span>example text</span>
                </body>
            </html>""";
}

In this case, the minimum indentation is 12 spaces. Thus, all 12 spaces to the left of <html> and on all subsequent lines are removed. Let’s test this:

@Test
void givenAnOldStyleMultilineString_whenComparing_thenEqualsTextBlock() {
    String expected = "<html>\n"
      + "\n" 
      + "    <body>\n"
      + "        <span>example text</span>\n"
      + "    </body>\n"
      + "</html>";
    assertThat(subject.getBlockOfHtml()).isEqualTo(expected);
}

@Test
void givenAnOldStyleString_whenComparing_thenEqualsTextBlock() {
    String expected = "<html>\n\n    <body>\n        <span>example text</span>\n    </body>\n</html>";
    assertThat(subject.getBlockOfHtml())
       .isEqualTo(expected);
}

When we need explicit indentation, we can use less indentation for a non-empty line (or the last line):

public String getNonStandardIndent() {
    return """
                Indent
            """;
}

@Test
void givenAnIndentedString_thenMatchesIndentedOldStyle() {
    assertThat(subject.getNonStandardIndent())
            .isEqualTo("    Indent\n");
}

Moreover, we can also use escaping inside text blocks, as we’ll see in the next section.

4. Escaping

4.1. Escaping Double-Quotes

Inside text blocks, double-quotes don’t have to be escaped. We could even use three double-quotes again in our text block by escaping one of them:

public String getTextWithEscapes() {
    return """
            "fun" with
            whitespace
            and other escapes \"""
            """;
}

This is the only case where double-quotes must be escaped. In the other cases, it’s considered a bad practice.

4.2. Escaping Line Terminators

In general, newlines don’t have to be escaped inside text blocks.

However, note that even if a source file has Windows line endings (\r\n), the text blocks will only be terminated with newlines (\n). If we need carriage returns (\r) to be present, we have to explicitly add them to the text block:

public String getTextWithCarriageReturns() {
return """
separated with\r
carriage returns""";
}

@Test
void givenATextWithCarriageReturns_thenItContainsBoth() {
assertThat(subject.getTextWithCarriageReturns())
.isEqualTo("separated with\r\ncarriage returns");
}

Sometimes, we might have long lines of text in our source code that we want to format in a readable way. Java 14 preview added a feature that allows us to do this. We can escape a newline so that it is ignored:

public String getIgnoredNewLines() {
    return """
            This is a long test which looks to \
            have a newline but actually does not""";
}

Actually this String literal will just equal a normal non-interrupted String:

@Test
void givenAStringWithEscapedNewLines_thenTheResultHasNoNewLines() {
    String expected = "This is a long test which looks to have a newline but actually does not";
    assertThat(subject.getIgnoredNewLines())
            .isEqualTo(expected);
}

4.3. Escaping Spaces

The compiler ignores all trailing spaces in text blocks. However, since Java 14 preview, we can escape a space using the new escape sequence \s. The compiler will also preserve any spaces in front of this escaped space.

Let’s take a closer look at the impact of an escaped space:

public String getEscapedSpaces() {
    return """
            line 1·······
            line 2·······\s
            """;
}

@Test
void givenAStringWithEscapesSpaces_thenTheResultHasLinesEndingWithSpaces() {
    String expected = "line 1\nline 2        \n";
    assertThat(subject.getEscapedSpaces())
            .isEqualTo(expected);
}

Note: the spaces in the example above are replaced with the ‘·’ symbol to make them visible.

The compiler will remove the spaces from the first line. However, the second line is terminated with an escaped space, and all the spaces are thus preserved.

5. Formatting

To aid with variable substitution, a new method was added that allows calling the String.format method directly on a String literal:

public String getFormattedText(String parameter) {
    return """
            Some parameter: %s
            """.formatted(parameter);
}

6. Conclusion

In this short tutorial, we looked at the Java Text Blocks feature. It may not be a game-changer, but it helps us to write better and more readable code, which is generally a good thing.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.