1. Java String类基础与核心特性
Java中的String类是使用频率最高的类之一，但很多开发者对其底层机制理解不够深入。我们先从String的基础特性讲起，这些特性直接影响着它的使用方式和性能表现。
String类在Java中被设计为final类，这意味着它不能被继承。这种设计保证了String对象的行为不会被修改，确保了字符串操作的安全性。在内存层面，String对象内部使用char数组存储字符数据，这个数组同样被声明为final，进一步强化了不可变性。
提示：String的不可变性是面试高频考点，理解这一点对掌握字符串处理至关重要。
1.1 不可变性的实现原理
String的不可变性体现在三个方面：
- 类本身被final修饰，防止子类修改行为
- 内部char数组被final修饰，引用不可变
- 所有修改操作都返回新对象而非修改原对象
这种设计带来了几个关键优势：
- 线程安全：无需额外同步即可在多线程环境下安全使用
- 缓存哈希值：String常用作HashMap的键，不可变性保证了哈希值的一致性
- 安全性：防止敏感字符串被篡改
- 常量池优化：允许字符串常量池的实现，节省内存
java复制// 典型String操作示例
String s1 = "hello";
String s2 = s1.concat(" world"); // 返回新对象，不改变s1
System.out.println(s1); // 输出"hello"
System.out.println(s2); // 输出"hello world"
1.2 字符串常量池机制
JVM为了优化字符串内存使用，设计了字符串常量池（String Pool）。这是一个特殊的内存区域，用于存储字符串字面量。当创建字符串时，JVM会先检查常量池中是否已存在相同内容的字符串：
-
使用字面量创建时（String s = "abc"）：
- 先检查常量池
- 存在则直接返回引用
- 不存在则在常量池创建新对象
-
使用new创建时（String s = new String("abc")）：
- 先在堆中创建新对象
- 不直接使用常量池（但可以通过intern()方法手动加入）
java复制String a = "hello"; // 常量池创建
String b = "hello"; // 复用常量池
String c = new String("hello"); // 堆中新对象
System.out.println(a == b); // true，同一引用
System.out.println(a == c); // false，不同引用
System.out.println(a.equals(c)); // true，内容相同
1.3 String的常用构造方法
虽然我们最常用字面量方式创建字符串，但String类提供了多种构造方法：
java复制// 1. 空字符串
String s1 = new String();
// 2. 从字节数组构造
byte[] bytes = {104, 101, 108, 108, 111};
String s2 = new String(bytes); // "hello"
// 3. 从字符数组构造
char[] chars = {'w', 'o', 'r', 'l', 'd'};
String s3 = new String(chars); // "world"
// 4. 从StringBuilder构造
StringBuilder sb = new StringBuilder("builder");
String s4 = new String(sb); // "builder"
2. String类的常用方法解析
String类提供了丰富的方法来处理字符串，这些方法可以分为几个主要类别：查询方法、比较方法、操作方法和转换方法。我们按类别详细解析最常用的方法及其使用场景。
2.1 查询与检查方法
-
length()：返回字符串长度
java复制"hello".length(); // 5 -
isEmpty()：检查是否为空字符串
java复制"".isEmpty(); // true -
charAt(int index)：获取指定位置字符
java复制"abc".charAt(1); // 'b' -
indexOf()/lastIndexOf()：查找子串位置
java复制"hello".indexOf('l'); // 2 "hello".lastIndexOf('l'); // 3 -
contains(CharSequence s)：检查是否包含子串
java复制"hello".contains("ell"); // true
2.2 字符串比较方法
-
equals(Object obj)：内容比较
java复制"hello".equals("hello"); // true -
equalsIgnoreCase(String str)：忽略大小写比较
java复制"Hello".equalsIgnoreCase("hello"); // true -
compareTo(String str)：字典序比较
java复制"apple".compareTo("banana"); // 负数（a在b前） -
startsWith()/endsWith()：前缀/后缀检查
java复制"file.txt".endsWith(".txt"); // true
2.3 字符串操作方法
-
substring(int begin, int end)：截取子串
java复制"hello".substring(1, 4); // "ell" -
concat(String str)：字符串连接
java复制"hello".concat(" world"); // "hello world" -
replace()：字符/子串替换
java复制"hello".replace('l', 'L'); // "heLLo" -
toLowerCase()/toUpperCase()：大小写转换
java复制"Hello".toLowerCase(); // "hello" -
trim()：去除首尾空白
java复制" hello ".trim(); // "hello" -
split(String regex)：按正则分割
java复制"a,b,c".split(","); // ["a", "b", "c"]
2.4 类型转换方法
-
valueOf()：各种类型转String
java复制String.valueOf(123); // "123" -
toCharArray()：转为字符数组
java复制"hello".toCharArray(); // ['h','e','l','l','o'] -
getBytes()：转为字节数组
java复制"hello".getBytes(); // [104, 101, 108, 108, 111]
3. 字符串拼接的性能陷阱与优化
字符串拼接是日常开发中最常见的操作之一，但不当的使用方式会导致严重的性能问题。理解不同拼接方式的差异对写出高效代码至关重要。
3.1 拼接操作性能对比
我们通过一个简单测试比较几种拼接方式的性能差异：
java复制final int COUNT = 100000;
// 1. 使用+操作符
long start = System.currentTimeMillis();
String s1 = "";
for (int i = 0; i < COUNT; i++) {
s1 += i;
}
System.out.println("+操作符耗时: " + (System.currentTimeMillis() - start));
// 2. 使用concat方法
start = System.currentTimeMillis();
String s2 = "";
for (int i = 0; i < COUNT; i++) {
s2 = s2.concat(String.valueOf(i));
}
System.out.println("concat耗时: " + (System.currentTimeMillis() - start));
// 3. 使用StringBuilder
start = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < COUNT; i++) {
sb.append(i);
}
String s3 = sb.toString();
System.out.println("StringBuilder耗时: " + (System.currentTimeMillis() - start));
测试结果通常会显示：
- +操作符：最慢（可能相差几个数量级）
- concat：中等
- StringBuilder：最快
3.2 性能差异的原因分析
-
+操作符：
- 编译时会被转换为StringBuilder操作
- 但在循环中每次迭代都会创建新的StringBuilder
- 产生大量临时对象，增加GC压力
-
concat方法：
- 每次调用都创建新String对象
- 比+操作符稍好，但仍有性能问题
-
StringBuilder：
- 可变字符序列，避免创建中间对象
- 预先分配缓冲区，减少扩容次数
- 是循环拼接的最佳选择
注意：在单行简单拼接（如String s = "a" + "b" + "c"）时，编译器会自动优化为单个StringBuilder操作，此时性能与直接使用StringBuilder相当。
3.3 实际开发建议
- 循环内拼接必须使用StringBuilder
- 单行简单拼接可以使用+操作符（可读性更好）
- 已知最终大小时可预设StringBuilder容量
java复制StringBuilder sb = new StringBuilder(estimatedSize); - 多线程环境考虑使用StringBuffer（线程安全版StringBuilder）
4. StringBuilder与StringBuffer详解
当需要进行大量字符串修改操作时，StringBuilder和StringBuffer是比String更合适的选择。它们提供了可变字符序列，避免了频繁创建新对象的开销。
4.1 核心区别与选择
| 特性 | StringBuilder | StringBuffer |
|---|---|---|
| 线程安全 | 非线程安全 | 线程安全 |
| 性能 | 更高 | 稍低 |
| 版本 | Java 5+ | Java 1.0+ |
| 使用场景 | 单线程环境 | 多线程环境 |
实际开发中，除非明确需要线程安全，否则优先使用StringBuilder。
4.2 常用API与使用技巧
StringBuilder和StringBuffer的API几乎完全相同，主要方法包括：
-
append()：追加内容
java复制sb.append("hello").append(123).append('!'); -
insert()：在指定位置插入
java复制sb.insert(5, " world"); -
delete()/deleteCharAt()：删除字符
java复制sb.delete(5, 11); // 删除5-10位置字符 -
reverse()：反转字符串
java复制new StringBuilder("hello").reverse(); // "olleh" -
setLength()：设置长度
java复制sb.setLength(10); // 截断或填充null字符
使用技巧：
- 链式调用：多数方法返回this，支持链式调用
- 预设容量：减少扩容操作，提升性能
- 复用对象：清空后复用（setLength(0)）
4.3 性能优化实践
java复制// 不推荐：每次循环创建新StringBuilder
String result = "";
for (String str : list) {
result += str;
}
// 推荐：复用单个StringBuilder
StringBuilder sb = new StringBuilder();
for (String str : list) {
sb.append(str);
}
String result = sb.toString();
// 更优：预设容量
int totalLength = list.stream().mapToInt(String::length).sum();
StringBuilder sb = new StringBuilder(totalLength);
for (String str : list) {
sb.append(str);
}
String result = sb.toString();
5. 字符串相关高级主题与面试要点
5.1 intern()方法深度解析
intern()方法用于将字符串对象手动添加到常量池中，它的行为随JDK版本有所变化：
- JDK6及之前：将字符串复制到永久代的常量池
- JDK7+：在堆中的字符串对象被常量池引用
使用场景：
java复制String s1 = new String("hello").intern();
String s2 = "hello";
System.out.println(s1 == s2); // true
注意事项：
- 大量使用intern()可能导致内存问题
- 适合重复率高的字符串缓存
- 通常不需要手动调用，编译器会优化字面量
5.2 字符串与编码问题
字符串编码转换是常见需求，需要注意：
java复制// 指定编码转换
String str = "你好";
byte[] utf8Bytes = str.getBytes(StandardCharsets.UTF_8);
String newStr = new String(utf8Bytes, StandardCharsets.UTF_8);
// 常见问题：编码不一致导致乱码
byte[] isoBytes = str.getBytes(StandardCharsets.ISO_8859_1);
String wrongStr = new String(isoBytes, StandardCharsets.UTF_8); // 乱码
最佳实践：
- 明确指定编码（避免依赖平台默认）
- 统一使用UTF-8
- 处理外部数据时验证编码
5.3 字符串与正则表达式
String类内置了正则支持：
java复制// 匹配检查
"123".matches("\\d+"); // true
// 替换所有匹配项
"a1b2c3".replaceAll("\\d", "x"); // "axbxcx"
// 分割字符串
"a,b, c".split("\\s*,\\s*"); // ["a", "b", "c"]
性能提示：
- 频繁使用的Pattern应该预编译
- 复杂正则考虑使用Pattern和Matcher类
5.4 字符串在集合中的使用
作为最常用的HashMap键类型，字符串需要注意：
- 不可变性保证了hashCode()一致性
- 相等的字符串必须有相同hashCode
- 大字符串作为键可能影响性能
- 考虑重写hashCode()的场景
java复制Map<String, Integer> map = new HashMap<>();
map.put("one", 1);
map.put("two", 2);
// 获取时使用相同对象
Integer one = map.get("one"); // 1
// 即使不同对象，只要equals为true也能获取
Integer two = map.get(new String("two")); // 2
6. 字符串处理的最佳实践与常见陷阱
6.1 性能优化要点
-
避免在循环中使用+拼接字符串
- 使用StringBuilder代替
-
合理使用字符串常量池
- 尽量使用字面量而非new String()
- 谨慎使用intern()
-
预设StringBuilder容量
- 减少扩容操作次数
-
重用StringBuilder对象
- 通过setLength(0)清空后复用
-
选择正确的字符串比较方式
- 常量在前："constant".equals(variable)
- 忽略大小写时用equalsIgnoreCase()
6.2 常见问题排查
-
内存泄漏问题
- 大字符串长期持有
- 过度使用intern()
-
编码不一致问题
- 明确指定字符编码
- 处理IO时统一编码
-
正则表达式性能问题
- 避免贪婪匹配
- 预编译Pattern
-
国际化问题
- 注意字符长度计算
- 正确处理unicode
6.3 现代Java中的字符串改进
-
Java 8的字符串去重
- JVM层面的优化
- 减少相同字符串的内存占用
-
Java 11的String新方法
java复制" ".isBlank(); // true (vs isEmpty) "hello".repeat(3); // "hellohellohello" " hello ".strip(); // "hello" (类似trim但unicode感知) -
Java 15的文本块
java复制String html = """ <html> <body> <p>Hello, world</p> </body> </html> """;
6.4 字符串相关工具推荐
-
Apache Commons Lang
- StringUtils工具类
- 提供isEmpty, join等实用方法
-
Guava
- Splitter, Joiner等工具
- 更灵活的字符串处理
-
正则表达式测试工具
- Regex101
- 帮助调试复杂正则
-
编码转换工具
- 确保编码转换正确性
- 排查乱码问题
在实际项目中，合理选择工具类可以显著提高字符串处理的效率和代码可读性，但也要注意避免过度依赖外部库带来的维护成本。