面试深入解析Java字符串常量池：从理论到实践

引言

在Java编程中，字符串是最常用的数据类型之一。Java为了优化字符串的性能和内存使用，设计了字符串常量池（String Pool）这一特殊机制。本文将深入探讨字符串常量池的工作原理，并通过代码示例详细分析其行为特点。

一、字符串常量池概述

1.1 什么是字符串常量池

字符串常量池是Java虚拟机（JVM）中一块特殊的内存区域，用于存储字符串字面量。它的主要目的是减少重复字符串对象的内存占用，提高程序性能。

1.2 常量池的位置演变

• JDK 1.6及之前：位于永久代（PermGen）
• JDK 1.7：将字符串常量池移到了堆内存
• JDK 1.8及之后：完全移除了永久代，使用元空间（Metaspace）替代，但字符串常量池仍在堆中

这种变迁主要是为了避免永久代的内存溢出问题，并提高内存管理的灵活性。

二、字符串创建机制解析

2.1 两种创建方式对比

Java中创建字符串主要有两种方式：

// 方式一：字面量赋值
String s1 = "hello";

// 方式二：new关键字创建
String s2 = new String("hello");

这两种方式在内存分配上有本质区别：

1. 字面量赋值：

• • 首先检查字符串常量池中是否存在该字面量
  • 如果存在，直接返回池中的引用
  • 如果不存在，在池中创建对象并返回引用

1. new关键字创建：

• • 首先检查字符串常量池（与字面量方式相同）
  • 然后在堆内存中创建一个新的String对象
  • 返回堆中新对象的引用

2.2 经典问题解析

问题：String s = new String("abc")创建了几个对象？

答案：

• 如果常量池中不存在"abc"：创建2个对象（常量池1个+堆中1个）
• 如果常量池中已存在"abc"：创建1个对象（仅堆中）

可以通过以下代码验证：

public class StringPoolDemo {
    public static void main(String[] args) {
        // 首次创建，会在常量池和堆中各创建一个对象
        String s1 = new String("abc");
        
        // 再次创建，常量池已有"abc"，只在堆中创建
        String s2 = new String("abc");
        
        System.out.println(s1 == s2); // false，因为指向不同堆对象
        System.out.println(s1.intern() == s2.intern()); // true，指向同一个常量池对象
    }
}

三、intern()方法深度解析

3.1 intern()方法的作用

intern()方法用于将字符串对象添加到常量池中：

• 如果池中已存在该字符串，返回池中的引用
• 如果不存在，将该字符串添加到池中并返回引用

3.2 intern()使用示例

public class InternDemo {
    public static void main(String[] args) {
        String s1 = new String("hello") + new String("world");
        String s2 = "helloworld";
        
        System.out.println(s1 == s2); // false
        
        s1 = s1.intern();
        System.out.println(s1 == s2); // true
    }
}

3.3 JDK 1.7+的intern()优化

在JDK 1.7之后，intern()方法不再复制字符串到常量池，而是在池中记录首次出现的实例的引用：

public class InternOptimization {
    public static void main(String[] args) {
        String s1 = new StringBuilder("ja").append("va").toString();
        System.out.println(s1.intern() == s1); // JDK 1.7+输出true
        
        String s2 = new StringBuilder("计算机").append("科学").toString();
        System.out.println(s2.intern() == s2); // 通常为true
    }
}

四、性能优化实践

4.1 字符串拼接性能对比

public class StringConcatPerformance {
    private static final int COUNT = 100000;
    
    public static void main(String[] args) {
        // 方式一：使用+拼接
        long start1 = System.currentTimeMillis();
        String s1 = "";
        for (int i = 0; i < COUNT; i++) {
            s1 += i;
        }
        long end1 = System.currentTimeMillis();
        System.out.println("+拼接耗时：" + (end1 - start1) + "ms");
        
        // 方式二：使用StringBuilder
        long start2 = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < COUNT; i++) {
            sb.append(i);
        }
        String s2 = sb.toString();
        long end2 = System.currentTimeMillis();
        System.out.println("StringBuilder耗时：" + (end2 - start2) + "ms");
    }
}

4.2 合理使用intern()

对于大量重复的字符串，可以使用intern()来节省内存：

public class InternUsage {
    public static void main(String[] args) {
        // 模拟从数据库读取大量重复城市名称
        String[] cities = new String[100000];
        for (int i = 0; i < cities.length; i++) {
            // 不使用intern()
            // cities[i] = new String("北京").toCharArray();
            
            // 使用intern()
            cities[i] = new String("北京").intern();
        }
        
        // 比较内存使用
        System.out.println("使用intern()后，相同字符串只存储一份");
    }
}

五、常见面试题解析

5.1 题目一：字符串比较

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

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

5.2 题目二：字符串拼接

String s1 = "hello" + "world";
String s2 = "helloworld";
System.out.println(s1 == s2); // true，编译器优化

String s3 = "hello";
String s4 = s3 + "world";
System.out.println(s2 == s4); // false，运行时拼接

六、总结与最佳实践

1. 优先使用字面量方式创建字符串
2. 避免在循环中使用+拼接字符串，改用StringBuilder
3. 谨慎使用intern()，只有在确实需要减少内存占用时才使用
4. 理解字符串不可变性，避免不必要的字符串操作
5. 注意编译期优化，如常量折叠（Constant Folding）

在实际开发中，应当根据具体场景选择合适的字符串处理方式，平衡内存使用和性能需求。