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 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.
As always, the full source code of the article is available over on GitHub.