happy最紧要这道题我在面试里问了无数遍，也在无数个技术群里看人争过。String str = new String("abc") 到底创建了几个对象？有人脱口而出“两个”，有人犹豫半天说“一个”，也有人反问“是不是要看情况”。每次听到这里我都挺感慨——这题看起来基础到不能再基础，但它能暴露的东西，比你想象中多得多。
先说个现场画面。上个月面一个三年经验的候选人，前面聊项目、聊并发都还行，我顺势问了一句这道题。他几乎是抢答的：“两个对象，引用str一个，堆里new出来的String一个。”然后我就追问了一句：“那‘abc’这个字符串本身呢？它算不算对象？它在哪？”他愣了一下，之后就开始绕了。
这就是我想写这篇文章的原因。你背过答案不等于你懂了，你懂了点皮毛也未必经得住追问。更关键的是，不同JDK版本、不同写法、不同运行阶段，这个问题的答案真的会变。今天我从底层到面试话术，把这道题彻底拆开聊一遍。
1. 一道看似送分、实则筛人的面试题，到底在考什么
先说个可能让你意外的结论：这道题的标准答案从来不是唯一的，它取决于你站在哪个时间点看问题。
很多人都把这道题当成JVM内存模型的背诵题，实际上面试官问它，核心是想知道三件事：你有没有真正理解字符串常量池和堆的关系；你有没有区分“编译期创建的东西”和“运行期创建的东西”；你能不能把一个Java表达式拆成JVM层面的一系列指令去理解。
就我自己的面试经验而言，能把这三点讲清楚的人，项目里处理内存优化、SQL拼接、缓存Key设计这些事，往往也不会差到哪里去。反过来，只会背“两个对象”的人，遇到线上字符串导致的卡顿或OOM，大概率是一脸懵的。
1.1 从候选人最常见的两种回答说起
先把这两种典型回答摆出来：
回答A：“一个对象，String指向的就是‘abc’啊。”
回答B：“两个对象，一个是new出来的String，一个是字符串常量池里的‘abc’。”
回答A显然是错的，因为它把字面量“abc”和new出来的String对象混为一谈了。字符串常量池里存的东西是一个独立的String实例，或者至少是一个可被引用的对象形态的数据，不能因为你平时写String s = "abc"用起来“看起来一样”，就认为引用和对象是同一个东西。
回答B听起来正确，其实也只说对了一半。为什么？因为你只描述了代码运行的那一刻，却没考虑代码运行之前发生了什么。“abc”这个字符串对象，其实在类加载阶段就已经被创建好并放进常量池了，这与new String执行不执行无关。也就是说，你在执行这一行代码之前，“abc”就已经作为对象存在于JVM内部了。
所以当面试官问“创建了几个对象”时，你必须定义清楚：你问的是类加载期创建的，还是这一行代码运行期创建的？如果把两个阶段合在一起算，结论和单独算运行期是截然不同的。
1.2 标准答案“两个对象”为什么不够用
市面上流传最广的答案是：“创建了两个对象，一个在堆里，一个在字符串常量池里。” 这个答案能应付八成的初级面试，但漏洞很明显。
第一个漏洞：字符串常量池里的对象是在类加载阶段创建的，不属于这行代码运行时的“创建动作”。如果你严格限定“执行这行代码时”，那你只能说new动作创建了一个对象，并引用了一个早已存在的常量池对象。
第二个漏洞：如果这个类在运行前，字符串常量池里根本没有“abc”呢？比如你之前执行过一句String s = new String(new char[]{...})，把字符串给变出来了，但池子里没有对应字面量。此时执行String str = new String("abc")，实际上类加载阶段还会先把“abc”扔进池子。这种情况下的对象计数又不一样。
第三个漏洞：JIT编译后，对象能不能创建出来都不一定。现代JVM会做逃逸分析，如果new出来的String没有逃逸出当前方法，它可能被栈上分配甚至完全标量化，也就是不实际创建对象。真要抬杠，“两个对象”连运行期都不一定成立。
所以这道题表面上考String，实际考的是你对JVM规范的掌握程度，以及你说话的逻辑边界。能把边界讲清的人，已经不是背题选手了。
1.3 这题真正考察的三个底层知识点
我把这道题的底层知识点拆成三层：
第一层是Java对象创建机制。new关键字一定会触发对象创建吗？在解释执行阶段确实会，在JIT阶段可能被优化掉。这是很多两年经验以内的人没想过的。
第二层是字符串的驻留机制，也就是intern相关逻辑。JVM维护了一个字符串常量池，用字面量方式赋值的字符串会进入池中，后续相同内容的引用可以直接复用池中对象。这个机制的本质是“用空间换时间”还是“用时间换空间”，也值得聊一聊。
第三层是类加载和常量池的关系。一个类中出现的所有字符串字面量，会作为CONSTANT_String_info常量存放在Class文件的常量池中。类加载阶段，JVM会把这些常量解析成对应的String对象实例，放到运行时常量池或堆的特殊区域里。也就是说，字面量“abc”并不是你写String str = new String("abc")那一刻才诞生的，它在类加载时已经存在了。
理解了这三层，你就能明白为什么同一个问题换个写法、换台JVM、换个时间点，答案都会变。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 先给标准结论：一行的执行在JVM里拆成了几件事
我们把场景限定在最常见的情况：JDK 8及以上，HotSpot虚拟机，代码所在类第一次被加载，且此前程序中没有以任何形式出现过“abc”这个字符串内容。
在这种设定下，String str = new String("abc") 的整体流程可以拆成两部分。
类加载阶段，JVM读取该类对应的Class文件，发现字符串常量池中有一个“abc”的字面量。此时JVM会在字符串常量池中创建（或者说驻留）一个内容为“abc”的String对象。注意这里用的是“驻留”，如果常量池已经存在相同内容的字符串，则不重复创建。
运行阶段，执行到new String("abc")时，因为构造方法接收的是一个字符串参数，而这里的参数恰好是常量池中那个“abc”对象。new关键字会触发在堆上创建一个新的String对象，内部字符数组跟参数保持一致。新创建的对象和常量池里的“abc”不是同一个对象，它们的关系类似于“复制了一份同样的字符串内容，但本体不同”。
然后，栈上的局部变量str会指向堆上新建出来的这个String对象，而构造方法里引用的常量池对象，在线程执行完这条语句之后，就失去了来自这个局部变量的直接引用，只继续活在常量池里等待后续复用。
所以在这个最标准的场景下：类加载期池中创建一个“abc”对象，代码运行期堆里再new一个对象，总共涉及两个String对象的创建。
但别急着背。这个结论非常脆弱，我们继续往深了说。
2.1 分两步看：字面量“abc”和new String()分别干了什么
要彻底理解这个创建过程，最好把表达式拆成两个部分来理解。
第一部分是字面量“abc”。JVM规范里有一个特殊的字符串常量池区域，任何字面量字符串都会被驻留进去。当你写下String str = new String("abc")时，“abc”作为字面量出现在代码中，它就会参与类加载时期的常量解析。更重要的是，这个驻留动作的执行时机是懒加载式的——第一次使用到这个字面量的类被加载和链接时，它才会被真正创建并放进池中。
第二部分是new String()。new关键字负责在堆上分配一块内存，调用构造器完成初始化。String的构造器众多，这里的String(String original)构造器会把original内部的char数组或byte数组复制一份，而不是直接复用同一块数组。也就是说，即使内容完全一致，new出来的String也会持有自己独立的数组引用。
这里有一个很多初学者不知道的细节：new String("abc")复制字符数组这个动作，本身是有内存开销的。如果你的“abc”特别长，比如一段数千字符的文本，每一次new都会把字符数组完整拷贝一遍。这也是为什么很多人推荐直接使用字面量赋值而不是new String()的根本原因。题面中的例子虽然只涉及3个字符，但这个原理是通用的。
2.2 用字节码验证：javap -c 看到的ldc与new指令
光说理论不过瘾，我们直接看字节码。写一段最简单的代码：
java复制public class StringDemo {
public void test() {
String str = new String("abc");
}
}
保存编译后，使用javap -c命令反编译class文件，你会看到这样的输出：
java复制public void test();
Code:
0: new #2 // class java/lang/String
3: dup
4: ldc #3 // String abc
6: invokespecial #4 // Method java/lang/String."<init>":(Ljava/lang/String;)V
9: astore_1
10: return
注意这里的操作顺序。new指令先创建了空的String对象，dup复制了一个引用，ldc指令会把常量池中的“abc”推送到操作数栈顶，然后invokespecial调用String的构造器。这个构造器接收的参数，就是刚才ldc从常量池里取出的“abc”对象。
这里最值得关注的就是ldc指令。ldc意思是“从运行时常量池加载常量”，它背后的机制就是访问字符串常量池，取出对应字符串对象的引用。如果你在类中直接写String s = "abc"，不用new，那也是走这条ldc指令，区别在于少了前面的new和invokespecial。
所以从字节码层面能清楚看到：new指令和ldc指令是两个独立的动作，一个负责在堆上创建String对象，一个负责从常量池中装载字符串对象。把这两件事分开看，题目的答案就天然清晰了。
2.3 别忽略类加载期：常量池的“预创建”发生在代码运行前
走完字节码还不算完。你还要思考一个问题：ldc指令取出“abc”的时候，这个字符串对象真的已经存在了吗？它是何时存在于何处的？
答案是：字节码指令运行时，JVM遇到ldc指令会去解析运行时常量池中的CONSTANT_String_info常量。这个解析过程会调用String.intern()逻辑，确保常量池中已经有一个内容为“abc”的String对象。如果之前没有，就创建一个放入池中；如果之前有，就直接复用。
也就是说，哪怕你的代码里没有任何一行对“abc”的显式使用，只要类中包含了这个字面量，第一次加载到该类的时刻，这个字符串对象就已经在池中驻留了。这也是面试中回答“创建了几个对象”时必须先明确时间范围的核心原因。
另外要补充一点，类加载期建立字符串对象这件事，跟你这个方法有没有被执行没有关系。只要类被加载了，这些字面量解析就可能在验证或准备阶段触发。所以你在程序里写死了一堆大字符串常量，即使某些分支永远不执行，它们也已经被放进池中占内存了。这也是很多反模式代码的隐患之一。
3. 字符串常量池的底层逻辑：为什么“一个”和“两个”都对
聊到这一步，很多人的疑问其实集中在字符串常量池本身。这个池到底在哪？池里放的是什么？为什么有时候说池里是对象，有时候又说池里是引用？这节的目的是把池子彻底讲明白。
3.1 “abc”字符串对象第一次是如何进池的
先明确一个基本点：字符串常量池是一个哈希表结构，它存放的是字符串对象的引用，或者说，它的每个元素指向堆中（JDK 7以后）或方法区中（JDK 6及以前）的String对象。
提问：第一次遇到字面量“abc”，进池过程是什么？
JVM会先检查哈希表，看有没有内容为“abc”的字符串。没有的话，就执行一个等效于intern()的操作，创建一个String对象并把它加入哈希表。这里的“创建位置”取决于JDK版本。
在JDK 6及之前，字符串常量池位于永久代，池中放的是实际的String对象，此时池中的对象跟堆中普通对象不在同一个内存区域。在JDK 7及之后，字符串常量池移到堆中，池中存放的不再是对象本身，而是指向堆中String对象的引用。更准确点说，JVM会先在堆中创建String对象，再把它的引用加入常量池哈希表。
这个改动影响极其深远。最典型的就是intern()方法的语义变化：JDK 6里调用intern()，如果池中没有，则复制一份对象放入永久代，然后返回永久代对象引用；JDK 7里如果池中没有，堆中的那个对象自己就会入池，返回的引用直接指向堆中的原对象。
这也是为什么网上很多老技术博客写的结论，放到新JDK上并不完全适用。你拿JDK 8的代码去验证JDK 6时代的结论，容易得出“假”的结果。
3.2 JDK版本变化：永久代移除前后，池子到底搬了家
JDK 8之后其实大家遇到最多的是永久代被元空间替代，字符串常量池从永久代移到了堆中，这个动作核心原因之一就是为了解决永久代容易OOM的问题。大量字符串驻留如果都在永久代，内存很难控制，而移到堆中后就可以依赖常规GC去回收无用的字符串对象。
对这道面试题而言，JDK版本变动的最大影响是：JDK 6及以前，new String("abc")创建的两个对象分处两个区域（堆和永久代）；JDK 7及以后，常量池本身在堆里，所以两个对象虽然都在堆中，但一个是普通对象，一个是池化的、被哈希表引用的对象。
有时候面试官会顺嘴问一句：“这两个对象是同一个吗？”很多人会用“都在堆里”来回答“是同一个”，这肯定是错的。是否在同一个内存区域，跟是否是同一个对象，是两码事。常量池中的字符串对象和new出来的对象是两个独立实例，哪怕内容一样、哈希值一样、equals结果为true，引用比较依然是false。
如果你用以下代码可以直观验证：
java复制public class StringPoolDemo {
public static void main(String[] args) {
String a = "abc";
String b = new String("abc");
System.out.println(a == b); // false
System.out.println(a.equals(b)); // true
System.out.println(a == b.intern()); // true
}
}
输出一眼就能看出a、b的关系。a指向常量池中的“abc”，b指向堆上的一个新String对象。内容一样，但引用完全不同。b调用intern后，返回的是常量池中已有对象的引用，所以与a相同。
结合这些你会发现，这道题讲的不只是String对象创建，它还逼迫你去理解“字符串复用”和“对象实体”的边界。这个边界在写缓存、拼接SQL、使用Map的Key时特别重要。
3.3 池中放的是对象还是引用（JDK 6和JDK 7的区别）
前文提过，JDK版本不同，池中存放的东西也不同。这里再用一个经典对比来说明。
在JDK 6中，当你执行：
java复制String s = new String("abc");
s.intern();
如果常量池之前没有“abc”，会把s指向的那个String对象复制一份到永久代并加入池，返回永久代中的对象引用。注意，这里用的是“复制”，意味着堆中的原对象和池中的对象是两个独立个体。
在JDK 7及以上版本中，同样代码执行intern()时，如果池中没有“abc”，JVM会直接将s指向的堆对象引用记录到常量池哈希表中，此时s本身就成了池中对象。换句话说，驻留的不再是复制品，而是原对象本身。
这个差异对内存影响很大。JDK 6时代大量使用intern()可能造成永久代内存暴涨，而JDK 7以后因为移动到了堆中，同样代码的内存表现可能完全不同。很多人会用下面这个例子去验证jdk版本差异：
java复制String s1 = new String("ja") + new String("va");
System.out.println(s1.intern() == s1);
这种用例要小心，因为“java”这个词在JVM内部有特殊驻留情况，不同版本结果不同。与其记这些偏门用例，不如记住根本差异：JDK 7之后，intern()返回的引用可能和调用对象是同一个。
而回到我们的面试题上，正是因为池中存放规则的这种版本差异，你在回答“new String('abc')创建了几个对象”时，必须和面试官确认或主动说明自己使用的是哪个JDK版本。这本身就是一种专业的表达习惯。
4. 把场景换一换，答案跟着变：运行期的常见分支
前面分析的是最常见场景，池中已有“abc”。但真实业务代码里，情况远比这个复杂。同一句代码，在不同的运行历史下，可能对应不同的对象创建数量。下面几种典型情况，面试官很喜欢作为追问抛出来。
4.1 情况一：常量池原本没有“abc”
这个场景相对少见，因为只要你在任何地方写过字面量“abc”，池里就会存在它。但有一种例外，你是通过拼接或构造的方式生成的字符串内容：
java复制public class StringDemo2 {
public static void main(String[] args) {
char[] data = new char[]{'a', 'b', 'c'};
String generated = new String(data);
String s = new String("abc");
}
}
请问：s这一行创建了几个对象？
这取决于“abc”之前是否已经在池中。前面一行生成的generated虽然是内容为“abc”的字符串，但它不会自动驻留到池中。所以当你执行new String("abc")时，类加载阶段依然会判定池中没有“abc”对应的字面量对象，于是在加载这个类时创建并驻留一个。运行期new动作再创建一个堆对象。
所以这行代码依旧会涉及到池对象和堆对象两类实体。但如果你要严格抠时间点，池中的对象创建发生在类加载期间，而不是这行代码执行期间。你可以在类加载完成后、方法执行前，通过反射手段检查常量池状态来验证。
这也是为什么我建议面试时最好主动声明时间边界。说清楚“在方法运行期只new了一个堆对象，但加上类加载期常量池的驻留动作，一共涉及两个String对象”，这样既严谨又完整，基本上就脱离了背答案的层次。
4.2 情况二：new String(其他字符串) 与编译期可确定
很多人还会遇到另一个变体：String str = new String(new String("abc"))，或者是String str = new String(someMethod())。
如果是new String(new String("abc"))，最内侧new String("abc")执行时会触发一次堆对象创建，同时自己作为构造参数又会触发外层new String创建。所以运行期堆上会多出两个新对象，池中依然只有一个“abc”。整体加起来涉及三个String对象实体。
如果是new String(someMethod())，其中someMethod()返回一个内容是“abc”的动态字符串，那么这行代码本身只有一个new动作。池中如果没有“abc”，也不会因为你这个调用而自动驻留，除非内部调用了intern()。这种情况下真正涉及的对象数量就变得不可预测，它取决于方法的返回逻辑。
这里的关键点是：内容为“abc”的字符串和“abc”字面量是两回事。一次动态运算出来的“abc”，跟写在代码里的“abc”，在JVM眼中有一个非常清晰的区分：一个会触发常量池驻留，一个不会。你只要抓得住这个区分，所有变形题都难不倒你。
4.3 intern()的本质：入池返回引用，而不是“复制了一份”
聊到字符串驻留，不得不提intern()。很多人对intern有一个错误认知：调用intern方法，相当于把当前字符串的内容复制到常量池中，返回常量池对象。这个说法在JDK 7以前勉强能用，在JDK 7以后就不准确了。
真正的过程是：调用intern()时，JVM会拿当前字符串内容去哈希表里查。如果找到相同内容的字符串，直接返回池中已有对象的引用，当前对象保持不变，池中也没有新增。如果找不到，JDK 7以后会把当前调用intern()的那个字符串对象本身加入池中，让池的哈希表记录它的引用。
所以“入池的不是副本，而是你自己”，这句话是JDK 7之后intern()相较老版本最大的不同。有些优化技巧会利用这一点，比如大量相同内容的字符串只保留一份，减少内存。也会有隐患，比如你把一个巨大String对象intern了，它就再也无法被GC回收，因为它被哈希表强引用着。线上环境滥用intern导致内存泄漏的例子并不少。
回到new String("abc")这道题，如果你在之后调用：
java复制String str = new String("abc");
String poolStr = str.intern();
因为“abc”已经在池中，所以intern()直接返回了池中原有的“abc”对象引用。str和poolStr并不相同，前者是堆上普通对象，后者是池化对象。没有任何新对象被创建。
4.4 面试追问的高发区：字面量拼接、循环创建、逃逸分析
面试官在面试中经常加码的几个追问，也一起在这里说了。
第一个追问：“String s = "a" + "b" + "c"; 创建了几个对象？”答案是0个或常量池中的“abc”可能被创建，取决于之前是否存在。因为“a” + “b” + “c”全由字面量组成，编译期就会被优化为字符串常量“abc”，插入常量池，字节码里只剩一条ldc指令。没有任何运行期拼接动作。
第二个追问：“String s = base + "b"; 假设base是传入的变量，此时创建了几个对象？”这就不好说了。base如果是动态的，运行时无法直接确定结果，只能通过StringBuilder或类似方式拼接，最终会生成一个新的String对象。拼接过程中还可能出现StringBuilder对象、char数组扩容分配等临时对象。只看结论的话，至少会创建一个新String，而临时对象的多少没法一概而论。
第三个追问：“循环里不断new String，会不会很耗性能？”这里牵涉逃逸分析。HotSpot的C2或Graal编译器会分析对象是否逃逸出方法。如果new String("abc")的结果没有被传出去、没有被return、没有存入外部数据结构，JIT可能直接用栈上分配甚至消除掉这个对象的创建。相关字节码在解释执行时也许还在创建对象，但经过JIT编译后，实际机器码里可能压根没有对应的内存分配指令。这也是我们常说的“JVM优化让你不能只根据源代码判断对象数量”。
这些追问其实没有标准答案，面试官想听的是你能不能结构化思考。你把类加载期、运行期、编译期三个时间维度分开，把对象分配和常量池驻留两件事分开，把解释执行和JIT优化分开，就已经给出了满分框架。
5. 下一次被问到，我建议你这样答
之前看很多同学准备这道题，背了标准答案就放心了。真上考场被追问两句就露馅，原因在于他一直在背“结果”，没有建立回答的“结构”。
如果是我来回答，我会按下面这个顺序展开回答。
第一步，约定条件：我先和面试官约定JDK版本和场景。比如“我以JDK 8为例，假设之前没出现过‘abc’，而且不考虑JIT优化的特殊情况”。
第二步，说明类加载阶段：类加载的时候，因为源代码里有字面量“abc”，常量池会驻留一个内容为“abc”的String对象。这一步产生的对象，严格来说不属于new语句执行时的产物，但它确实在那行代码运行前就存在了。
第三步，说明运行阶段：执行new String("abc")时，JVM会先在堆上new一个String对象，然后把常量池中的“abc”作为构造参数传入，完成内容复制。这一个new动作是运行期真正发生的对象创建。
第四步，汇总：如果只统计代码执行时的创建动作，在标准场景下答案是“创建了1个堆对象，同时引用了常量池中已有的1个对象”；如果把类加载惰性驻留也算上，就是“通常涉及2个String对象”。
回答时别怕啰嗦，面试官如果想听精简版会打断你，而你这么回答，几乎每句话都在展示底层知识的边界感，这正是这一题最难得的东西。
5.1 加分的小动作：主动提到构造器拷贝逻辑
这里有个容易让人眼前一亮的分支：new String("abc")的构造过程，会复制字符数组吗？答案是会。String有一个专门的构造器，接收另一个String作为参数，它在内部会通过Arrays.copyOf来复制字符内容，确保新对象不受原字符串后续变化的影响。JDK 9以后底层从char[]换成了byte[]，拷贝逻辑有细微区别，但“复制”的大方向没变。
如果你在回答中主动补一句“这里不是引用同一个字符数组，而是拷贝了一份内容”，面试官会立刻知道你读过String源码，而不是只背了网上面经。更进一步，你还可以提一下，正是因为这种拷贝，某些场景下new String会带来无谓的数组内存浪费，所以优先推荐字面量赋值。
5.2 三个加分句，帮你从回答者里跳出来
分享三个临场能用的话术：
第一句：“如果从类加载器的角度看，这个字符串可能在我这行代码运行之前就已经被放进常量池了。” 这句话表明你区分了类加载阶段和代码运行阶段。
第二句：“在JDK 7以后，字符串常量池移到了堆里，池中存的是String对象的引用；但即使都在堆里，new出来的对象和池中对象也不是同一个对象，因为内容复制了两份。” 这句话表明你了解版本演进，也清楚引用和对象的区别。
第三句：“如果考虑到JIT的逃逸分析和标量替换，实际执行时对象都不一定会被真正创建出来，所以这道题严格说应该是‘在解释执行且无JIT优化时……’”。这句话能把题目拉到一个更高的维度，也是在暗示你不是死记硬背的人。
5.3 面试官真正期待的引导方向
作为面试官，我特别希望候选人把话题引导到更有意思的方向去。比如你可以主动说：“其实这道题还会延伸到String不可变性的设计、字符串常量池带来的内存收益、以及StringBuilder的使用场景。如果项目里碰到大片字符串拼接，性能瓶颈往往不是拼接本身，而是创建了大量中间String对象。”
聊到这里，这就不再是一道孤立的面试题了，它会变成一个关于内存模型、编译器优化、API设计理念的综合讨论。很多候选人以为面试官考的是“知不知道答案”，其实面试官想看到的是一个能由点及面、把知识和实践串起来的人。
6. 我踩过的那些String相关的“坑”
最后说一点跟理论无关但跟经历有关的体会。可能也是我这几年写程序、带新人后，对String相关题目感触最深的地方。
早几年前我刚工作那阵，接手过一个定时任务，里面用一个List存了十几万条从外部接口拿到的字符串，每条内容都和业务配置的常量有重叠。当时前辈review代码时跟我说，“别用new String包装这些数据，里面很多内容都一样，全都在堆里躺着，GC压力会很大。”我当时不太服气，觉得一个String能占多少内存。后来压测发现，任务高峰期堆内存直线上涨，甚至出现频繁Full GC。排查下来，发现有一处代码调用了类似new String(original)的写法，本来可以直接复用原来的字符串引用，硬是在堆里多复制了十几万份内容。那次以后我才真正理解了，new String并不只是“多一个对象而已”，它背后的字符数组复制是有实际内存代价的。
还有一次，我们有个配置系统用Map做缓存，Key由多个字段拼接而成。当时的同事图省事，在循环里用加号拼接Key，代码大概是这样的：
java复制for (...) {
String key = prefix + ":" + userId + ":" + bizType;
cacheMap.get(key);
}
因为prefix和bizType都是变量，编译器不会优化成常量拼接，每次循环都会生成新的String对象。系统刚上线没啥感觉，等数据量上来，缓存命中倒是没问题，但GC线程的CPU占用率肉眼可见地提高了。后来改成用StringBuilder统一构建或在进入循环前把固定字段拼好，问题就缓解了很多。
这两个事情让我在带人时特别强调一件事：让你别用new String不是因为那个new有多贵，而是因为每次new都可能复制一份完整的字符数组。如果这段数据本身来自常量池或不可变区域，那纯粹的引用的开销远小于整段内容的复制。
话说回来，面试中碰到“String str = new String('abc')创建了几个对象”这类题，别排斥，也别只会背。把它当成一个窗口，去理解JVM、编译器和JDK库本身是怎么协作的。真正想明白的人，面对任何变体都能处变不惊。这也是我写这篇分析最想传达的东西：一道表面上的基础题，背后能挖出深不见底的Java功底。