String
String 表示不可变的字符序列:对象创建后,其中的文本内容就不能修改。它的其他特性大多从这一点出发:字符串可以放心共享,常量池可以复用同一个对象,拼接时则要考虑是否改用 StringBuilder。另外,length() 数的是 UTF-16 代码单元,不一定等于用户看到的字符数。
1. 面试核心
先记住这几条,再读正文String的字符序列不会改变,因此可以在线程间安全共享,也适合作为HashMap的键。- 内容相同的字符串字面量和字符串常量表达式,会共享常量池中的同一个对象。卡 · 字符串常量池
intern()返回常量池中内容相同的规范字符串引用。业务代码需要比较内容时,仍应使用equals。StringBuilder适合在单线程中逐步构建文本。StringBuffer的主要公开操作提供同步保证,但这个保证只覆盖单次调用。卡 · String 的不可变性String.length()返回 UTF-16 代码单元数。一个 Unicode 码点可能占两个代码单元,因此返回的长度不一定等于码点数,也不一定等于读者看到的字符数。卡 · 字符串存储与字符计数
2. String 的不可变性
调用 String 的方法不会改变原对象。如果结果的内容不同,方法会返回另一个字符串;如果内容没变,也可以复用原对象:
String original = "Coding";
String result = original.concat(" 101");
System.out.println(original); // Coding
System.out.println(result); // Coding 101
调用 concat 后,original 仍然指向内容为 "Coding" 的对象,result 才指向内容为 "Coding 101" 的字符串。如果不接收 concat 的返回值,拼接结果就会被丢弃。
s = s + "!" 看起来像是改了字符串,其实也没有:它先拼出一个新字符串,再让变量 s 指向它,原来的对象没有变化。不可变说的是对象的内容,变量换不换指向是另一回事,参见 Java 值传递。
String 通过几方面的设计保证内容不变:
String类不能被继承,子类无法改变它的语义。- 内部字符表示不向调用方直接暴露。
- 公开 API 不提供修改已有字符序列的方法。
- 构造方法会保护内部表示,不让外部可变数组反向修改字符串。
这些保证不依赖某一种内部存储。JDK 可以调整实现,例如内部不必始终使用 char[]。调用方可以依赖的是:字符串创建后,它的值不会改变。
2.1 不可变性的作用
多个对象或线程可以安全共享同一个字符串,因为任何一方都无法修改它的内容。String 也适合作为 HashMap 的键:参与 equals 和 hashCode 计算的字符序列不会变化,查找时使用的依据也就保持稳定。
代价是每次得到新内容,都要创建一个新字符串。偶尔拼接一次问题不大,在循环里反复拼接时就要注意,见字符串拼接的选择。
3. 字符串常量池
字符串常量池是 JVM 维护的一张表,记录可以共享的字符串对象。内容相同的字符串字面量只在池里保留一个对象,所有引用都共用它,这叫驻留(interning),池里这个被共用的对象叫规范字符串对象。这种共享之所以安全,正是因为字符串不可变:谁都改不了它,共用一个对象就不会互相影响。
String first = "Java";
String second = "Java";
String created = new String("Java");
System.out.println(first == second); // true
System.out.println(first.equals(second)); // true
System.out.println(first == created); // false
System.out.println(first.equals(created)); // true
first 和 second 都来自字面量 "Java",所以指向同一个对象,first == second 返回 true。new String("Java") 明确创建了新对象,因此 first == created 返回 false。
三个字符串的内容相同,所以两次 equals 都返回 true。业务需要判断文本内容是否相同时,应使用 equals。
由此也能回答「new String("Java") 创建了几个对象」:new 一定会创建一个新的 String 对象;如果字面量 "Java" 还没有驻留,还要先创建池里的那个对象。所以答案是一个或两个,取决于执行前池里有没有 "Java"。
3.1 编译期常量折叠
常量折叠是指编译器在编译时直接算出常量表达式的结果,并把结果写进 class 文件。两个字面量的拼接就属于这种情况,结果直接使用常量池里的驻留对象;拼接里只要有一个非恒定变量,就得等到运行时再算。
String folded = "Coding" + " 101";
String literal = "Coding 101";
String prefix = "Coding";
String runtime = prefix + " 101";
System.out.println(folded == literal); // true
System.out.println(runtime == literal); // false
System.out.println(runtime.equals(literal)); // true
folded 的两个操作数都是字面量,编译时就能得到 "Coding 101",因此它与 literal 共享对象。prefix 是非恒定变量,runtime 要在运行时得到拼接结果,所以它与 literal 指向不同的对象。
两种拼接得到的文本都是 "Coding 101"。判断内容是否相同时,仍应使用 equals,不能依赖对象是否驻留。
如果把 prefix 的声明改成 final String prefix = "Coding",它就成了由常量表达式初始化的常量变量。此时 prefix + " 101" 也会在编译期折叠,runtime == literal 返回 true。这里需要同时满足两个条件:声明为 final,并且由常量表达式初始化。如果初始值来自方法调用,即使加了 final,prefix 也不是常量变量。
3.2 intern()
运行时创建的字符串可以调用 intern(),取得常量池中对应的规范引用。如果池中已有相同内容的对象,就返回它;否则把当前字符串加入池,再返回当前对象:
String created = new String("Java");
String canonical = created.intern();
System.out.println(canonical == "Java"); // true
这里的字面量 "Java" 已经有对应的驻留对象,因此 canonical 指向这个对象,canonical == "Java" 返回 true。
如果大量字符串内容重复,比如从数据里读出的城市名,可以先测量,看驻留能不能省内存。但对所有外部输入都调用 intern(),会增加常量池的查找和维护开销;应用长期持有返回的引用,还会让这些对象活得更久。普通业务用 equals 比较内容就够了,不需要主动驻留字符串。
4. StringBuilder 与 StringBuffer
StringBuilder 和 StringBuffer 保存的字符序列可以修改。调用 append 等方法时,改的是当前对象,返回的也是它自己:
StringBuilder builder = new StringBuilder();
builder.append("Coding");
builder.append(' ');
builder.append(101);
String result = builder.toString();
三次 append 都在修改 builder,最后调用 toString() 得到字符串 "Coding 101"。选择这几种类型时,主要看内容是否需要修改,以及是否需要同步:
| 类型 | 内容是否可变 | 同步策略 | 常见用途 |
|---|---|---|---|
String | 否 | 不需要为内容变化加锁 | 保存和传递最终文本 |
StringBuilder | 是 | 不提供同步保证 | 方法内部或单线程构建文本 |
StringBuffer | 是 | 主要公开操作带同步 | 多线程共享同一个可变缓冲区 |
如果构建器只在当前方法内使用,可以选择 StringBuilder。
StringBuffer 的主要公开方法使用 synchronized,保护的是单次方法调用。例如,先检查长度再追加内容,需要调用两次方法,其他线程可以在两次调用之间修改内容。如果要求这两步作为一个整体执行,就需要在外层同步。也可以让每个线程分别构建结果,避免共享同一个缓冲区。
5. 字符串拼接的选择
拼接字符串时,单个表达式直接用 +,在循环里逐步拼接则用 StringBuilder。一次性拼接少量文本时,+ 最直观:
String message = "order " + orderId + " created";
Java 规范没有规定 + 必须怎样实现,编译器可以把整个表达式作为一个整体来优化,编译结果不一定用 StringBuilder。Java 17、21 的 javac 在默认编译目标下用 invokedynamic 编译字符串拼接,具体的拼接方式由 JVM 在运行时决定。所以写代码时只依赖拼接出来的文本,不要依赖某种固定的实现。
这些优化针对的是单个表达式。在循环里执行 result = result + item,每一轮都会生成一个新字符串,并把前面累积的文本再复制一遍。逐步构建较长的文本时,可以复用一个 StringBuilder:
StringBuilder result = new StringBuilder();
for (String item : items) {
if (!result.isEmpty()) {
result.append(',');
}
result.append(item);
}
return result.toString();
循环把 items 中的元素逐个追加到 result,用逗号分隔,最后才调用一次 toString() 取得完整字符串。使用固定分隔符连接元素时,也可以用 String.join 或 Collectors.joining,直接表达这个操作。
如果这段代码位于热点路径,再通过基准测试比较不同的容量预估和构建方式。预估容量可以减少缓冲区扩容,但能带来多少收益,还取决于文本长度和调用频率。
6. 字符串存储与字符计数
字符串内部怎样存储,与 length() 怎样计数,是两个不同的问题。OpenJDK 17、21 的 String 实现通过 byte[] 和编码标记保存文本。默认启用 Compact Strings 时,如果全部内容都能用 Latin-1 表示,就采用每个代码单元一个字节的表示;否则,整个字符串使用 UTF-16 表示。关闭这项优化时也会使用 UTF-16,不能把默认存储策略当成 Java 语言或 Android 类库的统一保证。
公开 API 仍然按 UTF-16 代码单元索引,也就是按 16 位的编码单位定位文本。Unicode 码点是字符的编号,一个码点可以占一个或两个 UTF-16 代码单元。例如,下面这个表情就占两个代码单元:
String face = "😀";
System.out.println(face.length()); // 2
System.out.println(face.codePointCount(0, face.length())); // 1
face 中的表情由一对代理项表示,也就是两个 UTF-16 代码单元共同表示一个码点。因此,face.length() 返回 2,face.codePointCount(0, face.length()) 返回 1。需要遍历码点时,可以使用 codePoints(),避免把这对代理项拆开。
此外还要考虑字素簇。字素簇是用户眼中的一个字符,它可能由多个码点组合而成,比如带肤色的表情。所以截断文本之前,要先想清楚按什么计数:代码单元、码点,还是字素簇。
7. 常见问题
7.1 String 被 final 修饰就一定不可变吗?
仅有 final 不够。它只阻止类被继承,不保证内部状态不能修改。String 还通过保护内部表示、让公开操作保持原内容不变,来保证不可变性。
7.2 final String 与不可变字符串有什么区别?
final 限制的是变量能否重新赋值,不可变性描述的是对象内容能否修改。例如:
final String name = "Java";
final 让 name 在初始化后不能再指向别的对象。即使去掉 final,原来的 String 对象仍然不可变。因此,变量能不能换一个引用,与对象内容能不能修改,需要分开判断。
7.3 StringBuilder 一定比 + 快吗?
不一定,要看 JDK、数据量和调用方式。单个表达式用 + 更直观,编译器也能整体优化;在循环中逐步累积文本时,复用 StringBuilder 可以减少中间字符串和重复复制。
7.4 String.length() 返回用户看到的字符数吗?
不一定。length() 返回的是 UTF-16 代码单元数,而用户看到的一个字符可能占多个代码单元。如果需要按码点计数或遍历,可以用 codePointCount() 或 codePoints()。
代理项与码点示例见字符串存储与字符计数。
8. 面试题卡片
9. 参考资料
- Java API:String
- Java API:StringBuilder
- Java API:StringBuffer
- Java Language Specification:final Variables
- Java Language Specification:Constant Expressions
- Java Language Specification:String Literals
- Java Language Specification:String Concatenation Operator
- OpenJDK 21:String 存储实现
- Java 21 API:StringConcatFactory
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明