Java String 字符串核心特性与 API 详解

三、字符串常量池（String Pool）

3.1 常量池定义与作用

字符串常量池是 JVM 为 String 专门设计的内存区域（属于方法区），用于存储字符串常量，核心作用是复用对象、减少内存占用。当创建字符串时，JVM 会先检查常量池：若存在相同内容的字符串，直接返回其引用；若不存在，创建新字符串存入常量池并返回引用。

3.2 字符串创建的两种方式对比

String 对象有两种创建方式，其在内存中的存储位置、是否复用常量池对象均不同，是面试高频考点。

方式 1：字面量赋值（String s = 'abc'）

优先使用常量池，流程如下：

1. JVM 检查字符串常量池，是否存在 'abc'。
2. 存在：直接将常量池中 'abc' 的引用赋值给 s。
3. 不存在：在常量池创建 'abc' 对象，再将引用赋值给 s。

方式 2：new 关键字创建（String s = new String('abc'）

优先在堆内存创建对象，流程如下：

1. 在堆内存中创建一个新的 String 对象。
2. 检查字符串常量池，是否存在 'abc'。
3. 不存在：在常量池创建 'abc' 对象，再让堆对象的 value 引用指向常量池对象。
4. 存在：直接让堆对象的 value 引用指向常量池对象。
5. 将堆对象的引用赋值给 s。

结论：new String('abc') 至少创建 1 个对象（堆对象），最多创建 2 个对象（堆对象 + 常量池对象，若常量池无对应值）。

3.3 代码示例：两种创建方式对比

public class StringPoolDemo {
    public static void main(String[] args) {
        // 方式 1：字面量赋值，复用常量池对象
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2); // true（引用同一常量池对象）
        System.out.println(s1.equals(s2)); // true（内容相同）

        // 方式 2：new 创建，堆对象不同
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.println(s3 == s4); // false（堆中两个不同对象）
        System.out.println(s3.equals(s4)); // true（内容相同）
        // 堆对象与常量池对象对比
        System.out.println(s1 == s3); // false（分别指向常量池、堆）
    }
}

3.4 常量池相关方法：intern()

intern() 方法是 String 类提供的手动关联常量池的方法，作用是：将当前字符串对象的内容存入常量池（若不存在），并返回常量池中该对象的引用。

代码示例：intern() 使用

public class StringInternDemo {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = s1.intern(); // 将 'abc' 存入常量池（已存在），返回常量池引用
        String s3 = "abc";

        System.out.println(s1 == s2); // false（s1 指向堆，s2 指向常量池）
        System.out.println(s2 == s3); // true（均指向常量池）
        // 常量池不存在时的场景
        String s4 = new String("xy") + new String("z"); // 堆对象 "xyz"，常量池无 "xyz"
        String s5 = s4.intern(); // 常量池创建 "xyz"，返回其引用
        String s6 = "xyz";
        System.out.println(s4 == s5); // JDK7+ 为 true（常量池存储堆对象引用），JDK6 为 false
        System.out.println(s5 == s6); // true
    }
}

注意：JDK 7 对 intern() 做了优化，若常量池不存在该字符串，会直接存储堆对象的引用（而非复制内容），进一步节省内存。

四、String 核心 API 详解（附示例）

String 类提供了大量操作字符串的 API，按功能分类整理，结合示例说明核心用法，覆盖开发高频场景。

4.1 字符串长度与空判断

int length()

// 返回字符串的长度（字符个数），注意与数组长度属性区分（数组用 length，字符串用 length() 方法）
// 示例：获取字符串长度
String str = "Java String";
System.out.println(str.length()); // 输出：11（包含空格，空格算一个字符）

boolean isEmpty()

// 判断字符串是否为空（长度为 0），仅当字符串是 "" 时返回 true，无法判断 null（判断 null 需先做非空校验，否则抛空指针异常）
// 示例：判断字符串是否为空
String emptyStr = "";
String nonEmptyStr = "test";
String nullStr = null;

System.out.println(emptyStr.isEmpty()); // 输出：true
System.out.println(nonEmptyStr.isEmpty()); // 输出：false
// System.out.println(nullStr.isEmpty()); // 报错：NullPointerException
// 安全判断写法
System.out.println(nullStr != null && !nullStr.isEmpty()); // 输出：false

4.2 字符串拼接与替换

4.2.1 拼接方法

String concat(String str)

// 仅能拼接 String 类型，若传入 null 会抛出 NullPointerException，拼接后原字符串不变，返回新字符串
// 示例：使用 concat 拼接字符串
String str1 = "Hello";
String str2 = "World";
String result = str1.concat(" ").concat(str2); // 支持链式调用
System.out.println(result); // 输出：Hello World
System.out.println(str1); // 输出：Hello（原字符串未变）
// String error = str1.concat(null); // 报错：NullPointerException

+ 号拼接

// 支持任意数据类型（基本类型、引用类型）拼接，null 会被当作 "null" 处理，编译期优化为 StringBuilder（循环拼接除外，循环中 + 号会重复创建 StringBuilder，效率低）
// 示例：使用 + 号拼接字符串
String str = "年龄：";
int age = 25;
String result1 = str + age; // 拼接基本类型
String result2 = "姓名：" + "张三" + "，" + result1; // 链式拼接字符串
String result3 = "null 拼接：" + null; // 处理 null

System.out.println(result1); // 输出：年龄：25
System.out.println(result2); // 输出：姓名：张三，年龄：25
System.out.println(result3); // 输出：null 拼接：null

4.2.2 替换方法

String replace(char oldChar, char newChar)

// 替换字符串中所有指定的旧字符为新字符，若旧字符不存在，返回原字符串
// 示例：替换指定字符
String str = "abacada";
String result = str.replace('a', 'x'); // 替换所有 'a' 为 'x'
String noChange = str.replace('z', 'y'); // 旧字符不存在，返回原字符串

System.out.println(result); // 输出：xbxcdxd
System.out.println(noChange); // 输出：abacada

String replace(CharSequence target, CharSequence replacement)

替换字符串中所有指定的子串为目标子串，支持 String、StringBuilder 等 CharSequence 类型。

// 示例：替换指定子串
String str = "Hello World, World is beautiful";
String result = str.replace("World", "Java"); // 替换所有 "World" 为 "Java"

System.out.println(result); // 输出：Hello Java, Java is beautiful

String replaceAll(String regex, String replacement)

按正则表达式匹配内容，替换所有符合条件的子串，正则特殊字符需转义。

// 示例：正则替换（去除所有数字、替换空格）
String str = "abc123def456 789";
String noNum = str.replaceAll("\\d", ""); // 匹配所有数字并替换为空
String noSpace = str.replaceAll("\\s", "-"); // 匹配所有空格并替换为 "-"

System.out.println(noNum); // 输出：abcdef
System.out.println(noSpace); // 输出：abc123def456-789

String replaceFirst(String regex, String replacement)

// 按正则表达式匹配内容，仅替换第一个符合条件的子串
// 示例：替换第一个匹配的子串
String str = "abacada";
String result = str.replaceFirst("a", "x"); // 仅替换第一个 'a' 为 'x'

System.out.println(result); // 输出：xbacada

4.3 字符串截取与分割

4.3.1 截取方法

String substring(int beginIndex)

// 从指定索引（包含该索引字符）开始截取，到字符串末尾结束，索引越界会抛出 StringIndexOutOfBoundsException
// 示例：从指定索引截取到末尾
String str = "abcdefgh";
String result1 = str.substring(3); // 从索引 3 开始截取
String result2 = str.substring(0); // 从开头截取，返回原字符串

System.out.println(result1); // 输出：defgh
System.out.println(result2); // 输出：abcdefgh
// String error = str.substring(10); // 报错：StringIndexOutOfBoundsException

String substring(int beginIndex, int endIndex)

遵循'左闭右开'原则，截取从 beginIndex（包含）到 endIndex（不包含）的子串，beginIndex 不能大于 endIndex。

// 示例：指定起始和结束索引截取
String str = "abcdefgh";
String result = str.substring(2, 6); // 截取索引 2、3、4、5 的字符（不包含 6）

System.out.println(result); // 输出：cdef
// String error = str.substring(6, 2); // 报错：StringIndexOutOfBoundsException

4.3.2 分割方法

String[] split(String regex)

// 按正则表达式分割字符串，返回字符串数组，若末尾有匹配项，会忽略空字符串；若无匹配项，返回仅含原字符串的数组
// 示例：按正则分割字符串
import java.util.Arrays;

String str1 = "a,b,c,d,e";
String[] arr1 = str1.split(","); // 按逗号分割
String str2 = "192.168.1.1";
String[] arr2 = str2.split("\\."); // 点是正则特殊字符，需双重转义
String str3 = "abc";
String[] arr3 = str3.split(","); // 无匹配项，返回原字符串数组

System.out.println(Arrays.toString(arr1)); // 输出：[a, b, c, d, e]
System.out.println(Arrays.toString(arr2)); // 输出：[192, 168, 1, 1]
System.out.println(Arrays.toString(arr3)); // 输出：[abc]

String[] split(String regex, int limit)

// limit 控制分割结果的数组长度，limit>0 时，分割 limit-1 次，返回长度为 limit 的数组；limit=0 时，效果同 split(String regex)；limit<0 时，分割所有匹配项，不忽略末尾空字符串
// 示例：指定 limit 分割字符串
import java.util.Arrays;

String str = "a,b,c,d,e";
String[] arr1 = str.split(",", 3); // limit=3，分割 2 次，返回 3 个元素
String[] arr2 = str.split(",", 0); // 等同于无 limit，忽略末尾空串
String[] arr3 = str.split(",", -2); // 分割所有，不忽略末尾空串（此处无空串）

System.out.println(Arrays.toString(arr1)); // 输出：[a, b, c,d,e]
System.out.println(Arrays.toString(arr2)); // 输出：[a, b, c, d, e]
System.out.println(Arrays.toString(arr3)); // 输出：[a, b, c, d, e]

4.4 字符串查找与判断

4.4.1 查找方法

int indexOf(int ch)

// 返回指定字符（传入字符的 Unicode 编码也可）第一次出现的索引，未找到返回 -1
// 示例：查找字符第一次出现的索引
String str = "Hello World";
int index1 = str.indexOf('o'); // 查找 'o' 的索引
int index2 = str.indexOf(111); // 111 是 'o' 的 Unicode 编码，效果同上
int index3 = str.indexOf('z'); // 未找到，返回 -1

System.out.println(index1); // 输出：4
System.out.println(index2); // 输出：4
System.out.println(index3); // 输出：-1

int indexOf(int ch, int fromIndex)

// 从 fromIndex（包含）开始，查找指定字符第一次出现的索引，fromIndex 超出字符串长度返回 -1
// 示例：从指定索引开始查找字符
String str = "Hello World";
int index = str.indexOf('o', 5); // 从索引 5 开始查找 'o'

System.out.println(index); // 输出：7（索引 5 之后第一个 'o' 在 7 的位置）

int indexOf(String str)

// 返回指定子串第一次出现的索引，子串为空时返回 0，未找到返回 -1
// 示例：查找子串第一次出现的索引
String str = "Hello World Java";
int index1 = str.indexOf("World"); // 查找子串 "World"
int index2 = str.indexOf(""); // 空串返回 0
int index3 = str.indexOf("Python"); // 未找到返回 -1

System.out.println(index1); // 输出：6
System.out.println(index2); // 输出：0
System.out.println(index3); // 输出：-1

int lastIndexOf(int ch)

// 返回指定字符最后一次出现的索引，未找到返回 -1，与 indexOf 方向相反
// 示例：查找字符最后一次出现的索引
String str = "abacada";
int index = str.lastIndexOf('a'); // 查找最后一个 'a'

System.out.println(index); // 输出：6（字符串末尾的 'a' 索引为 6）

char charAt(int index)

// 返回指定索引处的字符，索引范围为 0~length()-1，越界抛出 StringIndexOutOfBoundsException
// 示例：获取指定索引处的字符
String str = "Hello World";
char c1 = str.charAt(3); // 获取索引 3 的字符
char c2 = str.charAt(str.length()-1); // 获取最后一个字符

System.out.println(c1); // 输出：l
System.out.println(c2); // 输出：d
// char error = str.charAt(20); // 报错：StringIndexOutOfBoundsException

4.4.2 判断方法

boolean equals(Object anObject)

// 重写自 Object 类，严格比较字符串内容（区分大小写、字符顺序），仅当参数是 String 且内容完全一致时返回 true
// 示例：比较字符串内容（区分大小写）
String str1 = "Hello";
String str2 = "Hello";
String str3 = "hello";
String str4 = new String("Hello");

System.out.println(str1.equals(str2)); // 输出：true（内容一致）
System.out.println(str1.equals(str3)); // 输出：false（大小写不同）
System.out.println(str1.equals(str4)); // 输出：true（内容一致，引用不同不影响）
System.out.println(str1.equals(null)); // 输出：false（避免空指针）

boolean equalsIgnoreCase(String anotherString)

// 忽略大小写比较字符串内容，仅比较字符本身，不区分大小写（不改变原字符串大小写）
// 示例：忽略大小写比较内容
String str1 = "Java";
String str2 = "java";
String str3 = "JAVA";

System.out.println(str1.equalsIgnoreCase(str2)); // 输出：true
System.out.println(str1.equalsIgnoreCase(str3)); // 输出：true
System.out.println(str1.equals(str2)); // 输出：false（对比 equals 方法）

boolean startsWith(String prefix)

// 判断字符串是否以指定前缀开头，前缀为空串时返回 true
// 示例：判断是否以指定前缀开头
String str = "Hello World Java";
boolean flag1 = str.startsWith("Hello"); // 以 "Hello" 开头
boolean flag2 = str.startsWith("World"); // 不以 "World" 开头
boolean flag3 = str.startsWith(""); // 空前缀返回 true

System.out.println(flag1); // 输出：true
System.out.println(flag2); // 输出：false
System.out.println(flag3); // 输出：true

boolean endsWith(String suffix)

// 判断字符串是否以指定后缀结尾，后缀为空串时返回 true
// 示例：判断是否以指定后缀结尾
String str = "Hello World Java";
boolean flag1 = str.endsWith("Java"); // 以 "Java" 结尾
boolean flag2 = str.endsWith("World"); // 不以 "World" 结尾

System.out.println(flag1); // 输出：true
System.out.println(flag2); // 输出：false

boolean contains(CharSequence s)

// 判断字符串是否包含指定字符序列（子串），子串为空串时返回 true，本质是通过 indexOf 实现（indexOf != -1 则返回 true）
// 示例：判断是否包含指定子串
String str = "Hello World Java";
boolean flag1 = str.contains("World"); // 包含 "World"
boolean flag2 = str.contains("Python"); // 不包含 "Python"

System.out.println(flag1); // 输出：true
System.out.println(flag2); // 输出：false

4.5 字符串转换（大小写、数组、基本类型）

4.5.1 大小写转换

String toLowerCase()

// 将字符串中所有大写字母转换为小写字母，非字母字符保持不变，返回新字符串（原字符串不变）
// 示例：转换为小写字符串
String str = "Hello World 123!";
String lowerStr = str.toLowerCase();

System.out.println(lowerStr); // 输出：hello world 123!
System.out.println(str); // 输出：Hello World 123!（原字符串不变）

String toUpperCase()

// 将字符串中所有小写字母转换为大写字母，非字母字符保持不变，返回新字符串
// 示例：转换为大写字符串
String str = "Hello World 123!";
String upperStr = str.toUpperCase();

System.out.println(upperStr); // 输出：HELLO WORLD 123!
System.out.println(str); // 输出：Hello World 123!（原字符串不变）

4.5.2 字符串与数组转换

char[] toCharArray()

// 将字符串转换为字符数组，数组长度与字符串长度一致，字符顺序完全相同
// 示例：字符串转字符数组
import java.util.Arrays;

String str = "Hello";
char[] charArr = str.toCharArray();

System.out.println(Arrays.toString(charArr)); // 输出：[H, e, l, l, o]
System.out.println(charArr[0]); // 输出：H（可通过数组索引访问字符）

static String valueOf(char[] data)

// 静态方法，将字符数组转换为字符串，数组为 null 时返回 "null"，而非抛出空指针
// 示例：字符数组转字符串
import java.util.Arrays;

char[] charArr1 = {'H', 'e', 'l', 'l', 'o'};
char[] charArr2 = null;
String str1 = String.valueOf(charArr1);
String str2 = String.valueOf(charArr2);

System.out.println(str1); // 输出：Hello
System.out.println(str2); // 输出：null（处理 null 安全）

4.5.3 字符串与基本类型转换

基本类型转 String：可通过 + 号拼接或 String.valueOf() 方法（推荐 valueOf()，效率更高、处理 null 更安全）。

String 转基本类型：通过对应包装类的 parseXxx() 方法（如 Integer.parseInt()），转换失败抛 NumberFormatException。

// 示例 1：基本类型转字符串
int num = 123;
double d = 3.14;
boolean b = true;
// 方式 1：valueOf（推荐）
String strNum = String.valueOf(num);
String strD = String.valueOf(d);
String strB = String.valueOf(b);
// 方式 2：+ 号拼接
String strNum2 = num + "";

System.out.println(strNum); // 输出：123
System.out.println(strD); // 输出：3.14
System.out.println(strB); // 输出：true
System.out.println(strNum2); // 输出：123

// 示例 2：字符串转基本类型
String str1 = "456";
String str2 = "3.1415";
int num2 = Integer.parseInt(str1); // 字符串转 int
double d2 = Double.parseDouble(str2); // 字符串转 double

System.out.println(num2 + 100); // 输出：556
System.out.println(d2 + 0.8585); // 输出：4.0

// 转换失败示例（编译通过，运行报错）
// String strError = "abc";
// int numError = Integer.parseInt(strError); // 报错：NumberFormatException

4.6 去除空格与比较

4.6.1 去除空格方法

• String trim()：去除字符串首尾的空白字符（空格、制表符 \t、换行符 \n 等），中间空格保留。
• String strip()：JDK 11+ 新增，功能与 trim() 类似，但支持 Unicode 空白字符（推荐使用）。

4.6.2 字符串比较（按字典序）

• 返回 0：内容相同。
• 返回正数：当前字符串大于目标字符串。
• 返回负数：当前字符串小于目标字符串。

int compareToIgnoreCase(String str)

按字典序比较，不区分大小写。

int compareTo(String anotherString)

// 按字典序比较两个字符串，返回差值
public class StringTrimCompareDemo {
    public static void main(String[] args) {
        // 去除空格
        String s1 = " Hello World \t\n";
        System.out.println(s1.trim()); // Hello World（去除首尾空白）
        // System.out.println(s1.strip()); // JDK11+ 可用，效果同上，支持 Unicode 空白

        // 字典序比较
        String s2 = "abc";
        String s3 = "abd";
        String s4 = "ABC";
        System.out.println(s2.compareTo(s3)); // -1（s2 < s3，差值为 'c'-'d'=-1）
        System.out.println(s3.compareTo(s2)); // 1（s3 > s2）
        System.out.println(s2.compareToIgnoreCase(s4)); // 0（不区分大小写，内容相同）
    }
}

五、String、StringBuilder、StringBuffer 对比

开发中频繁修改字符串时，需选择 StringBuilder 或 StringBuffer，三者核心差异集中在可变性、线程安全、效率上，对比如下：

5.1 代码示例：效率对比（循环拼接）

public class StringPerformanceDemo {
    public static void main(String[] args) {
        int loop = 100000; // 循环次数

        // String 拼接（效率极低）
        long start1 = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i < loop; i++) {
            s += i;
        }
        long end1 = System.currentTimeMillis();
        System.out.println("String 耗时：" + (end1 - start1) + "ms");

        // StringBuilder 拼接（效率最高）
        long start2 = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < loop; i++) {
            sb.append(i);
        }
        String result2 = sb.toString();
        long end2 = System.currentTimeMillis();
        System.out.println("StringBuilder 耗时：" + (end2 - start2) + "ms");

        // StringBuffer 拼接（效率中等）
        long start3 = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer();
        for (int i = 0; i < loop; i++) {
            sbf.append(i);
        }
        String result3 = sbf.toString();
        long end3 = System.currentTimeMillis();
        System.out.println("StringBuffer 耗时：" + (end3 - start3) + "ms");
    }
}

运行结果参考：String 耗时 5000+ms，StringBuilder 耗时 1-2ms，StringBuffer 耗时 5-10ms，差异显著。

六、常见面试题汇总

1. String 为什么是不可变的？ 答：底层通过 private final char[] value（JDK8）+ 无修改方法实现，不可变性保障线程安全、支持常量池、哈希值稳定。
2. String s = new String('abc') 创建了几个对象？ 答：至少 1 个（堆对象），最多 2 个（堆对象 + 常量池对象，若常量池无 'abc'）。
3. String、StringBuilder、StringBuffer 的区别？ 答：核心差异在可变性、线程安全、效率（详见第五章对比表），单线程优先用 StringBuilder，多线程用 StringBuffer，不频繁修改用 String。
4. intern() 方法的作用？JDK7 对其做了什么优化？ 答：将字符串内容存入常量池并返回常量池引用；JDK7 优化为：常量池不存在时，直接存储堆对象引用（而非复制内容），节省内存。
5. JDK8 与 JDK9+ 中 String 底层实现的差异？ 答：JDK8 用 char[]（2 字节/字符），JDK9+ 用 byte[] + coder（ASCII 占 1 字节，UTF-16 占 2 字节），目的是节省内存。
6. String 的 equals() 与 == 的区别？ 答：equals() 比较字符串内容（String 重写后），== 比较对象引用地址；基本类型用 == 比较值，引用类型默认 == 比较引用（除 String 常量池复用场景）。