1. 深入理解String类的基础构造
在Java开发中，String类是最基础也是最常用的类之一。作为不可变字符序列，String提供了多种构造方式，每种构造方法都有其特定的使用场景和内部实现原理。
1.1 空字符串构造
最基本的构造方式是创建一个空字符串：
java复制String str = new String();
这种构造方式会创建一个内容为""（空字符串）的String对象。在实际开发中，我们更常用简写形式：
java复制String str = "";
这两种方式看似相同，但实际上存在细微差别。第一种方式显式调用了构造函数，而第二种方式利用了Java的字符串池机制。当我们需要一个空字符串作为初始值时，第二种方式更为高效。
1.2 基于字符数组的构造
String类提供了从字符数组构造字符串的能力：
java复制char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArray);
这种构造方式特别适用于需要动态构建字符串的场景。值得注意的是，构造后的String对象与原始字符数组是相互独立的，修改字符数组不会影响已创建的String对象。
1.3 带偏移量的构造
对于大型字符数组，我们可以指定起始位置和长度来构造字符串：
java复制char[] largeArray = {'A', 'B', 'C', 'D', 'E', 'F'};
String str = new String(largeArray, 2, 3); // 结果为"CDE"
这种构造方式在处理子字符串时非常高效，因为它避免了不必要的数组复制操作。
1.4 基于字节数组的构造
在处理二进制数据或网络传输时，我们经常需要从字节数组构造字符串：
java复制byte[] byteArray = {72, 101, 108, 108, 111};
String str = new String(byteArray, StandardCharsets.UTF_8);
这里必须指定字符编码，否则会使用平台默认编码，可能导致乱码问题。在实际开发中，明确指定字符编码是一个好习惯。
2. String类的容量操作与性能优化
String类虽然不可变，但了解其容量相关操作对于编写高效代码至关重要。这些操作主要影响字符串构建过程中的性能表现。
2.1 长度与容量
String类提供了两个获取长度的方法：
java复制String str = "Hello";
int length = str.length(); // 返回5
int size = str.length(); // 同样返回5
在Java中，length()和size()方法实际上是一样的，都返回字符串中Unicode字符的数量。与C++不同，Java字符串不以'\0'结尾，所以不需要考虑null终止符的问题。
2.2 字符串构建优化
虽然String是不可变的，但在构建字符串时，我们可以通过一些技巧提高性能：
java复制// 不推荐的拼接方式 - 会产生多个临时对象
String result = "";
for (int i = 0; i < 100; i++) {
result += i; // 每次拼接都会创建新对象
}
// 推荐使用StringBuilder
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 100; i++) {
builder.append(i);
}
String optimizedResult = builder.toString();
StringBuilder内部使用可变字符数组，可以显著减少内存分配和复制的次数。根据测试，当拼接次数超过5次时，StringBuilder的性能优势就开始显现。
2.3 字符串判空与清理
检查字符串是否为空有多种方式：
java复制String str = "";
boolean isEmpty1 = str.isEmpty(); // true
boolean isEmpty2 = str.length() == 0; // true
boolean isEmpty3 = str.equals(""); // true
第一种方式是最直观的，性能也最佳。需要注意的是，如果字符串可能为null，应该先进行null检查：
java复制if (str == null || str.isEmpty()) {
// 处理空或null情况
}
3. 字符串访问与遍历技巧
String类提供了多种访问和遍历其内容的方式，每种方式都有适用的场景。
3.1 字符访问
最基本的字符访问方式是charAt()方法：
java复制String str = "Java";
char firstChar = str.charAt(0); // 'J'
需要注意的是，如果索引越界会抛出StringIndexOutOfBoundsException。安全的使用方式应该先检查长度：
java复制int index = 4;
if (index >= 0 && index < str.length()) {
char ch = str.charAt(index);
}
3.2 字符数组转换
有时我们需要将字符串转换为字符数组进行处理：
java复制String str = "Hello";
char[] chars = str.toCharArray();
// 修改字符数组
chars[0] = 'h';
// 转换回字符串
String modifiedStr = new String(chars); // "hello"
这种方法虽然可以"修改"字符串内容，但实际上创建了新的String对象。对于频繁修改的场景，应该考虑使用StringBuilder。
3.3 使用字符迭代器
Java 8引入了字符流处理方式：
java复制"Java".chars().forEach(c -> System.out.print((char)c));
这种方式适合函数式编程风格，可以方便地结合其他流操作。但要注意，chars()方法返回的是IntStream，需要转换为char类型。
3.4 子字符串提取
substring()方法可以提取字符串的一部分：
java复制String str = "HelloWorld";
String sub1 = str.substring(5); // "World"
String sub2 = str.substring(0, 5); // "Hello"
需要注意的是，substring()创建的新字符串会共享原始字符串的字符数组（在Java 7之前），这可能导致内存泄漏。从Java 7开始，substring()总是创建新的字符数组。
4. 字符串修改操作与实际应用
虽然String是不可变的，但Java提供了丰富的字符串操作方法，可以创建修改后的新字符串。
4.1 拼接与追加
字符串拼接是最常见的操作：
java复制String s1 = "Hello";
String s2 = "World";
String combined = s1 + " " + s2; // "Hello World"
对于简单的拼接，使用+操作符即可。但在循环或多次拼接时，应该使用StringBuilder：
java复制StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World");
String result = sb.toString();
4.2 大小写转换
String提供了简单的大小写转换方法：
java复制String original = "Java";
String upper = original.toUpperCase(); // "JAVA"
String lower = original.toLowerCase(); // "java"
这些方法会考虑本地化设置，如果需要忽略本地化规则，可以指定Locale：
java复制String turkish = "ı".toUpperCase(Locale.ENGLISH); // "I"
4.3 空白字符处理
Java 11引入了更强大的空白字符处理方法：
java复制String str = " Hello ";
String trimmed = str.strip(); // "Hello" (支持Unicode空白)
String trimmedStart = str.stripLeading(); // "Hello "
String trimmedEnd = str.stripTrailing(); // " Hello"
与传统的trim()方法相比，strip()系列方法能处理更多类型的空白字符。
4.4 字符串替换
String提供了多种替换方法：
java复制String str = "apple banana apple";
String replaced = str.replace("apple", "orange"); // "orange banana orange"
String regexReplaced = str.replaceAll("a.e", "***"); // "***ple b***nana ***ple"
replace()进行简单文本替换，而replaceAll()支持正则表达式。注意正则表达式替换的性能开销较大。
5. 字符串搜索与比较
高效的字符串搜索和比较是许多算法的核心，String类提供了丰富的方法支持这些操作。
5.1 基础搜索方法
indexOf()系列方法可以查找字符或子字符串：
java复制String str = "Hello World";
int pos1 = str.indexOf('o'); // 4
int pos2 = str.indexOf('o', 5); // 7 (从位置5开始找)
int pos3 = str.indexOf("World"); // 6
int notFound = str.indexOf("Java"); // -1
对应的lastIndexOf()方法从字符串末尾开始搜索：
java复制int lastPos = str.lastIndexOf('o'); // 7
5.2 内容比较
字符串比较有多种方式：
java复制String s1 = "Java";
String s2 = "java";
boolean eq1 = s1.equals(s2); // false (区分大小写)
boolean eq2 = s1.equalsIgnoreCase(s2); // true
int cmp = s1.compareTo(s2); // 负数 (字典序比较)
在比较用户输入或配置值时，equalsIgnoreCase()通常很有用。compareTo()方法常用于排序。
5.3 开头结尾检查
startsWith()和endsWith()方法可以方便地检查字符串前缀和后缀：
java复制String filename = "config.xml";
boolean isXml = filename.endsWith(".xml"); // true
boolean isConfig = filename.startsWith("config"); // true
这些方法常用于文件处理、URL路由等场景。
5.4 正则表达式匹配
对于复杂的模式匹配，可以使用正则表达式：
java复制String email = "user@example.com";
boolean isValid = email.matches("^[\\w-.]+@([\\w-]+\\.)+[\\w-]{2,4}$");
matches()方法检查整个字符串是否匹配正则表达式。如果只需要查找匹配部分，可以使用Pattern和Matcher类。
6. 字符串分割与连接
字符串的分割和连接是日常开发中的常见需求，String类提供了多种方法支持这些操作。
6.1 简单分割
split()方法是最常用的字符串分割方法：
java复制String csv = "apple,banana,orange";
String[] fruits = csv.split(","); // ["apple", "banana", "orange"]
对于简单的分隔符，这种方法很有效。但如果分隔符是正则表达式元字符，需要转义：
java复制String line = "a|b|c";
String[] parts = line.split("\\|"); // 需要转义
6.2 复杂分割
split()方法支持限制分割次数：
java复制String data = "one:two:three:four";
String[] firstTwo = data.split(":", 2); // ["one", "two:three:four"]
这在处理部分分割时很有用。Java 8还引入了splitAsStream()方法，可以返回流对象。
6.3 字符串连接
Java 8引入了String.join()方法，简化了字符串连接：
java复制String[] words = {"Hello", "World"};
String sentence = String.join(" ", words); // "Hello World"
对于更复杂的连接需求，可以使用StringJoiner类：
java复制StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("one").add("two").add("three");
String result = joiner.toString(); // "[one, two, three]"
6.4 性能考虑
当处理大量字符串分割和连接操作时，性能变得重要：
java复制// 低效的分割方式
for (String line : largeText.split("\n")) {
// 处理每一行
}
// 更高效的方式
try (BufferedReader reader = new BufferedReader(new StringReader(largeText))) {
String line;
while ((line = reader.readLine()) != null) {
// 处理每一行
}
}
对于大文本，基于流的方式可以避免一次性加载所有内容到内存。
7. 字符串格式化与模板
现代Java提供了多种字符串格式化和模板技术，使字符串构建更加灵活和可读。
7.1 传统格式化
String.format()方法提供了类似C语言的格式化功能：
java复制String formatted = String.format("Hello, %s! You have %d messages.", "Alice", 5);
格式化说明符支持各种数据类型和格式选项：
java复制double price = 19.99;
String priceStr = String.format("Price: $%.2f", price); // "Price: $19.99"
7.2 文本块（Java 15+）
Java 15引入了文本块语法，简化了多行字符串的编写：
java复制String html = """
<html>
<body>
<h1>Hello, %s!</h1>
</body>
</html>
""".formatted("World");
文本块保留了格式，同时提供了formatted()方法进行插值。
7.3 消息格式化
对于国际化应用，MessageFormat更合适：
java复制String pattern = "On {0,date,long}, {1} sent you a message.";
String message = MessageFormat.format(pattern, new Date(), "Alice");
这种方式支持本地化的日期、数字格式，适合多语言应用。
7.4 性能优化技巧
频繁的字符串格式化可能影响性能，可以考虑预编译格式：
java复制// 预编译格式
static final MessageFormat MF = new MessageFormat("Hello, {0}!");
// 重复使用
String greeting = MF.format(new Object[]{"Alice"});
对于高频率使用的格式，预编译可以显著提高性能。
8. 字符串编码与二进制转换
正确处理字符串编码是避免乱码问题的关键，特别是在网络传输和文件处理中。
8.1 编码与解码
String和byte[]之间的转换需要明确指定字符编码：
java复制String str = "你好";
byte[] utf8Bytes = str.getBytes(StandardCharsets.UTF_8);
String decodedStr = new String(utf8Bytes, StandardCharsets.UTF_8);
永远不要使用无参数的getBytes()方法，它会使用平台默认编码，可能导致不一致的行为。
8.2 Base64编码
Java 8引入了Base64编码支持：
java复制String original = "Hello World";
String encoded = Base64.getEncoder().encodeToString(original.getBytes());
String decoded = new String(Base64.getDecoder().decode(encoded));
Base64常用于编码二进制数据以便在文本协议中传输。
8.3 字符集检测
当编码未知时，可以使用第三方库如juniversalchardet来检测：
java复制byte[] data = getSomeBytes();
UniversalDetector detector = new UniversalDetector(null);
detector.handleData(data, 0, data.length);
detector.dataEnd();
String encoding = detector.getDetectedCharset();
这种检测并非100%准确，但能处理大多数常见情况。
8.4 性能考虑
大量字符串编码转换可能成为性能瓶颈：
java复制// 低效方式 - 每次创建新的Charset对象
byte[] bytes = str.getBytes("UTF-8");
// 高效方式 - 重用Charset实例
private static final Charset UTF_8 = Charset.forName("UTF-8");
byte[] optimizedBytes = str.getBytes(UTF_8);
重用Charset实例可以避免重复的编码查找开销。
9. 字符串池与内存优化
理解Java字符串池机制对于编写高效、内存友好的代码至关重要。
9.1 字符串字面量
直接使用双引号创建的字符串会进入字符串池：
java复制String s1 = "Java";
String s2 = "Java";
boolean sameRef = (s1 == s2); // true (引用相同)
字符串池避免了重复字符串的内存开销，但仅适用于编译期已知的字符串。
9.2 显式入池
可以使用intern()方法将运行时创建的字符串加入池中：
java复制String s1 = new String("Java").intern();
String s2 = "Java";
boolean sameRef = (s1 == s2); // true
但过度使用intern()可能导致PermGen或Metaspace内存问题，应谨慎使用。
9.3 内存考虑
大量动态创建的字符串可能消耗大量内存：
java复制// 可能的内存问题
List<String> strings = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
strings.add(new String("prefix" + i)); // 创建大量对象
}
// 优化方案
List<String> optimized = new ArrayList<>();
String prefix = "prefix";
for (int i = 0; i < 1_000_000; i++) {
optimized.add(prefix + i); // 利用编译器优化
}
注意字符串拼接在循环中的性能影响。
9.4 大字符串处理
处理超大字符串时，应考虑分块处理：
java复制String hugeString = getHugeString();
try (Scanner scanner = new Scanner(hugeString)) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
// 逐行处理
}
}
这种方式可以避免将整个大字符串加载到内存中。
10. 字符串安全与防御性编程
字符串处理中的安全问题常常被忽视，但可能导致严重的安全漏洞。
10.1 敏感信息处理
敏感信息如密码不应以String形式存储：
java复制// 不安全的方式
String password = getUserInput();
// password可能长期存在于内存中
// 更安全的方式
char[] password = getPasswordInput();
// 使用后立即清除
Arrays.fill(password, '\0');
String是不可变的，无法从内存中主动清除，而char[]可以手动清空。
10.2 SQL注入防护
拼接SQL语句是常见的安全风险：
java复制// 危险的拼接方式
String query = "SELECT * FROM users WHERE name = '" + name + "'";
// 使用预编译语句
PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE name = ?");
stmt.setString(1, name);
永远不要直接拼接用户输入到SQL语句中。
10.3 日志安全
日志中的敏感信息可能泄露：
java复制// 不安全
log.info("User logged in with password: " + password);
// 安全方式
log.info("User logged in (password hidden)");
确保日志中不记录密码、令牌等敏感信息。
10.4 输入验证
所有外部输入都应验证：
java复制String userInput = request.getParameter("input");
if (userInput == null || userInput.length() > MAX_LENGTH) {
throw new ValidationException("Invalid input");
}
// 进一步验证内容
if (!userInput.matches("^[a-zA-Z0-9]+$")) {
throw new ValidationException("Invalid characters");
}
防御性编程可以防止许多安全问题。