4.2 字符串处理

文档摘要

Java 字符串处理完全指南：String、StringBuilder 与正则表达式核心摘要：Java 字符串处理是日常开发中最频繁的操作之一。深入理解、、的底层原理及常用 API，不仅能有效避免内存溢出与性能瓶颈，还能提升代码的优雅度。本文全面解析 Java 字符串处理的核心机制，涵盖对象创建、不可变性、高效拼接、编码转换及正则表达式等关键技术，为开发者提供一份详尽的实战指南。 4.2 Java 字符串处理核心机制在 Java 编程语言中，字符串（String）是表示文本数据的核心引用类型。针对不同的业务场景，Java 提供了、、以及等多种处理方式。合理选择字符串处理工具，是优化系统性能与内存占用的关键。 4.2.

Java 字符串处理完全指南：String、StringBuilder 与正则表达式

核心摘要：Java 字符串处理是日常开发中最频繁的操作之一。深入理解 String、StringBuilder、StringBuffer 的底层原理及常用 API，不仅能有效避免内存溢出与性能瓶颈，还能提升代码的优雅度。本文全面解析 Java 字符串处理的核心机制，涵盖对象创建、不可变性、高效拼接、编码转换及正则表达式等关键技术，为开发者提供一份详尽的实战指南。

4.2 Java 字符串处理核心机制

在 Java 编程语言中，字符串（String）是表示文本数据的核心引用类型。针对不同的业务场景，Java 提供了 String、StringBuilder、StringBuffer 以及 StringJoiner 等多种处理方式。合理选择字符串处理工具，是优化系统性能与内存占用的关键。

4.2.1 String 类：不可变字符序列

String 类代表不可变的字符序列。这意味着一旦创建了一个 String 对象，其内部包含的字符数据就无法被修改。任何看似修改 String 对象的操作（如拼接、替换），实际上都会在内存中创建并返回一个新的 String 对象。

4.2.1.1 String 对象的创建方式

在 Java 中，创建 String 对象主要有以下几种方式，它们在内存分配上存在显著差异：


public class StringCreation {
    public static void main(String[] args) {
        // 1. 使用字符串字面量（推荐）
        String str1 = "Hello World";
        
        // 2. 使用 new 关键字
        String str2 = new String("Hello World");
        
        // 3. 使用字符数组
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
        String str3 = new String(charArray);
        
        System.out.println("str1: " + str1); // 输出: str1: Hello World
        System.out.println("str2: " + str2); // 输出: str2: Hello World
        System.out.println("str3: " + str3); // 输出: str3: Hello
    }
}

内存分配机制解析：

字符串字面量：这是创建 String 对象最常见且最高效的方式。Java 字符串字面量存储在字符串常量池（String Pool） 中。如果池中已经存在相同内容的字符串，JVM 会直接返回池中已有对象的引用，避免重复创建，从而节省内存。
new String()：使用 new 关键字强制在堆内存（Heap） 中创建一个新的 String 对象，即使字符串的内容与常量池中的字符串完全相同。这会导致额外的内存开销。
字符数组/字节数组：可以通过传入 char[] 或 byte[] 来构建新的字符串对象，常用于底层数据转换。

4.2.1.2 String 类的常用方法

String 类提供了丰富的 API 用于文本操作。以下为核心常用方法及示例：

length()：返回字符串的字符数量。


String str = "Java";
int length = str.length(); // length = 4
System.out.println("Length: " + length);

charAt(int index)：返回指定索引处的字符（索引从 0 开始）。
```
String str = "Java";
char ch = str.charAt(0); // ch = 'J'
```

substring(int beginIndex) / substring(int beginIndex, int endIndex)：截取子字符串。endIndex 不包含在内。


String str = "HelloWorld";
String subStr1 = str.substring(5); // "World"
String subStr2 = str.substring(0, 5); // "Hello"

concat(String str) 与 + 运算符：字符串拼接。实际开发中通常使用 + 或 +=，编译器会自动将其优化为 StringBuilder 操作。


String str1 = "Hello";
String str2 = "World";
String result = str1.concat(str2); // "HelloWorld"
String result2 = str1 + str2;      // "HelloWorld" (更简洁)

equals(Object obj) 与 equalsIgnoreCase(String str)：字符串内容比较。前者区分大小写，后者忽略大小写。注意：比较字符串内容务必使用 equals，而非 ==。
```
String str1 = "Java";
String str2 = "java";
boolean isEqual = str1.equals(str2); // false
boolean isIgnoreCase = str1.equalsIgnoreCase(str2); // true
```
compareTo(String str)：按字典顺序比较两个字符串，返回整数差值。
indexOf(String str) 与 lastIndexOf(String str)：查找子串首次或最后一次出现的索引位置，未找到返回 -1。
replace(CharSequence target, CharSequence replacement)：替换所有匹配的目标字符序列。
toLowerCase() 与 toUpperCase()：大小写转换。
trim() 与 strip() (Java 11+)：去除首尾空白字符。strip() 支持更广泛的 Unicode 空白字符。

split(String regex)：根据正则表达式将字符串拆分为数组。


String str = "apple,banana,orange";
String[] fruits = str.split(","); // ["apple", "banana", "orange"]

startsWith(String prefix)、endsWith(String suffix)、contains(CharSequence s)：前缀、后缀及包含关系判断。

4.2.1.3 String 的不可变性与内存机制

String 对象的不可变性（Immutability）是其最核心的设计特性。每次对 String 对象进行修改时，都会创建新对象，原始对象保持不变。


public class StringImmutability {
    public static void main(String[] args) {
        String str = "Hello";
        String str2 = str.concat(" World"); // 创建了一个新的 String 对象
        
        System.out.println("Original: " + str);  // 输出: Hello
        System.out.println("Modified: " + str2); // 输出: Hello World
    }
}

设计优势与劣势：

优势：线程安全（无需同步）、支持字符串常量池（节省内存）、可安全作为 HashMap 的 Key（HashCode 不变）。
劣势：在循环中进行大量字符串拼接时，会产生大量临时对象，导致频繁的 GC（垃圾回收），严重影响性能。此时应改用 StringBuilder。

4.2.2 StringBuilder 与 StringBuffer：可变字符序列

为了解决 String 频繁修改带来的性能问题，Java 提供了 StringBuilder 和 StringBuffer。它们代表可变的字符序列，允许在原有对象基础上直接修改内容，避免了大量新对象的创建。

4.2.2.1 核心区别与适用场景

特性	StringBuilder	StringBuffer
线程安全性	非线程安全	线程安全（方法使用 `synchronized` 修饰）
性能	高（无锁开销）	较低（存在同步锁开销）
适用场景	单线程环境下的字符串频繁操作（默认首选）	多线程环境下的共享字符串缓冲区操作

4.2.2.2 常用操作方法

两者的 API 基本一致，以下以 StringBuilder 为例：


public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        
        // 1. append: 追加内容
        sb.append(" World"); // "Hello World"
        
        // 2. insert: 在指定位置插入
        sb.insert(5, ","); // "Hello, World"
        
        // 3. delete / deleteCharAt: 删除字符
        sb.delete(5, 6); // "Hello World"
        sb.deleteCharAt(4); // "HellWorld"
        
        // 4. replace: 替换指定区间的内容
        sb.replace(4, 9, "o Java"); // "Hello Java"
        
        // 5. reverse: 反转序列
        sb.reverse(); // "avaJ olleH"
        
        // 6. toString: 转换为不可变的 String 对象
        String finalStr = sb.toString(); 
    }
}

4.2.2.3 性能对比与基准测试

以下代码直观展示了 String、StringBuilder 和 StringBuffer 在 10 万次拼接操作下的性能差异：


public class StringPerformance {
    public static void main(String[] args) {
        int iterations = 100000;
        long startTime, endTime;

        // 1. String 拼接
        startTime = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < iterations; i++) {
            str += "a"; 
        }
        endTime = System.currentTimeMillis();
        System.out.println("String 耗时: " + (endTime - startTime) + "ms");

        // 2. StringBuilder 拼接
        startTime = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < iterations; i++) {
            sb.append("a");
        }
        sb.toString(); 
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder 耗时: " + (endTime - startTime) + "ms");

        // 3. StringBuffer 拼接
        startTime = System.currentTimeMillis();
        StringBuffer sbuf = new StringBuffer();
        for (int i = 0; i < iterations; i++) {
            sbuf.append("a");
        }
        sbuf.toString(); 
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer 耗时: " + (endTime - startTime) + "ms");
    }
}

运行结果通常表明：StringBuilder 耗时在毫秒级以内，而 String 拼接可能需要数秒甚至导致内存溢出。

4.2.3 StringJoiner：高效的字符串拼接 (Java 8+)

StringJoiner 是 Java 8 引入的实用类，专门用于构造由特定分隔符分隔的字符串序列，并支持添加前缀和后缀。它在构建 SQL 语句、CSV 数据或 JSON 数组时极为高效。


import java.util.StringJoiner;

public class StringJoinerExample {
    public static void main(String[] args) {
        // 创建 StringJoiner：分隔符为 ", "，前缀为 "["，后缀为 "]"
        StringJoiner sj = new StringJoiner(", ", "[", "]");
        sj.add("apple").add("banana").add("orange");
        System.out.println(sj.toString()); // 输出: [apple, banana, orange]

        // 设置空值表现
        StringJoiner sjEmpty = new StringJoiner(",");
        sjEmpty.setEmptyValue("Empty List");
        System.out.println(sjEmpty.toString()); // 输出: Empty List
    }
}

进阶技巧：在 Java 8 Stream API 中，可以直接使用 Collectors.joining() 来实现与 StringJoiner 相同的功能，代码更加函数式且简洁。

4.2.4 字符串编码与字符集转换

Java 内部使用 UTF-16（Unicode）编码存储字符串。在与外部系统（如网络传输、文件读写）交互时，必须进行正确的字符集转换，否则会导致乱码问题。

最佳实践：推荐使用 java.nio.charset.StandardCharsets 替代硬编码的字符串名称，以避免 UnsupportedEncodingException 并提高代码健壮性。


import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class StringEncoding {
    public static void main(String[] args) {
        String str = "你好世界";
        
        // 使用 StandardCharsets 转换为字节数组 (推荐)
        byte[] utf8Bytes = str.getBytes(StandardCharsets.UTF_8);
        System.out.println("UTF-8 bytes: " + Arrays.toString(utf8Bytes));
        
        // 从字节数组还原为字符串
        String decodedStr = new String(utf8Bytes, StandardCharsets.UTF_8);
        System.out.println("Decoded string: " + decodedStr);
    }
}

4.2.5 字符串格式化输出

Java 提供了 String.format() 和 java.util.Formatter 用于生成格式化的字符串，支持占位符替换，类似于 C 语言的 printf。


public class StringFormatting {
    public static void main(String[] args) {
        String name = "Alice";
        int age = 30;
        double salary = 5000.50;

        // 使用 String.format()
        String formatted = String.format("Name: %s, Age: %d, Salary: %.2f", name, age, salary);
        System.out.println(formatted); 
        
        // Java 15+ 新特性：使用 formatted() 实例方法
        // String formatted2 = "Name: %s, Age: %d".formatted(name, age);
    }
}

常用占位符：%s (字符串), %d (整数), %f (浮点数), %t (日期时间)。

4.2.6 正则表达式与模式匹配

Java 通过 java.util.regex 包提供强大的正则表达式支持。核心类包括 Pattern（编译后的正则模式）和 Matcher（匹配引擎）。

性能优化提示：Pattern.compile() 是一个相对耗时的操作。如果同一个正则表达式需要被多次使用，务必将其预编译为静态常量，避免在循环中重复编译。


import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegularExpressionExample {
    // 预编译正则表达式，提升性能
    private static final Pattern NUMBER_PATTERN = Pattern.compile("\\d+");

    public static void main(String[] args) {
        String text = "Order IDs: 12345 and 67890.";
        Matcher matcher = NUMBER_PATTERN.matcher(text);

        // 查找所有匹配项
        while (matcher.find()) {
            System.out.println("Found ID: " + matcher.group()); 
        }

        // 替换匹配项
        String maskedText = matcher.replaceAll("***");
        System.out.println("Masked text: " + maskedText); 
    }
}

总结与最佳实践

在 Java 应用程序开发中，正确处理字符串不仅关乎代码的整洁度，更直接影响系统的内存占用与执行效率。以下是核心知识点的总结与最佳实践建议：

首选 String 处理静态文本：String 的不可变性保证了线程安全与哈希值的稳定性，适用于配置项、常量及不需要频繁修改的文本。
循环拼接必用 StringBuilder：在 for/while 循环或大量字符串拼接场景中，严禁使用 String 的 + 操作符，必须使用 StringBuilder 以避免内存抖动。
多线程环境慎用 StringBuffer：虽然 StringBuffer 是线程安全的，但在现代 Java 开发中，更推荐通过线程局部变量（ThreadLocal<StringBuilder>）或并发集合来解决多线程字符串拼接问题，以获得更好的性能。
善用 Java 8+ 新特性：使用 StringJoiner 或 Collectors.joining() 处理带分隔符的集合拼接；使用 StandardCharsets 处理字符编码；使用 strip() 替代 trim() 处理 Unicode 空白符。
正则表达式预编译：将高频使用的 Pattern 提取为 static final 常量，显著降低 CPU 开销。

熟练掌握上述字符串处理技术与底层机制，能够显著提升 Java 应用程序的运行效率，构建出更加健壮、优雅的企业级代码。

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/133-java%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF%E4%B8%8E%E5%BC%80%E5%8F%91%E5%AE%9E%E6%88%98

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流