【Java】字符串为什么不可变？原理+代码实例详解
大家好，我是云扬～ 今天想和大家深入聊聊 Java 中一个基础又关键的知识点：字符串为什么不可变。作为日常开发中最常用的数据类型，String 的不可变性不仅影响代码逻辑，还和性能、安全性密切相关。这篇文章会从原理、原因、实际应用三个维度拆解，再配上直观的代码实例，帮大家彻底搞懂～
一、String 的不变性：源码级拆解
要理解不可变性，首先得看 String 类的底层实现。打开 JDK 源码，String 类的核心定义如下：
// String 类被 final 修饰，无法被继承
public final class String
implements java.io.Serializable, Comparable>, CharSequence {
// 存储字符串的字符数组，被 private + final 修饰
private final char value[];
// 哈希值缓存（后续会讲作用）
private int hash; // Default to 0
// 构造方法：初始化字符数组
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
// 其他方法...
}
从源码能看出两个关键设计，这也是 String 不可变的核心：
- 类被 final 修饰：意味着 String 不能被继承，子类无法重写它的方法来改变行为；
- 存储数据的 char 数组被 final + private 修饰：
private保证外部无法直接操作这个数组；final保证数组的引用地址一旦初始化就不能修改（注意：不是数组本身不能变，而是不能指向新的数组）。
简单说：String 对象创建后，其底层字符数组的引用和内容都无法被修改 —— 这就是「不可变性」的本质。
二、为什么要设计成不可变？3 大核心原因
1. 保证安全性：避免敏感数据被篡改
字符串常用来存储密码、密钥、配置信息等敏感数据。如果 String 是可变的，可能被恶意代码偷偷修改，导致安全漏洞。
代码实例：安全场景验证
public class SecurityDemo {
public static void main(String[] args) {
String password = "yunyang_123456"; // 存储密码
checkPassword(password);
System.out.println("原始密码：" + password); // 输出：yunyang_123456
}
private static void checkPassword(String pwd) {
// 假设这里是验证逻辑，如果 String 可变，可能被篡改
pwd = pwd.replace("123456", "xxxxxx"); // 实际是创建新对象，原对象不变
}
}
由于 String 不可变，checkPassword 方法中对 pwd 的修改不会影响原始 password 对象，保证了数据安全性。
2. 缓存哈希值：提升集合性能
String 经常作为 HashMap、HashSet 等集合的键（Key），而哈希表的查找依赖哈希值（hashCode）。如果 String 是可变的，每次修改后哈希值都会变化，导致集合无法正确查找元素。
String 的解决方案是：首次计算哈希值后缓存起来，后续直接复用（源码中 private int hash 就是缓存字段）。
代码实例：哈希值缓存验证
public class HashDemo {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
// 相同内容的字符串，哈希值相同且只计算一次
System.out.println(s1.hashCode()); // 输出：96354
System.out.println(s2.hashCode()); // 输出：96354（复用缓存）
// 新对象会重新计算哈希值
String s3 = s1.concat("def");
System.out.println(s3.hashCode()); // 输出：2943241
}
}
如果 String 可变，每次修改都要重新计算哈希值，会大幅降低哈希表的查询性能。
3. 实现字符串常量池：节省内存
Java 设计了「字符串常量池」（String Constant Pool），核心逻辑是：相同内容的字符串只存储一份，多个变量共享引用。这一切的前提是 String 不可变 —— 如果可变，一个变量修改了字符串内容，其他共享引用的变量都会受影响。
代码实例：常量池复用验证
public class ConstantPoolDemo {
public static void main(String[] args) {
// 直接赋值：从常量池获取对象（如果不存在则创建）
String a = "hello";
String b = "hello";
// new String：创建新对象，不直接使用常量池
String c = new String("hello");
// 验证引用是否相同
System.out.println(a == b); // true（指向常量池同一个对象）
System.out.println(a == c); // false（c 是新对象）
System.out.println(a.equals(c)); // true（内容相同）
}
}
通过常量池，相同内容的字符串无需重复创建，极大节省了内存空间 —— 尤其是在大量使用字符串的场景（如数据库操作、接口调用）中，效果更明显。
三、注意：String 的「修改」其实是创建新对象
由于不可变性，String 类中所有看似「修改」的方法（如截取、拼接、替换），本质都是创建新的 String 对象，原对象不会有任何变化。
代码实例：常用方法的不可变性验证
public class ModifyDemo {
public static void main(String[] args) {
String original = "hello world";
// 1. 截取 substring()
String sub = original.substring(6);
System.out.println("原字符串：" + original); // hello world（不变）
System.out.println("截取后：" + sub); // world（新对象）
// 2. 拼接 concat()
String concat = original.concat("！");
System.out.println("原字符串：" + original); // hello world（不变）
System.out.println("拼接后：" + concat); // hello world！（新对象）
// 3. 替换 replace()
String replace = original.replace('l', 'x');
System.out.println("原字符串：" + original); // hello world（不变）
System.out.println("替换后：" + replace); // hexxo worxd（新对象）
}
}
输出结果很直观：所有操作后，original 依然是最初的 “hello world”，修改后的结果都存储在新创建的对象中。
四、总结
String 的不可变性是 Java 语言的经典设计，核心依赖「final 类 + final 字符数组」的底层实现，带来了三大优势：
- 保护敏感数据，提升安全性；
- 缓存哈希值，优化哈希表性能；
- 支持字符串常量池，节省内存。
需要注意的是：频繁修改字符串时（如循环拼接），尽量使用 StringBuilder 或 StringBuffer，避免创建大量临时对象，提升性能。
如果大家在实际开发中遇到字符串相关的坑（比如 == 和 equals 的区别、常量池复用问题），欢迎在评论区留言讨论～
