Java String 类详解

在 Java 编程中，String类是最常用的类之一，用于处理文本数据。本文将深入解析 Java String 类的核心特性、内存管理、常用操作及最佳实践，帮助开发者全面掌握这一基础而重要的类。

一、String 类的核心特性

1. 不可变性（Immutable）

String 对象一旦创建，其值不可更改。这是通过内部的private final char[] value数组实现的：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];
    // ...其他成员
}

• 不可变性的优势：线程安全、缓存哈希码、安全传递参数
• 常见误解：str = "new value"并非修改原对象，而是创建新对象并赋值

2. 常量池（String Pool）

Java 为 String 提供了特殊的内存区域 —— 字符串常量池，用于存储编译期已知的字符串字面量：

String s1 = "hello";  // 常量池中的对象
String s2 = "hello";  // 复用常量池中的对象
System.out.println(s1 == s2);  // 输出true，引用相同对象

String s3 = new String("hello");  // 堆中的新对象
System.out.println(s1 == s3);  // 输出false，引用不同对象

 

• intern () 方法：手动将字符串添加到常量池

String s4 = s3.intern();  // 将s3的值放入常量池
System.out.println(s1 == s4);  // 输出true

 

3. 继承结构

String类实现了CharSequence、Serializable和Comparable<String>接口：

• CharSequence：提供字符序列的通用操作
• Serializable：支持对象序列化
• Comparable<String>：支持字符串比较

二、字符串创建与内存管理

1. 不同创建方式的内存分配

// 方式1：字面量创建（推荐）
String s1 = "hello";  // 常量池

// 方式2：new关键字创建
String s2 = new String("hello");  // 堆内存

// 方式3：构造函数传入char[]
char[] chars = {'h', 'e', 'l', 'l', 'o'};
String s3 = new String(chars);  // 堆内存，避免常量池重复

// 方式4：字符串拼接
String s4 = "hel" + "lo";  // 编译期优化为"hello"，常量池
String s5 = s1 + " world";  // 运行时拼接，堆内存

 

2. 字符串拼接性能对比

// 循环中使用+拼接（性能差）
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;  // 每次循环创建新String对象
}

// 使用StringBuilder（性能优）
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);  // 仅创建一个StringBuilder对象
}
String result2 = sb.toString();

 

三、String 类的常用方法

1. 基础操作

String str = "Hello, World!";

// 长度获取
int length = str.length();  // 13

// 字符访问
char c = str.charAt(4);  // 'o'

// 子串提取
String sub = str.substring(7, 12);  // "World"

// 转换大小写
String upper = str.toUpperCase();  // "HELLO, WORLD!"
String lower = str.toLowerCase();  // "hello, world!"

 

2. 查找与比较

// 包含检查
boolean contains = str.contains("World");  // true

// 前缀/后缀检查
boolean startsWith = str.startsWith("Hello");  // true
boolean endsWith = str.endsWith("!");  // true

// 位置查找
int index = str.indexOf("o");  // 4（首次出现位置）
int lastIndex = str.lastIndexOf("o");  // 7（最后出现位置）

// 比较
boolean equals = str.equals("Hello, World!");  // true
boolean equalsIgnoreCase = str.equalsIgnoreCase("hello, world!");  // true
int compareTo = str.compareTo("Hello, Java!");  // 正数（按字典序比较）

 

3. 格式化与替换

// 格式化
String formatted = String.format("Name: %s, Age: %d", "Alice", 25);  // "Name: Alice, Age: 25"

// 替换
String replaced = str.replace("World", "Java");  // "Hello, Java!"

// 正则替换
String numbers = "a1b2c3";
String onlyLetters = numbers.replaceAll("\\d", "");  // "abc"

 

4. 分割与连接

// 分割
String[] parts = "a,b,c".split(",");  // ["a", "b", "c"]

// 连接
String joined = String.join("-", "Java", "Python", "C++");  // "Java-Python-C++"

 

四、字符串编码与转换

1. 字节数组与字符串转换

// 字符串转字节数组
String text = "你好，世界";
byte[] bytesUTF8 = text.getBytes("UTF-8");  // UTF-8编码
byte[] bytesGBK = text.getBytes("GBK");  // GBK编码

// 字节数组转字符串
String decodedUTF8 = new String(bytesUTF8, "UTF-8");  // "你好，世界"
String decodedGBK = new String(bytesGBK, "GBK");  // "你好，世界"

 

2. 字符序列转换

// StringBuilder转String
StringBuilder sb = new StringBuilder("Java");
String strFromBuilder = sb.toString();  // "Java"

// String转char[]
char[] charArray = strFromBuilder.toCharArray();  // ['J', 'a', 'v', 'a']

 

五、性能优化与最佳实践

1. 避免在循环中使用 + 拼接

// 低效方式
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;  // 每次循环创建新对象
}

// 高效方式
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);  // 推荐使用
}

 

2. 使用 intern () 优化内存

// 大量重复字符串场景
String[] names = new String[1000000];
for (int i = 0; i < names.length; i++) {
    names[i] = "重复字符串示例".intern();  // 节省内存
}

 

3. 优先使用 StringJoiner（Java 8+）

 

// 字符串连接
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("Apple").add("Banana").add("Cherry");
String result = joiner.toString();  // "[Apple, Banana, Cherry]"

 

4. 正则表达式性能注意

// 编译一次，多次使用
Pattern pattern = Pattern.compile("\\d+");  // 预编译正则
Matcher matcher = pattern.matcher("a123b456");
while (matcher.find()) {
    System.out.println(matcher.group());  // 输出123和456
}

 

六、常见面试问题

1. String 为什么是不可变的？
   • 安全考虑：避免被恶意修改
   • 线程安全：无需同步
   • 支持哈希码缓存：提高性能
2. String vs StringBuilder vs StringBuffer
   • String：不可变，适合少量操作
   • StringBuilder：可变，非线程安全，性能高
   • StringBuffer：可变，线程安全，性能低
3. 如何比较两个字符串？equals () vs ==
   • equals()：比较字符串内容
   • ==：比较引用地址
4. 字符串常量池的作用
   • 节省内存，避免重复创建相同字符串
   • 提高性能，快速定位字符串

七、总结

Java String 类凭借其不可变性、常量池机制和丰富的 API，成为处理文本数据的核心组件。开发者应理解其内存管理机制，合理选择字符串操作方式，避免常见的性能陷阱。在日常编程中，建议：

• 优先使用字面量创建字符串
• 在循环中使用 StringBuilder 进行拼接
• 对大量重复字符串使用 intern () 优化
• 注意字符串编码转换的一致性

通过深入理解 String 类的设计理念和实现细节，开发者可以编写出更高效、更安全的 Java 代码。