Java中的字符串驻留（String Interning）机制详解

一、什么是字符串驻留

字符串驻留是Java中一种特殊的字符串存储机制，它指的是将字符串字面量在编译时或运行时存储在一个共享的常量池中，以便在程序的不同部分重复使用相同的字符串对象时，可以共享同一个实例，从而节省内存。

二、核心概念解析

1. 字符串常量池（String Constant Pool）

• 位置：在Java 6及之前位于方法区（永久代），Java 7之后移到了堆内存
• 作用：存储所有字符串字面量和通过intern()方法驻留的字符串
• 特性：线程安全，全局共享

2. 字符串对象的创建方式

// 方式1：字面量创建（直接进入常量池）
String s1 = "hello";

// 方式2：new创建（在堆中创建新对象）
String s2 = new String("hello");

// 方式3：通过字符数组创建
char[] chars = {'h', 'e', 'l', 'l', 'o'};
String s3 = new String(chars);

三、字符串驻留的工作原理

步骤1：编译时处理

// 源代码
String a = "hello";
String b = "hello";

// 编译后的字节码会：
// 1. 在常量池中创建"hello"字符串
// 2. 将a和b都指向常量池中的同一个"hello"对象

步骤2：运行时intern()方法

String s1 = new String("hello");  // 在堆中创建新对象
String s2 = s1.intern();          // 将字符串驻留到常量池

System.out.println(s1 == s2);      // false
System.out.println("hello" == s2); // true

intern()方法的具体执行过程：

1. 检查常量池中是否存在内容相同的字符串
2. 如果存在，直接返回常量池中的引用
3. 如果不存在，将当前字符串对象添加到常量池，并返回引用

四、内存布局示例

// 示例代码
String s1 = "java";
String s2 = "java";
String s3 = new String("java");
String s4 = s3.intern();

// 内存布局：
// 常量池："java" (地址: 0x1000)
// 堆：new String("java") (地址: 0x2000)
//
// 引用关系：
// s1 → 0x1000 (常量池)
// s2 → 0x1000 (常量池)
// s3 → 0x2000 (堆)
// s4 → 0x1000 (常量池)

五、不同Java版本的差异

Java 6及之前

// 常量池在永久代，大小有限（-XX:MaxPermSize）
// 大量调用intern()可能导致OutOfMemoryError: PermGen space
String s = new String(new char[1024]).intern(); // 小心！

Java 7及之后

// 常量池移到堆内存，受堆大小限制
// 可以更好地被垃圾回收器管理
// 但仍然要谨慎使用，避免内存泄漏

六、实战应用场景

场景1：优化字符串比较性能

// 普通比较（每次都要比较字符内容）
boolean isEqual(String a, String b) {
    return a.equals(b);
}

// 优化后（先intern，然后比较引用）
boolean isEqualOptimized(String a, String b) {
    return a.intern() == b.intern();  // 引用比较，O(1)时间复杂度
}

场景2：减少重复字符串内存占用

// 解析大量重复的字符串数据时
Map<String, String> cache = new HashMap<>();

String getInternedString(String raw) {
    String interned = cache.get(raw);
    if (interned == null) {
        interned = raw.intern();
        cache.put(raw, interned);
    }
    return interned;
}

七、注意事项与最佳实践

1. 自动驻留的字符串

// 以下字符串会自动驻留：
String s1 = "literal";           // 字面量
String s2 = "lit" + "eral";      // 编译时常量表达式
final String s3 = "literal";     // final常量

// 以下不会自动驻留：
String s4 = new String("literal");          // new创建
String s5 = s1 + s2;                        // 运行时拼接
String s6 = new StringBuilder().append("lit").append("eral").toString();

2. intern()的使用建议

// 适合使用intern()的场景：
// 1. 字符串数量有限且重复率高
// 2. 需要频繁进行字符串比较
// 3. 字符串生命周期较长

// 不适合使用intern()的场景：
// 1. 字符串数量无限或非常大
// 2. 字符串生命周期短暂
// 3. 随机生成的字符串

3. 性能考虑

// intern()方法的成本：
// - 需要同步操作（Java 7之前）
// - 需要哈希查找
// - 可能触发垃圾回收

// 建议：对于已知的、有限的字符串集合，可以手动管理
class StringPool {
    private static final Map<String, String> pool = new ConcurrentHashMap<>();
    
    public static String intern(String s) {
        String existing = pool.putIfAbsent(s, s);
        return existing == null ? s : existing;
    }
}

八、常见面试问题解析

问题1：以下代码输出什么？

String s1 = new String("abc");
String s2 = "abc";
String s3 = s1.intern();

System.out.println(s1 == s2);  // false
System.out.println(s2 == s3);  // true

解析：

• s1在堆中创建新对象
• s2指向常量池中的"abc"
• s3通过intern()获得常量池中的引用
• 所以s1≠s2，s2=s3

问题2：字符串拼接时的驻留

String s1 = "a" + "b" + "c";      // 编译时优化为"abc"，会驻留
String s2 = s1 + "d";             // 运行时拼接，不会自动驻留
final String s3 = "e";
String s4 = s3 + "f";             // 编译时常量，会驻留

九、总结

字符串驻留机制是Java为了优化内存和性能而设计的：

1. 字面量自动驻留：编译时处理
2. 手动控制：通过intern()方法
3. 内存优化：减少重复字符串的内存占用
4. 性能优化：加速字符串比较

正确理解和使用字符串驻留机制，可以在处理大量字符串时显著提升程序性能，但也要注意避免滥用导致的性能问题。