从字面量到字节数组:深入解析String、StringBuilder、StringBuffer的机制、性能与实战
在Java中,字符串是java.lang.String类的实例,属于不可变(immutable)的字符序列。其核心特性包括:
Serializable接口char[](Java 9+为byte[] + 编码标志)例如:String s = "hello"; 实际创建的是一个指向常量池中"hello"的引用。而new String("hello")会在堆中创建新对象,并可能在常量池中驻留副本(若不存在)。
字符串的不可变性设计带来三大核心优势:
hashCode()可缓存,避免重复计算但其代价是频繁修改时性能低下,需搭配StringBuilder或StringBuffer使用。
| 创建方式 | 内存位置 | 是否复用常量池 | 适用场景 |
|---|---|---|---|
String s = "abc"; |
字符串常量池(JDK 7+为堆内) | 是 | 固定值、常量、重复使用 |
String s = new String("abc"); |
堆(常量池可能驻留) | 否(除非池中无此值) | 需强制新建对象时(如反射、反序列化) |
String s = new StringBuilder("abc").toString(); |
堆 | 否 | 动态构建后需不可变副本 |
String s = String.valueOf(obj); |
堆(若obj为String则直接返回) | 视obj而定 | 通用转换方法,处理null安全 |
以下代码验证对象唯一性:
String a = "test";
String b = "test";
String c = new String("test");
String d = c.intern();
System.out.println(a == b); // true:同一常量池引用
System.out.println(a == c); // false:堆 vs 常量池
System.out.println(a == d); // true:intern()返回池中引用
System.out.println(c == d); // false:c仍为堆对象
Java提供多种构造方式,核心构造器包括:
String():空字符串String(byte[] bytes):使用平台默认字符集解码String(byte[] bytes, Charset charset):指定编码解码String(char[] value):从字符数组构造String(String original):复制字符串⚠️ 注意:直接使用new String(byte[], "UTF-8")在JDK 11后已弃用,应改用StandardCharsets.UTF_8。
字符串提供以下核心访问方法:
| 方法 | 说明 | 返回值 | 异常 |
|---|---|---|---|
charAt(int index) |
获取指定索引字符 | char |
StringIndexOutOfBoundsException |
codePointAt(int index) |
获取指定索引的Unicode码点(支持补充字符) | int |
StringIndexOutOfBoundsException |
length() |
返回字符数量 | int |
无 |
isEmpty() |
判断是否为空 | boolean |
无 |
遍历示例(推荐使用码点遍历以支持Emoji等补充字符):
String text = "Java🚀";
for (int i = 0; i < text.length(); ) {
int cp = text.codePointAt(i);
System.out.print(Character.isBmpCodePoint(cp)
? String.valueOf((char)cp)
: new String(Character.toChars(cp)));
i += Character.charCount(cp);
}
// 输出:Java🚀(完整显示)
字符串常量池(String Pool)是方法区(JDK 7前)或元空间(JDK 8+)中的特殊区域,用于存储唯一字符串实例。其演进如下:
常量池的自动驻留机制:当使用字面量创建字符串时,JVM会检查池中是否已存在等值字符串,若存在则返回引用,否则创建新实例并驻留。
String.intern()方法的作用是将当前字符串实例注册到常量池中,并返回池中等值字符串的引用。其行为如下:
经典案例:统计大文件中唯一单词数
Set words = new HashSet<>();
try (BufferedReader br = Files.newBufferedReader(path)) {
String line;
while ((line = br.readLine()) != null) {
for (String word : line.split("\\s+")) {
words.add(word.intern()); // 强制驻留,避免重复对象
}
}
}
⚠️ 风险提示:滥用intern()可能导致常量池膨胀,引发OutOfMemoryError: Metaspace。建议仅对低基数高重复场景使用(如状态码、枚举值)。
编译器会对字符串拼接进行优化:当拼接全为编译期常量时,会合并为单一常量字面量。
String a = "Hello" + "World"; // 编译后等同于 String a = "HelloWorld";
String b = "Hello";
String c = b + "World";
System.out.println(a == "HelloWorld"); // true
System.out.println(c == "HelloWorld"); // false
Java 8中,javac使用StringConcatFactory,但仅当所有操作数为final常量时才内联优化。
正确使用比较方法是避免逻辑错误的关键:
| 方法 | 说明 | 空值处理 | 性能 |
|---|---|---|---|
equals(Object anObject) |
内容严格相等 | 安全(this为null则NPE) | O(n) |
equalsIgnoreCase(String anotherString) |
忽略大小写比较 | 安全 | O(n) |
compareTo(String anotherString) |
字典序比较 | 安全 | O(min(m,n)) |
contentEquals(CharSequence cs) |
与任意CharSequence比较 | 安全 | O(n) |
Objects.equals(a, b) |
静态方法,支持null | 安全(a/b任一为null返回false) | O(n) |
推荐实践:
Objects.equals(str1, str2)避免NullPointerException"literal".equals(variable)防NPEcompareTo,非逻辑判断时避免支持正向/反向、子串/字符/码点搜索:
indexOf(String str):首次出现位置lastIndexOf(String str):末次出现位置startsWith(String prefix):前缀匹配endsWith(String suffix):后缀匹配contains(CharSequence s):是否包含子串matches(String regex):全匹配正则示例:解析URL路径参数
String url = "https://api.example.com/users?name=java&lang=strings";
int qPos = url.indexOf('?');
if (qPos > 0) {
String query = url.substring(qPos + 1);
String[] pairs = query.split("&");
for (String pair : pairs) {
int eqPos = pair.indexOf('=');
if (eqPos > 0) {
String key = pair.substring(0, eqPos);
String value = pair.substring(eqPos + 1);
System.out.printf("参数: %s = %s%n", key, value);
}
}
}
所有修改方法均返回新对象,核心方法包括:
| 方法 | 功能 | 示例 |
|---|---|---|
substring(int begin, int end) |
截取子串 | "hello".substring(1,4) → "ell" |
replace(CharSequence target, CharSequence replacement) |
替换所有匹配项 | "a.b.c".replace('.', '/') → "a/b/c" |
replaceAll(String regex, String replacement) |
正则替换 | "123-456".replaceAll("\\d", "*") → "***-***" |
trim() |
去除首尾空白 | " \t\nhello \r\n ".trim() → "hello" |
strip() (Java 11+) |
Unicode感知去空白 | "\u2007hello\u2007".strip() → "hello" |
join(delimiter, elements) |
连接字符串 | String.join("-", "a","b","c") → "a-b-c" |
注意:replace与replaceAll行为差异极大——前者为字面量替换,后者为正则替换。错误使用可能导致安全漏洞(如SQL注入)。
Java提供三种格式化方案:
String.format(String format, Object... args):C风格格式化System.out.printf:格式化输出MessageFormat:国际化消息模板格式化占位符示例:
String.format("用户%s在%s登录,IP:%s", "张三", "2023-08-01", "192.168.1.1")
// → "用户张三在2023-08-01登录,IP:192.168.1.1"
String.format("金额:%,.2f元", 1234567.89)
// → "金额:1,234,567.89元"
String.format("日期:%1$tm-%1$td-%1$tY", new Date())
// → "日期:08-01-2023"(支持重复参数)
性能对比:String.format比StringBuilder慢约30%,适合低频调用场景。
不同拼接方式的性能差异可达百倍:
| 方式 | JDK版本 | 时间复杂度 | 内存峰值 |
|---|---|---|---|
str += "x" |
任意 | O(n²) | O(n²) |
new StringBuilder().append() |
任意 | O(n) | O(n) |
String.join() |
Java 8+ | O(n) | O(n) |
String.format() |
任意 | O(n) | O(n) |
测试数据(10万次拼接):
| 方法 | 耗时(ms) | GC次数 |
|---|---|---|
+= |
12500 | 420 |
StringBuilder |
120 | 5 |
String.join |
180 | 8 |
关键技巧:
new StringBuilder(1024)避免扩容sb.append("a").append("b").toString()for(String s : list) str += s;会创建大量临时对象反模式示例:
// 每次循环创建新StringBuilder
for (String s : list) {
result += s; // 等价于 new StringBuilder(result).append(s).toString()
}
正确写法:
StringBuilder sb = new StringBuilder(list.size() * 16); // 预估容量
for (String s : list) sb.append(s);
String result = sb.toString();
String的不可变性使其天然线程安全,可安全地在多线程环境中共享。例如:
HashMap键:哈希值稳定,避免并发修改导致的哈希冲突对比StringBuilder(非线程安全)与StringBuffer(线程安全但性能低):
| 类 | 线程安全 | 性能 | 适用场景 |
|---|---|---|---|
String |
是 | 高(只读) | 固定文本 |
StringBuilder |
否 | 最高 | 单线程构建 |
StringBuffer |
是 | 低(同步开销) | 多线程构建 |
注意:Java 5后StringBuilder已完全取代StringBuffer,除非显式需要同步。
虽然字符串池本身线程安全,但滥用intern()可能导致:
解决方案:
-XX:StringTableSize调整)java.lang.String.intern GC事件典型错误:
String a = new String("test");
String b = new String("test");
System.out.println(a == b); // false!但期望true
正确做法:
Objects.equals(a, b):通用安全方案a.equals(b):已知a非null时错误示例:
String text = "a.b.c";
String[] parts = text.split("."); // 错误!点号是正则元字符
正确写法:
String[] parts = text.split("\\."); // 或 text.split(Pattern.quote("."));
Java正则特殊字符:. * + ? ^ $ { } [ ] ( ) | \
错误示例:
String s = new String(bytes); // 使用平台默认编码(可能与数据编码不符)
正确做法:
String s = new String(bytes, StandardCharsets.UTF_8);
特别注意:网络传输、文件读写、数据库交互时必须显式指定编码。
trim()仅移除ASCII空白(0x0000~0x0020),对全角空格(\u3000)、不间断空格(\u00A0)无效。
Java 11+推荐:
String clean = text.strip(); // Unicode-aware
或使用正则:
String clean = text.replaceAll("^\\s+|\\s+$", "");
实现手机号、身份证号、邮箱的自动脱敏:
public static String maskPhone(String phone) {
return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
}
// 输入:13812345678 → 输出:138****5678
public static String maskIdCard(String id) {
return id.replaceAll("(\\d{6})\\d{8}(\\d{4})", "$1********$2");
}
// 输入:110101199003072316 → 输出:110101********2316
生产环境建议使用Apache Commons Text的StringEscapeUtils或自定义规则引擎。
防止JSON注入的校验方案:
public static boolean isValidJson(String json) {
if (json == null || json.trim().isEmpty()) return false;
try {
new JsonParser().parse(json);
return true;
} catch (JsonSyntaxException e) {
return false;
}
}
补充:对用户输入的JSON字段值进行二次转义处理,避免XSS攻击。
日志中自动脱敏的AOP切面:
@Aspect
@Component
public class SensitiveLogAspect {
@Around("@annotation(sensitiveLog)")
public Object maskSensitiveData(ProceedingJoinPoint joinPoint, SensitiveLog sensitiveLog) throws Throwable {
Object result = joinPoint.proceed();
if (result instanceof String) {
String masked = ((String) result)
.replaceAll("(?<=.{3})\\d(?=.{4})", "*") // 手机号
.replaceAll("(?<=.{6})\\w+(?=\\@)", "****"); // 邮箱
return masked;
}
return result;
}
}
A:JDK 8中默认池大小为6001,可通过-XX:StringTableSize=10000调整。过大浪费内存,过小增加哈希冲突。
A:仅当所有操作数为编译期常量时(字面量或final常量)。例如:final String a = "a"; String b = a + "b";会被优化为"ab"。
A:str == null || str.isEmpty()是最佳实践。避免使用str.length() == 0(多一次方法调用)。
A:底层从char[]改为byte[] + 编码标志,节省50%内存。对开发者透明,但影响反射和某些底层操作。
© 2023 java字符串 | www.xservx.com