字符串是 Java 开发中最常用的数据类型之一，而字符串常量池作为 Java 内存模型里的 “特殊存在”，不仅影响着程序的内存使用效率，也是理解 Java 核心设计思想的关键。

一、字符串的不可变性：内存特性与性能影响

在聊常量池之前，先从字符串的一个核心特性说起：不可变性。Java 里的字符串一旦创建，它在内存里的原始值就永远不会变。比如我们写String s = "hello"; s = s + " world";，看似是 “修改” 了字符串，实则是新建了一个 "hello world" 的字符串对象，原来的 "hello" 还躺在内存里，只是变量s不再指向它了。

这种设计的好处是线程安全、可缓存，但问题也很明显：如果频繁创建重复的字符串（比如循环里拼接相同内容），会造成大量内存浪费。而字符串常量池的出现，就是为了缓存重复的字符串，减少内存占用—— 简单说，就是让相同内容的字符串只在内存里存一份，所有用到它的变量都指向这一份地址。

a.本质：字符串对象在创建后，其内存区域的原始值不会被修改。任何看似 “修改” 字符串的操作（如拼接、替换），本质都是创建新的字符串对象，并让变量指向新的内存地址。

b.内存损耗问题：计算机内存分配的最小单元是 4KB 的内存页。若频繁修改字符串（如循环拼接），每次修改都会至少占用一个 4KB 内存页 —— 假设修改 1 万次，理论上会消耗 1 万个 4KB 内存页，造成极大的内存浪费。

二、字符串常量池：存储规则与核心逻辑

字符串常量池是 Java 底层用于缓存字符串的特殊内存区域（属于常量池的一种，还有类常量池、静态常量池等），底层以数组形式存储，核心作用是减少重复字符串的内存占用。

2.1 不同赋值方式的存储逻辑

字符串的创建方式主要分两种，对应完全不同的内存逻辑，我们用代码 + 通俗解释说清楚：

1. 双引号直接赋值：优先走常量池

// 方式1：双引号直接赋值
String s1 = "java";
String s2 = "java";

当执行String s1 = "java"时，JVM 会先去字符串常量池里找有没有 "java"：

• 如果没有，就在常量池里创建 "java"，并让s1指向这个地址；
• 如果有（比如后续的s2），直接让s2指向已有的地址，不会新建。

所以s1 == s2的结果是true—— 因为两者指向的是常量池里同一个地址。

2. new 关键字创建：先堆内存，再看常量池

// 方式2：new关键字创建
String s3 = new String("java");
String s4 = new String("java");

当执行new String("java")时，JVM 的操作分两步：

1. 先检查常量池里有没有 "java"，没有的话先在常量池创建（保证常量池里有一份）；
2. 然后在堆内存里新建一个字符串对象，让变量（比如s3）指向堆里的这个新对象。

所以s3 == s4的结果是false—— 因为两者指向堆里不同的对象；而s1 == s3也是false（一个指向常量池，一个指向堆）。

小补充：== 和 equals 的区别

很多刚学的朋友会混淆这两个，其实核心就一点：

• ==：比较的是内存地址（变量指向的 “门牌号”）；
• equals：String 类重写了这个方法，比较的是字符串的实际内容（房子里的东西）。

比如上面的例子：

System.out.println(s1.equals(s3)); // true（内容都是java）
System.out.println(s3.equals(s4)); // true（内容都是java）

三、字符串常量池的内存回收机制

普通的 Java 对象（比如new Object()），如果没有任何变量指向它，垃圾回收器（GC）会自动回收它的内存。但常量池里的字符串不一样：

1. 即使变量改变指向（比如s1 = "python"），原来常量池里的 "java" 也不会立刻被回收，依然留在常量池里；
2. 只有当常量池的空间不够用了，JVM 才会清理常量池里使用频率最低的字符串（不是 “最老的”，也不是 “没人指向的”），释放内存。

这里可以记一个小细节：空字符串String s = "";，底层其实对应 C 语言的char* {"\0"}，虽然看起来是空的，但会占用 1 字节的结束符内存（Java 底层基于 C 实现，这点只是帮大家理解，不用深究）。

四、JDK 版本差异：常量池的 “搬家” 故事

字符串常量池的存储位置不是一成不变的，不同 JDK 版本有调整，了解这个能更好理解内存模型：

JDK 6 及之前：常量池放在 “方法区的永久代” 里，永久代的内存空间有限，容易出现内存溢出

JDK 7 及以后：常量池被移到了 “堆内存” 里，堆的内存空间更大、管理更灵活，这也是 JDK 优化内存的一个小细节

五、关联：与 HashMap 的配合使用

字符串常量池的知识点常与 HashMap 结合考察，核心逻辑：

1. HashMap 的 key 依赖hashCode()和equals()：String 重写了hashCode()（基于字符串内容计算哈希值）和equals()（比较内容）；
2. 若 String 未重写这两个方法，以字符串为 key 的 HashMap 会因 “地址不同但内容相同” 的 key 重复存储，破坏 HashMap 的核心逻辑；
3. 常量池的缓存特性可减少相同字符串的 hashCode 计算开销，提升 HashMap 的性能。

这两个方法是 HashMap 能正常工作的 “基石”，我们用 String 作为 Key 的场景举例，就能直观理解：

1. 先看：如果 String 没重写这两个方法会怎样？

Object 类（所有类的父类）默认的hashCode()返回的是对象的内存地址值，默认的equals()比较的也是内存地址。假设 String 没重写这两个方法，我们做这样的操作：

HashMap<String, Integer> map = new HashMap<>();
// s1指向常量池，s3指向堆，内容都是"java"但地址不同
String s1 = "java";
String s3 = new String("java");

map.put(s1, 1);
map.put(s3, 2);

// 期望：用s3查应该拿到1（因为内容都是"java"），实际却拿到2
System.out.println(map.get(s3)); // 输出2，而非预期的1

问题出在哪？

• s1和s3的内存地址不同 → 原始hashCode()返回的值不同 → HashMap 认为它们是两个不同的 Key；
• 原始equals()比较地址 → 也认为它们不相等；
• 最终 HashMap 里会存两个 Key（"java" 和 "java"），完全违背了 “Key 唯一” 的核心逻辑。

2. 再看：String 重写后带来的改变

String 重写了hashCode()和equals()：

• 重写hashCode()：基于字符串的内容计算哈希值（比如 "java" 不管存在常量池还是堆，hashCode 值都一样）；
• 重写equals()：比较字符串的实际内容（而非地址）。

还是上面的例子，重写后：

HashMap<String, Integer> map = new HashMap<>();
String s1 = "java";
String s3 = new String("java");

map.put(s1, 1);
map.put(s3, 2); // 因为s1和s3内容相同，这一步是“覆盖”而非“新增”

System.out.println(map.get(s3)); // 输出2（覆盖后的值）
System.out.println(map.size()); // 输出1（只有1个Key）

这才符合 HashMap“Key 唯一，值可覆盖” 的设计初衷。

六、总结

1.字符串常量池的核心作用是缓存重复字符串，减少内存占用，根源是字符串的不可变性；

2.双引号赋值复用常量池地址，new 创建会在堆新建对象，==比地址、equals比内容；

3.常量池的回收逻辑特殊，仅在空间不足时清理低频字符串，JDK7 后常量池从方法区移到堆内存；

4.实际开发中优先用双引号创建固定字符串，避免不必要的内存浪费。