Java String（二）：字符串操作编译期优化剖析

大家好，我是欧阳方超，公众号同名。

1 概述

在Java编程中，字符串操作是极为常见的，为了提升性能，Java编译器会在编译阶段对字符串进行优化，本文将探讨字符串在编译器优化的相关内容。

2 编译器优化的条件

下面几种情况的字符串操作会在编译器进行优化：字符串字面量直接拼接、使用final修饰的字符串变量拼接、所有参与拼接的部分都必须在编译器可确定。

2.1 字符串字面量直接拼接

当代码中存在字符串字面量直接拼接的情况，例如"hel" + “lo”，编译器会在编译阶段就完成拼接操作。

public class StringLiteralConcatenation {
    public static void main(String[] args) {
        String str = "hel" + "lo";
        System.out.println(str);
    }
}

上述代码，编译器会在编译时直接将 "hel"和"lo"拼接成hello，并放入常量池，而不是在运行时进行拼接。

2.2 使用final修饰的字符串变量拼接

若使用final修饰的字符串变量进行拼接，编译器同样会在编译阶段完成拼接。这是因为final变量的值在编译期就已经确定。

public class FinalStringConcatenation {
    public static void main(String[] args) {
        final String part1 = "hel";
        final String part2 = "lo";
        String str = part1 + part2;
        System.out.println(str);
    }
}

这里，part1和part2都被final修饰，编译器会在编译时将它们拼接成"hello"。

2.3 所有参与拼接的部分都必须在编译期可确定

只有当所有参与拼接的部分在编译期就能确定其值时，编译器才会进行优化。如：

public class CompileTimeDeterminable {
    public static final String CONSTANT1 = "hel";
    public static final String CONSTANT2 = "lo";
    public static void main(String[] args) {
        String str = CONSTANT1 + CONSTANT2;
        System.out.println(str);
    }
}

由于CONSTANT1和CONSTANT2是public static final常量，它们的值在编译期就已经确定，所以编译器会对其进行优化。

3 编译期优化原理

3.1 编译器计算最终字符串值

编译器在编译阶段会对满足优化条件的字符串进行拼接操作，得出最终的字符串值，如，对于 “hel” + “lo”，编译器会直接计算出结果为 “hello”。

3.2 优化后的代码直接适应计算好的字符串

编译后的代码会直接使用计算好的字符串，而不再进行运行时的拼接操作。这就减少了运行时的开销，提高了程序的性能。

3.3 优化后的字符串会直接进入常量池

经过编译期优化得到的字符串会直接进入字符串常量池。当后续代码中再次使用相同的字符串时，会直接从常量池中获取，避免了重复创建对象，节省了内存。

4 不会进行编译期优化的情况

当然不是所有的字符串拼接操作都会在编译期进行优化，下面就是一些不会优化的情况。

4.1 包含变量的字符串拼接

如果字符串拼接中包含变量，编译器无法再编译期确定变量的值，因此不会进行优化。

public class VariableConcatenation {
    public static void main(String[] args) {
        String part1 = "hel";
        String part2 = "lo";
        String str = part1 + part2;
        System.out.println(str);
    }
}

在这个例子中，part1和part2是变量，编译器无法再编译期确定它们的值，所有会在运行时进行拼接。
上面例子中，变量拼接的实际过程是这样的，编译后等同于：

String str = new StringBuilder()
.append(part1)
.append(part2)
.toString();

4.2 调用字符串的方法

当调用字符串的方法（如contact）进行拼接时，编译器也不会进行优化。

public class MethodCallConcatenation {
    public static void main(String[] args) {
        String str = "hel".concat("lo");
        System.out.println(str);
    }
}

这里使用了contact方法进行拼接，编译器会在运行时调用该方法进行拼接操作。

4.3 运行期才能确定的值

如果拼接的部分包含在运行期才能确定的值，编译器同样无法进行优化。

import java.util.Scanner;

public class RuntimeDeterminedValue {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个字符串: ");
        String input = scanner.nextLine();
        String str = "hel" + input;
        System.out.println(str);
    }
}

input的值需要在运行时从用户输入中获取，编译器无法在编译期确定其值，所有不会进行优化。

5 性能影响

编译器优化的好处：
减少运行时的对象创建；
直接使用常量池中的对象；
提高程序性能。
运行时拼接的劣势：
需要创建StringBuilder对象；
需要创建新的String对象；
增加了内存开销。

6 最佳实践

对于能确定值的字符串拼接，使用字面量；
对于大量的字符串拼接，显式使用StringBuilder；
如果确定字符串在编译器不会改变，可以使用final修饰；
避免在循环中使用字符串拼接。
下面是不推荐的做法：

String result = "";
        for (int i = 0; i < 100000; i++) {
            result += "hello";  // 每次循环都会创建新的String对象
        }

因为result += “hello”;最终会按下面的代码执行：

result = new StringBuilder()
.append(result)
.append("hello")
.toString();

每次循环都会执行下面的过程：
创建新的StringBuilder对象；
将原字符串内容复制到StringBuilder；
追加新的hello；
调用toString()创建新的String对象；
丢弃就的String对象，等待GC回收。
基于此，推荐的做法是

tringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) {
    sb.append("hello");  // 只需要一个StringBuilder对象
}
String result = sb.toString();  // 最后只创建一次String对象

优势在于，只创建一个StringBuilder对象，只在最后创建一次String对象，没有中间对象产生，大大减少了内存分配和GC压力。

7 总结

了解 Java 字符串编译期优化的条件、原理以及不进行优化的情况，有助于我们编写更高效的代码，提升程序的性能和内存使用效率。在实际开发中，我们应尽量利用编译期优化的特性，避免不必要的运行时开销。
我是欧阳方超，把事情做好了自然就有兴趣了，如果你喜欢我的文章，欢迎点赞、转发、评论加关注。我们下次见。