Java Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE

1. Introduction

In a previous tutorial, we saw how we can use multi-line strings in any Java version and without enabling preview features.

In this tutorial, we'll see how to use the JDK 13/14 preview feature of text blocks.

2. Usage

Since Java 13, text blocks are available as a preview feature. Text blocks start with a “”” (three double-quote marks) followed by optional whitespace and a newline. The most simple example could look like:

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. 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

Inside text blocks, double-quotes and newlines do not have to be escaped. However, we can use escaping to add, for example, carriage returns (\r) or tabs (\t) to a text block. We could even use “”” again in our text block by escaping one of the double-quotes:

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

Be aware that because single double-quotes and newlines do not have to be escaped, it is considered bad practice to escape them.

Also, 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");
}

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);
}

All these features already provide a very powerful feature. However, Java 14 has included some additional features. We'll see more about that next.

6. New Escape Sequences in Java 14

The second preview of the Text Blocks feature adds two additional escape sequences.

6.1. Escaping Line Terminators

Sometimes, we might have long lines of text in our source code that we want to format in a readable way. The second 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);
}

6.2. Escaping Spaces

The compiler ignores all trailing spaces in text blocks. However, since the second 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.

7. 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.

As always, the full source code of the article is available over on GitHub.

Java bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE
Comments are closed on this article!