Java String类详解

String是Java中使用最广泛的类之一，用于表示字符串。虽然字符串在Java中作为对象处理，但Java提供了特殊的语法支持，使其用起来像基本数据类型一样方便。理解String类的特性和内部机制对于编写高效的Java程序至关重要。

本文内容概览

• 1. String类基础特性
  • 1.1 不可变性（Immutability）
  • 1.2 字符串常量池（String Pool）
  • 1.3 String类的内部结构
• 2. String类的构造方法
  • 2.1 常用构造方法
  • 2.2 编码相关构造方法
• 3. String类的常用方法
  • 3.1 字符串查询方法
  • 3.2 字符串提取和分割方法
  • 3.3 字符串修改方法
• 4. 字符串操作和性能
  • 4.1 字符串连接性能分析
  • 4.2 StringBuilder和StringBuffer
  • 4.3 字符串池优化
• 5. 高级字符串操作
  • 5.1 正则表达式操作
  • 5.2 字符串格式化
  • 5.3 字符串编码和国际化
• 6. 实际应用场景
  • 6.1 文本处理工具
  • 6.2 配置文件解析
• 7. 面试题精选
  • 7.1 基础概念题
  • 7.2 性能优化题
  • 7.3 实践题
• 8. 总结
  • 8.1 核心要点回顾
  • 8.2 学习建议
  • 8.3 进阶方向

核心价值

String = 不可变性 + 字符串常量池 + 丰富的操作方法 + 性能优化

• 🔒 不可变性：保证线程安全，提升安全性和稳定性
• 📦 字符串常量池：优化内存使用，提高字符串处理效率
• 🛠️ 丰富的API：提供全面的字符串操作能力
• ⚡ 性能优化：灵活选择StringBuilder和StringBuffer提升性能
• 🌐 编码支持：完善的国际化和多语言支持

1. String类基础特性

不可变性

1.1 不可变性（Immutability）

String对象是不可变的（immutable），这意味着一旦创建，其内容就不能被修改。任何修改操作都会创建一个新的String对象。

不可变性示例

java

1public class StringImmutabilityDemo {
2    public static void main(String[] args) {
3        // 基本不可变性演示
4String s1 = "Hello";
5s1.concat(" World");  // 创建了新的字符串"Hello World"，但s1没有改变
6System.out.println(s1);  // 输出: Hello
7
8// 如果要保存修改后的值，需要重新赋值
9s1 = s1.concat(" World");
10System.out.println(s1);  // 输出: Hello World
11
12// 验证不可变性
13String original = "Java";
14String modified = original.toUpperCase();  // 创建新对象
15System.out.println("Original: " + original);    // Java
16System.out.println("Modified: " + modified);    // JAVA
17System.out.println("Same object? " + (original == modified));  // false
18        
19        // 进一步验证不可变性
20        String test = "Test";
21        String testCopy = test;  // testCopy和test指向同一个对象
22        test = test + "Modified";  // test指向新对象，testCopy仍然指向原对象
23        System.out.println("test: " + test);           // TestModified
24        System.out.println("testCopy: " + testCopy);   // Test
25        System.out.println("Same object? " + (test == testCopy)); // false
26    }
27}

不可变性的好处：

线程安全

多个线程可以同时访问同一个字符串而不会导致数据一致性问题，不需要额外的同步机制。

安全性

用于存储密码、网络连接等敏感信息时更安全，因为内容无法被修改。

哈希缓存

String对象的哈希值可以被缓存，无需重新计算，适合作为HashMap或HashSet的键。

字符串常量池

不可变性使JVM能够优化内存使用，通过常量池复用相同内容的字符串对象。

性能考虑

不可变性虽然带来很多好处，但在频繁修改字符串的场景下可能影响性能。此时应考虑使用StringBuilder或StringBuffer。

字符串常量池

1.2 字符串常量池（String Pool）

为了提高效率和减少内存消耗，Java为字符串维护了一个特殊的内存区域，称为"字符串常量池"。

字符串常量池示例

java

1public class StringPoolDemo {
2    public static void main(String[] args) {
3        // 基本常量池演示
4String s1 = "Hello";  // 创建一个字符串并放入常量池
5String s2 = "Hello";  // 直接引用常量池中的字符串
6String s3 = new String("Hello");  // 强制在堆中创建新对象
7
8System.out.println(s1 == s2);  // true，指向同一个对象
9System.out.println(s1 == s3);  // false，指向不同对象
10System.out.println(s1.equals(s3));  // true，内容相同
11
12// 使用intern()方法将字符串放入常量池
13String s4 = new String("World").intern();
14String s5 = "World";
15System.out.println(s4 == s5);  // true
16        
17        // 动态创建的字符串
18        String dynamic1 = "Dynamic";
19        String dynamic2 = "Dynamic";
20        String dynamic3 = new String("Dynamic");
21        String dynamic4 = dynamic3.intern();
22        
23        System.out.println("dynamic1 == dynamic2: " + (dynamic1 == dynamic2));     // true
24        System.out.println("dynamic1 == dynamic3: " + (dynamic1 == dynamic3));     // false
25        System.out.println("dynamic1 == dynamic4: " + (dynamic1 == dynamic4));     // true
26    }
27}

字符串创建方式

1. 字面量：使用双引号直接创建，如String s = "Hello"
2. 构造函数：使用new关键字创建，如String s = new String("Hello")
3. 字符串方法：通过其他字符串的方法创建，如"Hello".concat(" World")
4. intern()方法：将字符串放入常量池并返回引用

内存布局

内存布局示例

java

1public class StringMemoryExample {
2    public static void main(String[] args) {
3        // 方式1：字面量 - 存储在常量池
4        String literal1 = "Hello";
5        String literal2 = "Hello";
6        
7        // 方式2：构造函数 - 存储在堆内存
8        String constructor1 = new String("Hello");
9        String constructor2 = new String("Hello");
10        
11        // 方式3：字符串连接 - 可能创建新对象
12        String concat1 = "Hello" + " World";
13        String concat2 = "Hello World";
14        
15        // 方式4：运行时连接
16        String runtime1 = "Hello" + new String(" World");
17        String runtime2 = "Hello World";
18        
19        // 比较引用
20        System.out.println("literal1 == literal2: " + (literal1 == literal2));           // true
21        System.out.println("constructor1 == constructor2: " + (constructor1 == constructor2)); // false
22        System.out.println("concat1 == concat2: " + (concat1 == concat2));               // true（编译时优化）
23        System.out.println("runtime1 == runtime2: " + (runtime1 == runtime2));           // false（运行时创建）
24        
25        // 比较内容
26        System.out.println("literal1.equals(constructor1): " + literal1.equals(constructor1)); // true
27        System.out.println("concat1.equals(runtime1): " + concat1.equals(runtime1));           // true
28    }
29}

字符串常量池位置

在Java 7之前，字符串常量池位于永久代(PermGen)。从Java 7开始，字符串常量池被移至堆内存，提高了性能并降低了内存溢出的风险。

内部结构

1.3 String类的内部结构

从Java 9开始，String类的内部实现发生了变化，使用byte数组替代char数组来存储字符串内容。

String内部结构分析

java

1public class StringInternalStructure {
2    public static void main(String[] args) {
3        // 创建不同编码的字符串
4        String asciiString = "Hello World";  // ASCII字符
5        String chineseString = "你好世界";    // 中文字符
6        String emojiString = "Hello 👋";     // 包含emoji
7        
8        // 获取字符串长度
9        System.out.println("ASCII字符串长度: " + asciiString.length());           // 11
10        System.out.println("中文字符串长度: " + chineseString.length());         // 4
11        System.out.println("Emoji字符串长度: " + emojiString.length());          // 7
12        
13        // 获取字节数组
14        byte[] asciiBytes = asciiString.getBytes();
15        byte[] chineseBytes = chineseString.getBytes();
16        byte[] emojiBytes = emojiString.getBytes();
17        
18        System.out.println("ASCII字节数: " + asciiBytes.length);                 // 11
19        System.out.println("中文字节数: " + chineseBytes.length);                 // 12 (UTF-8编码)
20        System.out.println("Emoji字节数: " + emojiBytes.length);                 // 10 (UTF-8编码)
21        
22        // 获取字符数组
23        char[] asciiChars = asciiString.toCharArray();
24        char[] chineseChars = chineseString.toCharArray();
25        char[] emojiChars = emojiString.toCharArray();
26        
27        System.out.println("ASCII字符数: " + asciiChars.length);                 // 11
28        System.out.println("中文字符数: " + chineseChars.length);                 // 4
29        System.out.println("Emoji字符数: " + emojiChars.length);                 // 7
30    }
31}

Java 8及之前

java

1// Java 8 中 String 的部分源码
2public final class String
3    implements java.io.Serializable, Comparable<String>, CharSequence {
4    /** The value is used for character storage. */
5    private final char value[];
6
7    /** Cache the hash code for the string */
8    private int hash; // Default to 0
9    
10    // ...其他成员和方法...
11}

Java 9及以后

java

1// Java 9+ 中 String 的部分源码
2public final class String
3    implements java.io.Serializable, Comparable<String>, CharSequence {
4    /** The value is used for character storage. */
5    private final byte[] value;
6
7    /** The identifier of the encoding used to encode the bytes in {@code value}. */
8    private final byte coder;
9    
10    /** Cache the hash code for the string */
11    private int hash; // Default to 0
12    
13    // ...其他成员和方法...
14}

Java 9的改进

Java 9中String类使用byte[]而非char[]存储数据的主要原因：

1. 节省内存：大多数字符串只包含Latin-1字符，每个字符只需要1个字节而非2个字节
2. 使用coder字段标记编码方式：0代表Latin-1编码，1代表UTF-16编码
3. 平均可节省约20%的内存空间

2. String类的构造方法

常用构造方法

2.1 常用构造方法

String类提供了多种构造方法，用于不同的创建场景。

String构造方法示例

java

1public class StringConstructorsDemo {
2    public static void main(String[] args) {
3        // 1. 无参构造方法 - 创建空字符串
4        String empty = new String();
5        System.out.println("空字符串: '" + empty + "'");
6        System.out.println("长度: " + empty.length());
7        System.out.println("是否为空: " + empty.isEmpty());
8        
9        // 2. 字符串字面量构造
10        String literal = new String("Hello World");
11        System.out.println("字面量构造: " + literal);
12        
13        // 3. 字符数组构造
14        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
15        String fromCharArray = new String(charArray);
16        System.out.println("字符数组构造: " + fromCharArray);
17        
18        // 4. 字符数组部分构造
19        String fromCharArrayPart = new String(charArray, 1, 3);  // 从索引1开始，取3个字符
20        System.out.println("字符数组部分构造: " + fromCharArrayPart);  // ell
21        
22        // 5. 字节数组构造
23        byte[] byteArray = {72, 101, 108, 108, 111};  // "Hello"的ASCII码
24        String fromByteArray = new String(byteArray);
25        System.out.println("字节数组构造: " + fromByteArray);
26        
27        // 6. 字节数组部分构造
28        String fromByteArrayPart = new String(byteArray, 1, 3, "UTF-8");
29        System.out.println("字节数组部分构造: " + fromByteArrayPart);
30        
31        // 7. StringBuffer构造
32        StringBuffer stringBuffer = new StringBuffer("Hello");
33        String fromStringBuffer = new String(stringBuffer);
34        System.out.println("StringBuffer构造: " + fromStringBuffer);
35        
36        // 8. StringBuilder构造
37        StringBuilder stringBuilder = new StringBuilder("World");
38        String fromStringBuilder = new String(stringBuilder);
39        System.out.println("StringBuilder构造: " + fromStringBuilder);
40    }
41}

空字符串

java

1// 创建空字符串
2String s = new String();

这是最简单的构造方法，创建一个空字符串，长度为0。等同于String s = ""。

字符串拷贝

java

1// 从现有字符串创建新字符串
2String original = "Hello";
3String copy = new String(original);

这个构造方法创建一个与参数内容相同的新字符串对象。注意，这将创建一个新对象，不会重用常量池中的对象。

数组构造

java

1// 从字符数组构造
2char[] chars = {'H', 'e', 'l', 'l', 'o'};
3String s1 = new String(chars);
4
5// 从部分字符数组构造
6String s2 = new String(chars, 1, 3); // "ell"
7
8// 从字节数组构造
9byte[] bytes = {72, 101, 108, 108, 111};
10String s3 = new String(bytes);

这些构造方法允许从字符数组或字节数组创建字符串，可以指定起始索引和长度。

编码相关构造方法

2.2 编码相关构造方法

编码相关构造方法

java

1public class StringEncodingDemo {
2    public static void main(String[] args) throws Exception {
3        String original = "Hello 世界";
4        
5        // 使用默认编码（通常是UTF-8）
6        byte[] defaultBytes = original.getBytes();
7        String fromDefaultBytes = new String(defaultBytes);
8        System.out.println("默认编码: " + fromDefaultBytes);
9        
10        // 使用UTF-8编码
11        byte[] utf8Bytes = original.getBytes("UTF-8");
12        String fromUtf8Bytes = new String(utf8Bytes, "UTF-8");
13        System.out.println("UTF-8编码: " + fromUtf8Bytes);
14        
15        // 使用GBK编码
16        byte[] gbkBytes = original.getBytes("GBK");
17        String fromGbkBytes = new String(gbkBytes, "GBK");
18        System.out.println("GBK编码: " + fromGbkBytes);
19        
20        // 使用ISO-8859-1编码
21        byte[] isoBytes = original.getBytes("ISO-8859-1");
22        String fromIsoBytes = new String(isoBytes, "ISO-8859-1");
23        System.out.println("ISO-8859-1编码: " + fromIsoBytes);
24        
25        // 编码问题演示
26        System.out.println("UTF-8字节数: " + utf8Bytes.length);
27        System.out.println("GBK字节数: " + gbkBytes.length);
28        System.out.println("ISO-8859-1字节数: " + isoBytes.length);
29    }
30}

常用编码对照表

编码名称	特点	适用场景	中文支持
UTF-8	变长编码，1-4字节	网页、国际化应用	支持（3字节）
UTF-16	大部分字符2字节	Java内部编码	支持（2字节）
GBK	中文优化编码	中文应用	支持（2字节）
ISO-8859-1	单字节编码	西欧语言	不支持
ASCII	单字节编码	纯英文	不支持

编码构造方法

java

1// 指定字符集名称
2byte[] bytes = "Hello".getBytes("UTF-8");
3String s1 = new String(bytes, "UTF-8");
4
5// 使用Charset对象
6Charset utf8 = Charset.forName("UTF-8");
7byte[] bytes2 = "Hello".getBytes(utf8);
8String s2 = new String(bytes2, utf8);
9
10// 标准字符集常量
11byte[] bytes3 = "Hello".getBytes(StandardCharsets.UTF_8);
12String s3 = new String(bytes3, StandardCharsets.UTF_8);

编码转换警告

不同编码间的转换如果处理不当，可能导致乱码，特别是对于中文、日文等非ASCII字符。始终使用相同的编码进行getBytes()和new String()操作。

编码最佳实践

1. 尽量使用UTF-8作为默认编码
2. 在处理外部数据时，总是显式指定编码，不要依赖默认编码
3. 使用Java 7引入的StandardCharsets常量而不是字符串形式的编码名称
4. 处理非ASCII字符时，注意验证编码转换的正确性

3. String类的常用方法

查询方法

3.1 字符串查询方法

String类提供了丰富的查询方法来获取字符串的各种信息。

字符串查询方法示例

java

1public class StringQueryMethodsDemo {
2    public static void main(String[] args) {
3        String text = "Hello World Java Programming";
4        
5        // 1. 长度相关
6        System.out.println("字符串长度: " + text.length());
7        System.out.println("是否为空: " + text.isEmpty());
8        System.out.println("是否为空白: " + text.isBlank());  // Java 11+
9        
10        // 2. 字符访问
11        System.out.println("第一个字符: " + text.charAt(0));
12        System.out.println("最后一个字符: " + text.charAt(text.length() - 1));
13        
14        // 3. 子字符串查找
15        System.out.println("'World'的位置: " + text.indexOf("World"));
16        System.out.println("'Java'的位置: " + text.indexOf("Java"));
17        System.out.println("'o'第一次出现位置: " + text.indexOf('o'));
18        System.out.println("'o'最后一次出现位置: " + text.lastIndexOf('o'));
19        
20        // 4. 字符串包含检查
21        System.out.println("包含'Hello': " + text.contains("Hello"));
22        System.out.println("包含'Python': " + text.contains("Python"));
23        
24        // 5. 字符串开始和结束检查
25        System.out.println("以'Hello'开始: " + text.startsWith("Hello"));
26        System.out.println("以'ing'结束: " + text.endsWith("ing"));
27        System.out.println("从索引5开始以'World'开始: " + text.startsWith("World", 6));
28        
29        // 6. 字符串比较
30        String text2 = "Hello World Java Programming";
31        String text3 = "hello world java programming";
32        
33        System.out.println("text == text2: " + (text == text2));  // 引用比较
34        System.out.println("text.equals(text2): " + text.equals(text2));  // 内容比较
35        System.out.println("text.equalsIgnoreCase(text3): " + text.equalsIgnoreCase(text3));  // 忽略大小写比较
36        
37        // 7. 字符串比较（字典序）
38        System.out.println("text.compareTo(text2): " + text.compareTo(text2));  // 0
39        System.out.println("text.compareTo(text3): " + text.compareTo(text3));  // 负数
40        System.out.println("text.compareToIgnoreCase(text3): " + text.compareToIgnoreCase(text3));  // 0
41    }
42}

长度和空检查

java

1// 字符串长度
2int length = str.length();
3
4// 空字符串检查
5boolean isEmpty = str.isEmpty();  // 检查是否是空字符串 ""
6
7// Java 11+: 空白检查
8boolean isBlank = str.isBlank();  // 检查是否只包含空白字符

索引和搜索

java

1// 字符访问
2char firstChar = str.charAt(0);
3char lastChar = str.charAt(str.length() - 1);
4
5// 子字符串搜索
6int index = str.indexOf("Hello");    // 首次出现位置
7int lastIndex = str.lastIndexOf("o"); // 最后一次出现位置
8
9// 带起始位置的搜索
10int fromIndex = str.indexOf("o", 5);  // 从索引5开始搜索首次出现位置
11
12// 包含检查
13boolean contains = str.contains("Java");  // 检查是否包含子串

开始和结束检查

java

1// 开始检查
2boolean startsWithHello = str.startsWith("Hello");
3
4// 结束检查
5boolean endsWithJava = str.endsWith("Java");
6
7// 带偏移量的开始检查
8boolean startsWithWorld = str.startsWith("World", 6); // 从索引6开始检查

字符串比较

java

1// 相等性比较
2boolean isEqual = str1.equals(str2);               // 区分大小写
3boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2); // 不区分大小写
4
5// 字典顺序比较
6int result = str1.compareTo(str2);
7// 返回值: 负数表示str1小于str2，0表示相等，正数表示str1大于str2
8
9// 不区分大小写字典顺序比较
10int resultIgnoreCase = str1.compareToIgnoreCase(str2);

Java 11+新增方法

Java 11引入了isBlank()、strip()、stripLeading()、stripTrailing()和lines()等新方法，用于增强字符串处理能力。

提取和分割

3.2 字符串提取和分割方法

字符串提取和分割方法

java

1public class StringExtractionDemo {
2    public static void main(String[] args) {
3        String text = "Hello,World,Java,Programming";
4        
5        // 1. 子字符串提取
6        System.out.println("从索引0到5: " + text.substring(0, 5));  // Hello
7        System.out.println("从索引6开始: " + text.substring(6));    // World,Java,Programming
8        
9        // 2. 字符串分割
10        String[] parts = text.split(",");
11        System.out.println("分割后的部分:");
12        for (int i = 0; i < parts.length; i++) {
13            System.out.println("  [" + i + "]: " + parts[i]);
14        }
15        
16        // 3. 使用正则表达式分割
17        String text2 = "Hello;World.Java:Programming";
18        String[] parts2 = text2.split("[;.:]");
19        System.out.println("正则分割后的部分:");
20        for (int i = 0; i < parts2.length; i++) {
21            System.out.println("  [" + i + "]: " + parts2[i]);
22        }
23        
24        // 4. 限制分割次数
25        String text3 = "a,b,c,d,e,f";
26        String[] parts3 = text3.split(",", 3);  // 最多分割3次
27        System.out.println("限制分割次数:");
28        for (int i = 0; i < parts3.length; i++) {
29            System.out.println("  [" + i + "]: " + parts3[i]);
30        }
31        
32        // 5. 字符串截取
33        String longText = "This is a very long text that needs to be truncated";
34        if (longText.length() > 20) {
35            String truncated = longText.substring(0, 20) + "...";
36            System.out.println("截取后: " + truncated);
37        }
38    }
39}

子字符串提取

java

1// 从索引beginIndex到字符串结束
2String sub1 = str.substring(6);
3
4// 从索引beginIndex到endIndex-1
5String sub2 = str.substring(0, 5);  // 提取索引0,1,2,3,4的字符
6
7// 安全截取（避免IndexOutOfBoundsException）
8public static String safeSubstring(String str, int start, int end) {
9    if (str == null) return "";
10    int length = str.length();
11    if (start < 0) start = 0;
12    if (end > length) end = length;
13    if (start > end) return "";
14    return str.substring(start, end);
15}

分割字符串

java

1// 基本分割
2String[] parts = "a,b,c".split(",");  // 返回 ["a", "b", "c"]
3
4// 使用正则表达式分割
5String[] parts2 = "a;b.c:d".split("[;.:]");  // 返回 ["a", "b", "c", "d"]
6
7// 限制分割次数
8String[] parts3 = "a,b,c,d".split(",", 2);  // 返回 ["a", "b,c,d"]
9
10// 处理连续分隔符
11String[] parts4 = "a,,b".split(",");  // 返回 ["a", "", "b"]

空白处理

java

1// 去除前后空白（传统方法）
2String trimmed = "  Hello  ".trim();  // 返回 "Hello"
3
4// Java 11+ 新方法
5String stripped = "  Hello  ".strip();        // 去除前后Unicode空白
6String stripLeading = "  Hello  ".stripLeading();  // 去除前导空白
7String stripTrailing = "  Hello  ".stripTrailing(); // 去除尾部空白

转换方法

java

1// 转换为字符数组
2char[] chars = "Hello".toCharArray();
3
4// 转换为字节数组
5byte[] bytes = "Hello".getBytes();
6byte[] utf8Bytes = "Hello".getBytes("UTF-8");
7
8// 转换为代码点数组 (Java 9+)
9int[] codePoints = "Hello😊".codePoints().toArray();

修改方法

3.3 字符串修改方法

字符串修改方法

java

1public class StringModificationDemo {
2    public static void main(String[] args) {
3        String original = "  Hello World  ";
4        
5        // 1. 去除空白字符
6        System.out.println("原始字符串: '" + original + "'");
7        System.out.println("去除前后空白: '" + original.trim() + "'");
8        System.out.println("去除前导空白: '" + original.stripLeading() + "'");  // Java 11+
9        System.out.println("去除尾部空白: '" + original.stripTrailing() + "'"); // Java 11+
10        
11        // 2. 大小写转换
12        String text = "Hello World";
13        System.out.println("原字符串: " + text);
14        System.out.println("转大写: " + text.toUpperCase());
15        System.out.println("转小写: " + text.toLowerCase());
16        
17        // 3. 字符串替换
18        String replaceText = "Hello World Hello Java";
19        System.out.println("原字符串: " + replaceText);
20        System.out.println("替换Hello为Hi: " + replaceText.replace("Hello", "Hi"));
21        System.out.println("替换第一个Hello: " + replaceText.replaceFirst("Hello", "Hi"));
22        System.out.println("替换所有o为0: " + replaceText.replace('o', '0'));
23        
24        // 4. 正则表达式替换
25        String regexText = "Hello123World456Java";
26        System.out.println("原字符串: " + regexText);
27        System.out.println("替换数字为#: " + regexText.replaceAll("\\d+", "#"));
28        System.out.println("替换第一个数字序列: " + regexText.replaceFirst("\\d+", "#"));
29        
30        // 5. 字符串连接
31        String s1 = "Hello";
32        String s2 = "World";
33        String s3 = "Java";
34
35// 使用concat方法
36        String result1 = s1.concat(" ").concat(s2).concat(" ").concat(s3);
37        System.out.println("concat结果: " + result1);
38        
39        // 使用+操作符
40        String result2 = s1 + " " + s2 + " " + s3;
41        System.out.println("+操作符结果: " + result2);
42        
43        // 使用String.join
44        String result3 = String.join(" ", s1, s2, s3);
45        System.out.println("String.join结果: " + result3);
46    }
47}

大小写转换

java

1// 转大写
2String upper = "hello".toUpperCase();  // "HELLO"
3
4// 转小写
5String lower = "HELLO".toLowerCase();  // "hello"
6
7// 特定语言环境的大小写转换
8String turkishUpper = "istanbul".toUpperCase(Locale.forLanguageTag("tr-TR"));
9// 在土耳其语中，i转大写为İ(带点的I)

替换操作

java

1// 替换单个字符
2String replaced1 = "hello".replace('l', 'w');  // "hewwo"
3
4// 替换子字符串
5String replaced2 = "hello world".replace("world", "java");  // "hello java"
6
7// 使用正则表达式替换所有匹配
8String replaced3 = "hello123world456".replaceAll("\\d+", "#");  // "hello#world#"
9
10// 替换第一个匹配
11String replaced4 = "hello hello".replaceFirst("hello", "hi");  // "hi hello"

连接字符串

java

1// 使用concat方法
2String s1 = "hello".concat(" ").concat("world");  // "hello world"
3
4// 使用+运算符（编译器会优化）
5String s2 = "hello" + " " + "world";  // "hello world"
6
7// 使用String.join (Java 8+)
8String s3 = String.join(" ", "hello", "world");  // "hello world"
9String s4 = String.join(",", List.of("a", "b", "c"));  // "a,b,c"
10
11// 使用StringJoiner (Java 8+)
12StringJoiner joiner = new StringJoiner(", ", "[", "]");
13joiner.add("apple").add("banana").add("cherry");
14String s5 = joiner.toString();  // "[apple, banana, cherry]"

格式化

java

1// 基本格式化
2String formatted = String.format("Hello, %s", "World");  // "Hello, World"
3
4// 多参数格式化
5String multi = String.format("Name: %s, Age: %d", "Alice", 30);
6
7// 数字格式化
8String number = String.format("%.2f", 123.456);  // "123.46"
9
10// Java 15+ 文本块
11String textBlock = """
12    Hello,
13    World!
14    """;

字符串修改的最佳实践

• 对于简单的连接，使用+运算符最为清晰
• 在循环中连接字符串，使用StringBuilder而不是+
• 对集合元素进行连接，使用String.join或StringJoiner
• 对格式化输出，使用String.format或printf

4. 字符串操作和性能

字符串连接性能分析

4.1 字符串连接性能分析

字符串连接性能分析

java

1public class StringConcatenationPerformance {
2    public static void main(String[] args) {
3        int iterations = 10000;
4        
5        // 1. 使用+操作符连接
6        long startTime = System.currentTimeMillis();
7        String result1 = "";
8        for (int i = 0; i < iterations; i++) {
9            result1 += "String" + i + " ";
10        }
11        long endTime = System.currentTimeMillis();
12        System.out.println("+操作符耗时: " + (endTime - startTime) + "ms");
13        
14        // 2. 使用StringBuilder连接
15        startTime = System.currentTimeMillis();
16        StringBuilder sb = new StringBuilder();
17        for (int i = 0; i < iterations; i++) {
18            sb.append("String").append(i).append(" ");
19        }
20        String result2 = sb.toString();
21        endTime = System.currentTimeMillis();
22        System.out.println("StringBuilder耗时: " + (endTime - startTime) + "ms");
23        
24        // 3. 使用StringBuffer连接
25        startTime = System.currentTimeMillis();
26        StringBuffer sbf = new StringBuffer();
27        for (int i = 0; i < iterations; i++) {
28            sbf.append("String").append(i).append(" ");
29        }
30        String result3 = sbf.toString();
31        endTime = System.currentTimeMillis();
32        System.out.println("StringBuffer耗时: " + (endTime - startTime) + "ms");
33        
34        // 4. 使用String.join
35        startTime = System.currentTimeMillis();
36        String[] strings = new String[iterations];
37        for (int i = 0; i < iterations; i++) {
38            strings[i] = "String" + i;
39        }
40        String result4 = String.join(" ", strings);
41        endTime = System.currentTimeMillis();
42        System.out.println("String.join耗时: " + (endTime - startTime) + "ms");
43        
44        // 验证结果长度
45        System.out.println("结果长度验证:");
46        System.out.println("  +操作符: " + result1.length());
47        System.out.println("  StringBuilder: " + result2.length());
48        System.out.println("  StringBuffer: " + result3.length());
49        System.out.println("  String.join: " + result4.length());
50    }
51}

+ 操作符

优点：

• 语法简洁，易于理解
• 少量字符串连接时性能可接受
• 编译时常量会被优化

缺点：

• 大量连接或在循环中使用性能极差
• 每次连接都创建新的String对象
• 循环中使用会导致O(n²)时间复杂度

适用场景：简单的少量字符串连接，编译时常量连接

java

1// 编译优化示例
2String s = "Hello" + " " + "World"; // 编译器优化为 "Hello World"
3
4// 不推荐的用法
5String result = "";
6for (int i = 0; i < 1000; i++) {
7    result += i; // 非常低效!
8}

StringBuilder

优点：

• 可变字符序列，避免创建多余对象
• 性能最佳（非线程安全环境）
• 支持链式调用
• 可预分配容量减少扩容成本

缺点：

• 非线程安全
• 代码冗长度高于+操作符

适用场景：单线程环境下的大量字符串操作，尤其是在循环中

java

1// 高效用法
2StringBuilder sb = new StringBuilder(1000); // 预分配容量
3for (int i = 0; i < 1000; i++) {
4    sb.append(i);
5}
6String result = sb.toString();
7
8// 链式调用
9String message = new StringBuilder()
10    .append("Hello, ")
11    .append("World")
12    .append("!")
13    .toString();

StringBuffer

优点：

• 线程安全
• 可变字符序列
• 适合多线程环境

缺点：

• 性能低于StringBuilder (约慢10-15%)
• 代码冗长度高于+操作符

适用场景：多线程环境下的字符串操作

java

1// 多线程环境示例
2StringBuffer buffer = new StringBuffer();
3
4Runnable task = () -> {
5    for (int i = 0; i < 100; i++) {
6        buffer.append(i); // 线程安全
7    }
8};
9
10Thread t1 = new Thread(task);
11Thread t2 = new Thread(task);
12t1.start(); t2.start();

String.join

优点：

• 专为集合元素连接设计
• 清晰简洁的API
• 比循环+连接高效

缺点：

• Java 8+才可用
• 仅适用于已知元素的连接
• 不适合动态添加内容

适用场景：连接数组或集合中的元素

java

1// 数组元素连接
2String[] fruits = {"Apple", "Banana", "Cherry"};
3String result = String.join(", ", fruits);
4
5// 集合元素连接
6List<String> names = List.of("Alice", "Bob", "Charlie");
7String nameList = String.join("; ", names);

性能陷阱

在循环中使用+或concat()连接字符串是常见的性能陷阱。这会导致每次迭代都创建新的字符串对象，时间复杂度为O(n²)。始终在此类场景使用StringBuilder。

StringBuilder和StringBuffer

4.2 StringBuilder和StringBuffer

StringBuilder和StringBuffer示例

java

1public class StringBuilderBufferDemo {
2    public static void main(String[] args) {
3        // 1. StringBuilder基本操作
4        StringBuilder sb = new StringBuilder();
5        sb.append("Hello");
6        sb.append(" ");
7        sb.append("World");
8        sb.append(" ");
9        sb.append("Java");
10        
11        System.out.println("StringBuilder结果: " + sb.toString());
12        System.out.println("长度: " + sb.length());
13        System.out.println("容量: " + sb.capacity());
14        
15        // 2. StringBuilder插入和删除
16        sb.insert(5, " Beautiful ");
17        System.out.println("插入后: " + sb.toString());
18        
19        sb.delete(5, 16);
20        System.out.println("删除后: " + sb.toString());
21        
22        sb.replace(5, 10, "Amazing");
23        System.out.println("替换后: " + sb.toString());
24        
25        // 3. StringBuilder反转
26        sb.reverse();
27        System.out.println("反转后: " + sb.toString());
28        sb.reverse();  // 恢复原状
29        
30        // 4. StringBuilder设置长度
31        sb.setLength(10);
32        System.out.println("设置长度后: " + sb.toString());
33        
34        // 5. StringBuffer（线程安全版本）
35        StringBuffer sbf = new StringBuffer("Thread Safe");
36        sbf.append(" String Buffer");
37        System.out.println("StringBuffer结果: " + sbf.toString());
38        
39        // 6. 性能对比
40        int iterations = 100000;
41        
42        // StringBuilder性能
43        long startTime = System.currentTimeMillis();
44        StringBuilder sb2 = new StringBuilder();
45        for (int i = 0; i < iterations; i++) {
46            sb2.append(i);
47        }
48        long endTime = System.currentTimeMillis();
49        System.out.println("StringBuilder耗时: " + (endTime - startTime) + "ms");
50        
51        // StringBuffer性能
52        startTime = System.currentTimeMillis();
53        StringBuffer sbf2 = new StringBuffer();
54        for (int i = 0; i < iterations; i++) {
55            sbf2.append(i);
56        }
57        endTime = System.currentTimeMillis();
58        System.out.println("StringBuffer耗时: " + (endTime - startTime) + "ms");
59    }
60}

常用操作

创建

java

1// 默认容量构造
2StringBuilder sb1 = new StringBuilder();
3
4// 指定初始容量
5StringBuilder sb2 = new StringBuilder(100);
6
7// 初始字符串
8StringBuilder sb3 = new StringBuilder("Hello");

添加内容

java

1StringBuilder sb = new StringBuilder();
2sb.append("Hello");        // 添加字符串
3sb.append(' ');            // 添加字符
4sb.append(123);            // 添加数字
5sb.append(true);           // 添加布尔值
6sb.append(new char[]{'a', 'b', 'c'}); // 添加字符数组

插入内容

java

1StringBuilder sb = new StringBuilder("HelloWorld");
2sb.insert(5, ' ');         // Hello World
3sb.insert(0, "Start: ");   // Start: Hello World

删除内容

java

1StringBuilder sb = new StringBuilder("Hello World");
2sb.delete(5, 6);           // HelloWorld (删除空格)
3sb.deleteCharAt(5);        // HelloWorld (删除W)

替换内容

java

1StringBuilder sb = new StringBuilder("Hello World");
2sb.replace(6, 11, "Java"); // Hello Java

容量管理

容量原理

StringBuilder和StringBuffer内部维护一个字符数组，初始容量为16。当容量不足时，会自动扩容。默认的扩容策略是将容量翻倍+2。

java

1// 检查和管理容量
2StringBuilder sb = new StringBuilder();
3System.out.println("初始容量: " + sb.capacity()); // 通常为16
4
5// 确保容量足够
6sb.ensureCapacity(100);
7System.out.println("扩容后: " + sb.capacity());
8
9// 压缩容量到实际所需
10sb.append("Hello");
11sb.trimToSize();
12System.out.println("压缩后: " + sb.capacity()); // 应为5

自定义初始容量

如果预知大概需要的容量，最好在创建时指定，避免扩容开销：

java

1// 好的做法: 预估大小
2StringBuilder sb = new StringBuilder(1000);
3for (int i = 0; i < 1000; i++) {
4    sb.append(i);
5}
6
7// 不好的做法: 频繁扩容
8StringBuilder sb2 = new StringBuilder();
9for (int i = 0; i < 1000; i++) {
10    sb2.append(i);
11}

线程安全性

StringBuilder (非线程安全)

java

1// 单线程环境 - 正确
2StringBuilder sb = new StringBuilder();
3for (int i = 0; i < 1000; i++) {
4    sb.append(i);
5}
6
7// 多线程环境 - 错误! 可能导致数据损坏或异常
8StringBuilder sharedSb = new StringBuilder();
9Runnable task = () -> {
10    for (int i = 0; i < 1000; i++) {
11        sharedSb.append(i); // 线程不安全!
12    }
13};
14new Thread(task).start();
15new Thread(task).start();

StringBuffer (线程安全)

java

1// 多线程环境 - 正确
2StringBuffer buffer = new StringBuffer();
3Runnable task = () -> {
4    for (int i = 0; i < 1000; i++) {
5        buffer.append(i); // 线程安全
6    }
7};
8new Thread(task).start();
9new Thread(task).start();

信息

StringBuffer的线程安全是通过在每个方法上添加synchronized关键字实现的，这保证了多线程环境下的安全性，但也带来了约10-15%的性能损失。

字符串池优化

4.3 字符串池优化

字符串池优化示例

java

1public class StringPoolOptimization {
2    public static void main(String[] args) {
3        // 1. 编译时常量优化
4        String s1 = "Hello" + "World";  // 编译时优化为"HelloWorld"
5        String s2 = "HelloWorld";
6        System.out.println("编译时优化: " + (s1 == s2));  // true
7        
8        // 2. 运行时连接
9        String s3 = "Hello";
10        String s4 = "World";
11        String s5 = s3 + s4;  // 运行时创建新对象
12        String s6 = "HelloWorld";
13        System.out.println("运行时连接: " + (s5 == s6));  // false
14        
15        // 3. final变量优化
16        final String finalS1 = "Hello";
17        final String finalS2 = "World";
18        String s7 = finalS1 + finalS2;  // 编译时优化
19        System.out.println("final变量优化: " + (s7 == s6));  // true
20        
21        // 4. intern()方法使用
22        String s8 = new String("InternTest");
23        String s9 = s8.intern();
24        String s10 = "InternTest";
25        System.out.println("intern()优化: " + (s9 == s10));  // true
26        
27        // 5. 字符串池大小限制
28        System.out.println("字符串池优化建议:");
29        System.out.println("  - 对于频繁使用的字符串，使用字面量创建");
30        System.out.println("  - 对于动态创建的字符串，考虑使用intern()");
31        System.out.println("  - 避免在循环中创建大量字符串对象");
32        System.out.println("  - 使用StringBuilder进行大量字符串操作");
33    }
34}

编译时优化

编译器会在编译期间优化字符串常量表达式，将多个字符串字面量连接为一个：

java

1// 以下代码会被编译为 String s = "HelloWorld";
2String s = "Hello" + "World";

字符串常量折叠

这种优化称为"字符串常量折叠"(String constant folding)，它只适用于编译时常量表达式：

java

1// 编译时优化示例
2String s1 = "Hello" + "World" + "!";  // 编译为 "HelloWorld!"
3String s2 = "HelloWorld!";
4System.out.println(s1 == s2);  // true
5
6// 非编译时常量，不会优化
7String hello = "Hello";
8String world = "World";
9String s3 = hello + world;  // 运行时连接，创建新对象
10System.out.println(s3 == s2);  // false

final变量优化

使用final修饰的变量在编译期间是已知的常量，编译器可以对它们进行优化：

java

1// final变量优化
2final String hello = "Hello";
3final String world = "World";
4String s1 = hello + world;  // 编译为 "HelloWorld"
5
6// 非final变量不会优化
7String h = "Hello";
8String w = "World";
9String s2 = h + w;  // 运行时连接
10
11System.out.println(s1 == "HelloWorld");  // true
12System.out.println(s2 == "HelloWorld");  // false

字节码验证

如果查看编译后的字节码，你会发现final变量的连接已经在编译阶段被替换为常量"HelloWorld"，而非final变量的连接会调用StringBuilder的append方法。

intern()方法

intern()方法可以将运行时创建的字符串添加到字符串常量池，并返回常量池中的引用：

java

1// 动态创建的字符串
2String s1 = new String("Hello");  // 堆中的对象
3String s2 = s1.intern();          // 常量池中的引用
4String s3 = "Hello";              // 常量池中的引用
5
6System.out.println(s1 == s2);     // false
7System.out.println(s2 == s3);     // true

何时使用intern()

• 大量相同内容的字符串对象
• 内存敏感应用
• 需要频繁比较字符串引用相等性的场景

java

1// 有效使用intern()的例子
2Map<String, Data> dataCache = new HashMap<>();
3
4void processData(String key, Data value) {
5    // 使用intern()避免重复的字符串对象
6    dataCache.put(key.intern(), value);
7}

性能考虑

intern()方法需要全局字符串表查找，可能影响性能。在Java 7之前，常量池在PermGen空间，大小有限，过度使用intern()可能导致OutOfMemoryError。Java 7及以后，常量池移至堆内存，这个问题有所缓解，但仍需谨慎使用。

字符串池优化最佳实践

1. 优先使用字面量创建字符串，而不是构造函数
2. 对于需要频繁使用且内容相同的字符串，考虑使用intern()
3. 利用final变量的编译时优化特性
4. 对于大量字符串操作，使用StringBuilder而非+运算符
5. 使用System.getProperty("java.lang.string.intern.count")查看常量池使用情况（JVM特定参数）

5. 高级字符串操作

5.1 正则表达式操作

正则表达式操作示例

java

1public class StringRegexDemo {
2    public static void main(String[] args) {
3        // 1. 基本正则表达式匹配
4        String text = "Hello123World456Java789";
5        
6        // 匹配数字
7        String[] numbers = text.split("\\D+");
8        System.out.println("提取的数字:");
9        for (String number : numbers) {
10            if (!number.isEmpty()) {
11                System.out.println("  " + number);
12            }
13        }
14        
15        // 匹配字母
16        String[] letters = text.split("\\d+");
17        System.out.println("提取的字母:");
18        for (String letter : letters) {
19            if (!letter.isEmpty()) {
20                System.out.println("  " + letter);
21            }
22        }
23        
24        // 2. 复杂正则表达式
25        String email = "user@example.com";
26        String phone = "123-456-7890";
27        String date = "2023-12-25";
28        
29        // 邮箱验证
30        boolean isValidEmail = email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
31        System.out.println("邮箱格式有效: " + isValidEmail);
32        
33        // 电话号码验证
34        boolean isValidPhone = phone.matches("^\\d{3}-\\d{3}-\\d{4}$");
35        System.out.println("电话号码格式有效: " + isValidPhone);
36        
37        // 日期格式验证
38        boolean isValidDate = date.matches("^\\d{4}-\\d{2}-\\d{2}$");
39        System.out.println("日期格式有效: " + isValidDate);
40        
41        // 3. 正则表达式替换
42        String htmlText = "<p>Hello <b>World</b> <i>Java</i></p>";
43        String plainText = htmlText.replaceAll("<[^>]+>", "");
44        System.out.println("HTML标签移除后: " + plainText);
45        
46        // 4. 捕获组使用
47        String logEntry = "2023-12-25 10:30:45 [INFO] User login successful";
48        String pattern = "(\\d{4}-\\d{2}-\\d{2}) (\\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.+)";
49        
50        if (logEntry.matches(pattern)) {
51            String[] groups = logEntry.replaceAll(pattern, "$1|$2|$3|$4").split("\\|");
52            System.out.println("日志解析结果:");
53            System.out.println("  日期: " + groups[0]);
54            System.out.println("  时间: " + groups[1]);
55            System.out.println("  级别: " + groups[2]);
56            System.out.println("  消息: " + groups[3]);
57        }
58    }
59}

5.2 字符串格式化

字符串格式化示例

java

1public class StringFormattingDemo {
2    public static void main(String[] args) {
3        // 1. String.format方法
4        String name = "张三";
5        int age = 25;
6        double salary = 12345.67;
7        
8        String formatted1 = String.format("姓名: %s, 年龄: %d, 薪资: %.2f", name, age, salary);
9        System.out.println("格式化结果1: " + formatted1);
10        
11        // 2. 数字格式化
12        String numberFormat = String.format("整数: %d, 八进制: %o, 十六进制: %x, 科学计数: %e", 
13                                          100, 100, 100, 1000000.0);
14        System.out.println("数字格式化: " + numberFormat);
15        
16        // 3. 字符串对齐和填充
17        String leftAlign = String.format("左对齐: %-10s", "Hello");
18        String rightAlign = String.format("右对齐: %10s", "World");
19        String centerAlign = String.format("居中: %10s", "Java");
20        
21        System.out.println(leftAlign + "|");
22        System.out.println(rightAlign + "|");
23        System.out.println(centerAlign + "|");
24        
25        // 4. 日期时间格式化
26        java.util.Date now = new java.util.Date();
27        String dateFormat = String.format("当前时间: %tF %tT", now, now);
28        System.out.println("日期时间格式化: " + dateFormat);
29        
30        // 5. 货币格式化
31        double amount = 1234567.89;
32        String currencyFormat = String.format("金额: $%,.2f", amount);
33        System.out.println("货币格式化: " + currencyFormat);
34        
35        // 6. 自定义格式化
36        String customFormat = String.format("自定义: %1$s的%2$s是%3$d", "张三", "年龄", 25);
37        System.out.println("自定义格式化: " + customFormat);
38    }
39}

5.3 字符串编码和国际化

字符串编码和国际化示例

java

1public class StringEncodingDemo {
2    public static void main(String[] args) throws Exception {
3        // 1. 不同编码的字符串处理
4        String original = "Hello 世界";
5        
6        // UTF-8编码
7        byte[] utf8Bytes = original.getBytes("UTF-8");
8        String utf8String = new String(utf8Bytes, "UTF-8");
9        System.out.println("UTF-8编码: " + utf8String);
10        System.out.println("UTF-8字节数: " + utf8Bytes.length);
11        
12        // GBK编码
13        byte[] gbkBytes = original.getBytes("GBK");
14        String gbkString = new String(gbkBytes, "GBK");
15        System.out.println("GBK编码: " + gbkString);
16        System.out.println("GBK字节数: " + gbkBytes.length);
17        
18        // 2. 编码问题演示
19        String chineseText = "你好世界";
20        
21        // 错误的编码转换
22        try {
23            byte[] wrongBytes = chineseText.getBytes("ISO-8859-1");
24            String wrongString = new String(wrongBytes, "ISO-8859-1");
25            System.out.println("错误编码结果: " + wrongString);
26        } catch (Exception e) {
27            System.out.println("编码错误: " + e.getMessage());
28        }
29        
30        // 3. 字符集检测
31        String[] charsets = {"UTF-8", "GBK", "ISO-8859-1", "UTF-16"};
32        String testString = "测试字符串";
33        
34        System.out.println("字符集兼容性测试:");
35        for (String charset : charsets) {
36            try {
37                byte[] bytes = testString.getBytes(charset);
38                String decoded = new String(bytes, charset);
39                System.out.println("  " + charset + ": " + decoded + " (兼容)");
40            } catch (Exception e) {
41                System.out.println("  " + charset + ": 不兼容");
42            }
43        }
44        
45        // 4. 国际化支持
46        java.util.Locale[] locales = {
47            java.util.Locale.US,
48            java.util.Locale.CHINA,
49            java.util.Locale.JAPAN,
50            java.util.Locale.GERMANY
51        };
52        
53        System.out.println("国际化测试:");
54        for (java.util.Locale locale : locales) {
55            System.out.println("  " + locale.getDisplayCountry() + " (" + locale.getLanguage() + "): " + 
56                             java.text.NumberFormat.getCurrencyInstance(locale).format(1234.56));
57        }
58    }
59}

6. 实际应用场景

6.1 文本处理工具

文本处理工具示例

java

1public class TextProcessingTools {
2    public static void main(String[] args) {
3        // 1. 文本统计工具
4        String text = "Hello World! This is a sample text for demonstration. " +
5                     "It contains multiple sentences and various punctuation marks.";
6        
7        TextStats stats = analyzeText(text);
8        System.out.println("文本统计结果:");
9        System.out.println("  字符数: " + stats.characterCount);
10        System.out.println("  单词数: " + stats.wordCount);
11        System.out.println("  句子数: " + stats.sentenceCount);
12        System.out.println("  行数: " + stats.lineCount);
13        
14        // 2. 文本清理工具
15        String dirtyText = "  Hello   World  !  \n\n  This   is   dirty   text.  ";
16        String cleanText = cleanText(dirtyText);
17        System.out.println("清理前: '" + dirtyText + "'");
18        System.out.println("清理后: '" + cleanText + "'");
19        
20        // 3. 文本搜索工具
21        String searchText = "Java is a programming language. Java is widely used.";
22        String searchTerm = "Java";
23        int[] positions = findTextPositions(searchText, searchTerm);
24        System.out.println("搜索词 '" + searchTerm + "' 出现位置:");
25        for (int pos : positions) {
26            System.out.println("  位置: " + pos);
27        }
28        
29        // 4. 文本替换工具
30        String template = "Hello {name}, welcome to {company}!";
31        String result = replacePlaceholders(template, "张三", "ABC公司");
32        System.out.println("模板替换结果: " + result);
33    }
34    
35    // 文本统计类
36    static class TextStats {
37        int characterCount, wordCount, sentenceCount, lineCount;
38    }
39    
40    // 分析文本统计信息
41    public static TextStats analyzeText(String text) {
42        TextStats stats = new TextStats();
43        
44        if (text == null || text.isEmpty()) {
45            return stats;
46        }
47        
48        stats.characterCount = text.length();
49        stats.wordCount = text.split("\\s+").length;
50        stats.sentenceCount = text.split("[.!?]+").length;
51        stats.lineCount = text.split("\n").length;
52        
53        return stats;
54    }
55    
56    // 清理文本
57    public static String cleanText(String text) {
58        if (text == null) return "";
59        
60        return text.trim()
61                  .replaceAll("\\s+", " ")  // 多个空白字符替换为单个空格
62                  .replaceAll("\\n\\s*\\n", "\n")  // 多个空行替换为单个空行
63                  .trim();
64    }
65    
66    // 查找文本位置
67    public static int[] findTextPositions(String text, String searchTerm) {
68        if (text == null || searchTerm == null || searchTerm.isEmpty()) {
69            return new int[0];
70        }
71        
72        java.util.List<Integer> positions = new java.util.ArrayList<>();
73        int index = 0;
74        
75        while ((index = text.indexOf(searchTerm, index)) != -1) {
76            positions.add(index);
77            index += searchTerm.length();
78        }
79        
80        return positions.stream().mapToInt(Integer::intValue).toArray();
81    }
82    
83    // 替换占位符
84    public static String replacePlaceholders(String template, String name, String company) {
85        return template.replace("{name}", name).replace("{company}", company);
86    }
87}

6.2 配置文件解析

配置文件解析示例

java

1public class ConfigFileParser {
2    public static void main(String[] args) {
3        // 模拟配置文件内容
4        String configContent = 
5            "# 数据库配置\n" +
6            "db.host=localhost\n" +
7            "db.port=3306\n" +
8            "db.username=admin\n" +
9            "db.password=123456\n" +
10            "\n" +
11            "# 应用配置\n" +
12            "app.name=MyApplication\n" +
13            "app.version=1.0.0\n" +
14            "app.debug=true\n" +
15            "app.timeout=30000";
16        
17        // 解析配置文件
18        java.util.Map<String, String> config = parseConfig(configContent);
19        
20        System.out.println("解析的配置:");
21        for (java.util.Map.Entry<String, String> entry : config.entrySet()) {
22            System.out.println("  " + entry.getKey() + " = " + entry.getValue());
23        }
24        
25        // 获取特定配置
26        System.out.println("\n数据库主机: " + config.get("db.host"));
27        System.out.println("应用名称: " + config.get("app.name"));
28        System.out.println("调试模式: " + config.get("app.debug"));
29        
30        // 类型转换
31        int port = Integer.parseInt(config.get("db.port"));
32        boolean debug = Boolean.parseBoolean(config.get("app.debug"));
33        long timeout = Long.parseLong(config.get("app.timeout"));
34        
35        System.out.println("\n类型转换结果:");
36        System.out.println("  端口号: " + port + " (int)");
37        System.out.println("  调试模式: " + debug + " (boolean)");
38        System.out.println("  超时时间: " + timeout + " (long)");
39    }
40    
41    // 解析配置文件
42    public static java.util.Map<String, String> parseConfig(String content) {
43        java.util.Map<String, String> config = new java.util.HashMap<>();
44        
45        if (content == null || content.isEmpty()) {
46            return config;
47        }
48        
49        String[] lines = content.split("\n");
50        
51        for (String line : lines) {
52            line = line.trim();
53            
54            // 跳过空行和注释行
55            if (line.isEmpty() || line.startsWith("#")) {
56                continue;
57            }
58            
59            // 解析键值对
60            int equalIndex = line.indexOf('=');
61            if (equalIndex > 0) {
62                String key = line.substring(0, equalIndex).trim();
63                String value = line.substring(equalIndex + 1).trim();
64                config.put(key, value);
65            }
66        }
67        
68        return config;
69    }
70}

7. 面试题精选

7.1 基础概念题

Q: String、StringBuilder、StringBuffer的区别是什么？

A: 三者的主要区别：

• String: 不可变类，线程安全，适合少量字符串操作
• StringBuilder: 可变类，非线程安全，性能最好，适合单线程环境
• StringBuffer: 可变类，线程安全，性能略低于StringBuilder，适合多线程环境

Q: 什么是字符串常量池？它有什么作用？

A: 字符串常量池是JVM中专门存储字符串字面量的内存区域，主要作用：

• 节省内存空间，避免重复创建相同内容的字符串对象
• 提高字符串比较效率，可以直接使用==比较
• 支持字符串的intern()操作

7.2 性能优化题

Q: 如何优化字符串操作的性能？

A: 字符串性能优化策略：

1. 使用StringBuilder进行大量字符串连接
2. 合理使用字符串常量池
3. 避免在循环中创建字符串对象
4. 使用String.join替代循环连接
5. 合理设置StringBuilder的初始容量

Q: 什么情况下使用intern()方法？

A: intern()方法适用于：

• 需要频繁比较的字符串
• 内存敏感的应用
• 字符串内容相对固定的场景
• 需要节省内存的场景

7.3 实践题

Q: 实现一个字符串反转方法，要求不使用额外空间

A:

java

1public class StringReversal {
2    public static String reverse(String str) {
3        if (str == null || str.length() <= 1) {
4            return str;
5        }
6        
7        char[] chars = str.toCharArray();
8        int left = 0, right = chars.length - 1;
9        
10        while (left < right) {
11            char temp = chars[left];
12            chars[left] = chars[right];
13            chars[right] = temp;
14            left++;
15            right--;
16        }
17        
18        return new String(chars);
19    }
20    
21    public static void main(String[] args) {
22        String test = "Hello World";
23        System.out.println("原字符串: " + test);
24        System.out.println("反转后: " + reverse(test));
25    }
26}

Q: 实现一个方法判断字符串是否为回文

A:

java

1public class PalindromeChecker {
2    public static boolean isPalindrome(String str) {
3        if (str == null) return false;
4        
5        // 移除所有非字母数字字符并转换为小写
6        String clean = str.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
7        
8        if (clean.isEmpty()) return true;
9        
10        int left = 0, right = clean.length() - 1;
11        
12        while (left < right) {
13            if (clean.charAt(left) != clean.charAt(right)) {
14                return false;
15            }
16            left++;
17            right--;
18        }
19        
20        return true;
21    }
22    
23    public static void main(String[] args) {
24        String[] tests = {
25            "A man, a plan, a canal: Panama",
26            "race a car",
27            "Was it a car or a cat I saw?",
28            "Hello World"
29        };
30        
31        for (String test : tests) {
32            System.out.println("'" + test + "' 是回文: " + isPalindrome(test));
33        }
34    }
35}

8. 总结

8.1 核心要点回顾

1. 不可变性: String对象一旦创建就不能修改，所有修改操作都返回新对象
2. 字符串常量池: JVM优化机制，避免重复创建相同内容的字符串
3. 性能考虑: 大量字符串操作时使用StringBuilder，少量操作使用String
4. 编码处理: 正确处理字符串编码，避免乱码问题
5. 最佳实践: 合理使用字符串方法，注意性能优化

8.2 学习建议

1. 深入理解内存机制: 掌握字符串在内存中的存储方式
2. 实践性能测试: 通过实际测试了解不同方法的性能差异
3. 关注新特性: 了解Java新版本中String类的改进
4. 实际项目应用: 在实际项目中应用字符串处理技巧

8.3 进阶方向

1. 文本分析算法: 学习字符串匹配、搜索等算法
2. 自然语言处理: 了解文本处理的更高级应用
3. 性能调优: 深入学习JVM调优和性能分析
4. 框架应用: 学习Spring等框架中的字符串处理

---

通过本章的学习，你应该已经掌握了Java String类的核心特性、使用方法和性能优化技巧。String类是Java编程中最基础也是最重要的类之一，良好的字符串处理能力是Java开发者的必备技能。

记住：选择合适的字符串处理方式，既能提高代码可读性，也能优化程序性能。

评论