JAVA15 文本块

发表于 更新于 分类于 ， 阅读次数： 本文字数： 974 阅读时长 ≈ 3 分钟

背景

摘要

文本块是一种多行字符串字面形式，可避免使用大多数转义序列，以可预测的方式自动格式化字符串，并在需要时让开发人员控制格式。

历史

  1. JEP 355 第一次预览(JDK 13) 提出
  2. JEP 368 第二次预览(JDK 14), 两个新的转义序列
  3. JEP 378 正式发布(JDK 15)

不足

  1. 不直接支持字符串插值( interpolation ), 见 String::formatted
  2. 不支持原始字符串

详细

结构定义

来源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
TextBlock:
""" {TextBlockWhiteSpace} LineTerminator {TextBlockCharacter} """

TextBlockWhiteSpace:
WhiteSpace but not LineTerminator

TextBlockCharacter:
InputCharacter but not \
EscapeSequence
LineTerminator

WhiteSpace:
the ASCII SP character, also known as "space"
the ASCII HT character, also known as "horizontal tab"
the ASCII FF character, also known as "form feed"

LineTerminator:
the ASCII LF character, also known as "newline"
the ASCII CR character, also known as "return"
the ASCII CR character followed by the ASCII LF character

InputCharacter:
UnicodeInputCharacter but not CR or LF

UnicodeInputCharacter:
UnicodeEscape
RawInputCharacter

UnicodeEscape:
\UnicodeMarker HexDigit HexDigit HexDigit HexDigit

UnicodeMarker:
u {u}

RawInputCharacter:
any Unicode character

EscapeSequence:
\b (backspace BS, Unicode \u0008)
\s (space SP, Unicode \u0020)
\t (horizontal tab HT, Unicode \u0009)
\n (linefeed LF, Unicode \u000a)
\f (form feed FF, Unicode \u000c)
\r (carriage return CR, Unicode \u000d)
\LineTerminator (line continuation, no Unicode representation)
\" (double quote ", Unicode \u0022)
\' (single quote ', Unicode \u0027)
\\ (backslash \, Unicode \u005c)
OctalEscape (octal value, Unicode \u0000 to \u00ff)

OctalEscape:
\OctalDigit
\OctalDigit OctalDigit
\ZeroToThree OctalDigit OctalDigit

OctalDigit:
(one of)
0 1 2 3 4 5 6 7

ZeroToThree:
(one of)
0 1 2 3

测试用例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package com.pancc.up.jdks;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * @author Siweipancc on 2023/12/15
 */
public class BlocksTextTest {

    @Test
    @DisplayName("替换常规拼接")
    void t1() {
        String html1 = "<html>\n" +
                       "    <body>\n" +
                       "        <p>Hello, world</p>\n" +
                       "    </body>\n" +
                       "</html>\n";
        String html2 = """
                <html>
                    <body>
                        <p>Hello, world</p>
                    </body>
                </html>
                """;
        assertEquals(html1, html2);
    }

    @Test
    @DisplayName("最后产生换行字符")
    void t2() {
        String s1 = """
                line 1
                line 2
                line 3
                """;
        String s2 = "line 1\nline 2\nline 3\n";
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("最后不产生换行字符")
    void t22() {
        String s1 = """
                line 1
                line 2
                line 3""";
        String s2 = "line 1\nline 2\nline 3";
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("\\ 换行输入但不产生换行字符")
    void t3() {
        String s1 = """
                line 1
                line 2
                line 3\
                """;
        String s2 = "line 1\nline 2\nline 3";
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("空白字符串")
    void t4() {
        String s1 = "";
        String s2 = """
                """;
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("\\ 拼接长串")
    void t5() {
        String s1 = "文本块是一种多行字符串字面形式，可避免使用大多数转义序列，以可预测的方式自动格式化字符串，并在需要时让开发人员控制格式。";
        String s2 = """
                文本块是一种多行字符串\
                字面形式，可避免使用大多数\
                转义序列，以可预测的方式自\
                动格式化字符串，并在需要时\
                让开发人员控制格式。""";
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("特殊缩进1")
    void t61() {
        String s1 = "文本\n块是\n  一种\n  多行\n 字符串";
        String s2 = """
                文本
                块是
                  一种
                  多行
                 字符串""";
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("特殊缩进2")
    void t62() {
        String s1 = "文本\n块是\n  一种\n  多行\n 字符串\n";
        String s2 = """
                文本
                块是
                  一种
                  多行
                 字符串
                   """;
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("特殊缩进3")
    void t63() {
        String s1 = "文本\n块是\n  一种\n  多行\n 字符串\n";
        String s2 = """
                文本
                块是
                  一种
                  多行
                 字符串
                 """;
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("特殊缩进4")
    void t64() {
        String s1 = "文本\n块是\n  一种\n  多行\n 字符串\n";
        String s2 = """
                文本
                块是
                  一种
                  多行
                 字符串
                """;
        assertEquals(s1, s2);
    }

    @Test
    @DisplayName("特殊缩进5")
    void t65() {
        String s1 = "                文本\n                块是\n                  一种\n                  多行\n                 字符串\n";
        String s2 = """
                                文本
                                块是
                                  一种
                                  多行
                                 字符串
                """;
        assertEquals(s1, s2);
    }
}


编译器处理步骤

  1. 行结束符被翻译为 LF (\u000A)
  2. 最大努力的删除左右缩进使用的空白字符
  3. 对内容中的 Escape 序列进行解释, 如: \s

补充

编辑器换行符使用 LF

  1. IntelliJ IDEA: Settings -> Editor -> Code Style ==> Line separator(Unix and MacOS(\n))
  2. Notepad++: 设置 -> 首选项 -> 新建 ==> 格式(行尾) (Unix(LF))

一些实用的方法

  1. String::stripIndent()：用于从文本块内容中剥离附带的空白空间
  2. String::translateEscapes()：用于翻译转义序列
  3. String::formatted(Object… args)：简化文本块中的值替换