# 前言 {#前言}

要想看官方对于JDK21的更新说明，可以直接跳转到下面这个官方网站中

官网地址为：https://openjdk.org/projects/jdk/21/ (opens new window)

JDK21是最新的LTS版本，里面添加了不少新的特性，本文将介绍JEP430--字符串模板

# 新特性产生的动机 {#新特性产生的动机}

这是一个预览功能，使用字符串模板可以更加方便地进行字符串的拼接。 由于是预览功能，在编译和执行时需要增加对应的参数：

javac --enable-preview --release 21 Test.java
java --enable-preview Test

1
2

在之前的JDK中，如果想要实现字符串的拼接，主要有下面几种方式。

第一种使用+号进行字符串的拼接，问题在于这种方式难以阅读，就像下面这样

String s = x + " plus " + y + " equals " + (x + y);

1

第二种是使用工具类StringBuffer或者是StringBuilder，但是会显得代码很冗长。

String s = new StringBuilder()
                 .append(x)
                 .append(" plus ")
                 .append(y)
                 .append(" equals ")
                 .append(x + y)
                 .toString();

1
2
3
4
5
6
7

或者使用String的format方法，但这种方式会将字符串和参数分开，对于阅读和写代码都不够友好

String s = String.format("%2$d plus %1$d equals %3$d", x, y, x + y);
String t = "%2$d plus %1$d equals %3$d".formatted(x, y, x + y);

1
2

在很多语言中，都支持了字符串插值来代替加号连接的方式，比如下面这些语言：

终于JDK在21这个版本推出了字符串模板的功能，有多种字符串模板，下面会一个个介绍。

# STR模板 {#str模板}

STR是Java平台中定义的模板处理器，可以像下面这样去使用STR模板：

public class TestString {
    public static void main(String[] args) {
        String firstName = "Bill";
        String lastName  = "Duck";
        String fullName  = STR."\{firstName} \{lastName}";
        System.out.println(fullName);
        // 结果为：Bill Duck
    }
}

1
2
3
4
5
6
7
8
9

在上面的代码中，STR.是字符串模板的前缀修饰符，{}为具体的表达式，比如上面的代码中就从上下文中获取到了对应的变量。 除了简单的变量替换之外，表达式中可以编写对应的逻辑执行代码，比如下面这样进行相加

public class TestString {
    public static void main(String[] args) {
        int x = 10, y = 20;
        String s = STR."\{x} + \{y} = \{x + y}";
        System.out.println(s);
        // 结果为：10 + 20 = 30
    }
}

1
2
3
4
5
6
7
8

甚至可以在表达式中编写一些代码

public class TestString {
    public static void main(String[] args) {
        String time = STR."The time is \{
        DateTimeFormatter
                .ofPattern("HH:mm:ss")
                .format(LocalTime.now())
        } right now";
        System.out.println(time);
        // 结果为 The time is 23:18:16 right now
    }
}

1
2
3
4
5
6
7
8
9
10
11

# 多行模板表达式 {#多行模板表达式}

上面这些代码主要介绍的还是单行的STR模板，如果是对像Json或者Html等字符串进行拼接时，就可以采用多行模板表达式，比如下面这行代码：

public class TestString {
    public static void main(String[] args) {
        String name    = "Joan Smith";
        String phone   = "555-123-4567";
        String address = "1 Maple Drive, Anytown";
        String json = STR."""
        {
            "name":    "\{name}",
            "phone":   "\{phone}",
            "address": "\{address}"
        }
        """;
        System.out.println(json);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

得到的结果为：

{
    "name":    "Joan Smith",
    "phone":   "555-123-4567",
    "address": "1 Maple Drive, Anytown"
}

1
2
3
4
5

# FMT处理器 {#fmt处理器}

FMT处理器是JDK21中定义的另外一个模板处理器，在语法上和STR类似，只是多了一个格式说明符，这个格式的使用和String的format方法类似。 在下面的例子中，通过结果就能看出格式化和未格式化的区别，%-12s表示占用12个字符且左对齐。

public class TestString {
    public static void main(String[] args) {
        String name = "神秘的鱼仔";
        String message1 = STR."STR \{name}STR";
        String message2 = FMT."FMT %-12s\{name}FMT";
        System.out.println(message1);
        // STR 神秘的鱼仔STR
        System.out.println(message2);
        // FMT 神秘的鱼仔       FMT
    }
}

1
2
3
4
5
6
7
8
9
10
11

# RAW模式 {#raw模式}

RAW模式会生成一个StringTemplate对象，就好比StringBuilder和StringBuffer一样，想要获得最终的String对象还需要手动转一层，就像下面这样：

public class TestString {
    public static void main(String[] args) {
        String name = "Joan";
        StringTemplate st = RAW."My name is \{name}";
        String info = STR.process(st);
        System.out.println(info);
        // 输出：My name is Joan
    }
}

1
2
3
4
5
6
7
8
9

# 自定义模板处理器 {#自定义模板处理器}

前面介绍的这几种模板处理器都是JDK21中自带的，同时也提供了一个接口使得我们可以自己去实现一个字符串处理器，只需要继承StringTemplate.Processor，然后实现process方法即可。

比如我现在想要自定义一个字符串的模板处理器，效果是将传入的变量中的空格都去除，就可以按照下面这种写法

public class Test implements StringTemplate.Processor<String,RuntimeException>{
    public static final Test TEST = new Test();
    @Override
    public String process(StringTemplate stringTemplate) throws RuntimeException {
        StringBuilder builder = new StringBuilder();
        List<String> fragments = stringTemplate.fragments();
        List<Object> values = stringTemplate.values();
        for (int i = 0; i < fragments.size()-1; i++) {
            String fragment = fragments.get(i);
            String value = (String) values.get(i);
            String newValue = value.replaceAll("\\s", "");
            builder.append(fragment).append(newValue);
        }
        builder.append(fragments.get(fragments.size()-1));
        return builder.toString();
    }

    public static void main(String[] args) {
        String test = "te st";
        System.out.println(TEST."测试一下\{test},测试一下\{test}");

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

上面的这段代码最终输出如下，去除了字符串中的空格。

测试一下test,测试一下test

1

自定义字符串模板很简单，需要关注的是fragments和values两个对象，在上面的例子中，这两个对象里的内容如下：

StringTemplate{ fragments = [ "测试一下", ",测试一下", "" ], values = [test, test] }

1

# 总结 {#总结}

字符串模板功能主要还是为了弥补Java在字符串拼接上的弱点，在设计上也是借鉴了大量的语言，总体来说还是变得更好用了。