String 字符串修改实现的原理？

参考回答

String 是不可变类（Immutable），它的内容在创建后不能被修改。因此，所谓的字符串“修改”并不是直接修改字符串的内容，而是创建了一个新的字符串对象，原字符串对象保持不变。

例如：

String str = "Hello";
str = str + " World";

在这个例子中，str + " World" 会创建一个新的字符串对象，并将其赋值给 str，而原来的字符串 "Hello" 不会被修改。

详细讲解与拓展

1. 为什么 String 是不可变的？

在 Java 中，String 的底层实现是基于一个 final 修饰的 char[] 数组：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[]; // 字符数组存储字符串内容
    private int hash;           // 缓存的哈希值
}

• final 修饰的数组：一旦 String 对象被创建，其底层字符数组的引用无法更改。
• 不可变的设计：使得字符串能够安全地被多个线程共享，同时保证了常量池中的字符串不会被意外修改。

2. 字符串“修改”的原理

字符串的常见“修改”操作（如拼接、替换等）实际上都是通过创建新的字符串对象实现的。

示例 1：字符串拼接

String str = "Hello";
str = str + " World";

过程：

1. "Hello" 是原始字符串对象，存储在堆中。
2. " World" 是另一个字符串。
3. 拼接操作会在堆中创建一个新的字符串对象 "Hello World"。
4. str 的引用被更新为新的字符串对象。

问题：如果频繁修改字符串，会导致大量临时对象的创建和内存浪费。

示例 2：字符串替换

String str = "Hello";
String newStr = str.replace("H", "J");

过程：

1. 原始字符串 "Hello" 不会改变。
2. replace 方法会在堆中创建一个新的字符串 "Jello"，并返回这个新对象。

源码分析（String.replace 方法）：

public String replace(char oldChar, char newChar) {
    if (oldChar != newChar) {
        char[] value = this.value; // 获取原字符串的字符数组
        int len = value.length;
        for (int i = 0; i < len; i++) {
            if (value[i] == oldChar) {
                char[] buf = new char[len];
                System.arraycopy(value, 0, buf, 0, len);
                buf[i] = newChar;
                for (int j = i + 1; j < len; j++) {
                    if (value[j] == oldChar) {
                        buf[j] = newChar;
                    }
                }
                return new String(buf); // 创建新字符串对象
            }
        }
    }
    return this; // 如果没有修改，返回当前对象
}

3. 解决字符串频繁修改问题

由于每次修改字符串都会创建新对象，因此在需要频繁修改字符串的场景中，推荐使用 StringBuilder 或 StringBuffer。

StringBuilder 示例

StringBuilder 是可变字符串类，底层使用一个可扩展的 char[] 数组来存储字符串内容。它不会每次修改都创建新对象，而是直接修改数组中的内容。

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // 修改原始对象
System.out.println(sb.toString()); // 输出 "Hello World"

源码分析（StringBuilder.append 方法）：

public AbstractStringBuilder append(String str) {
    if (str == null) str = "null";
    int len = str.length();
    ensureCapacityInternal(count + len); // 确保数组容量足够
    str.getChars(0, len, value, count); // 将字符串内容复制到字符数组
    count += len;
    return this;
}

StringBuffer 示例

StringBuffer 与 StringBuilder 类似，但它是线程安全的，所有方法都加了同步锁。

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World"); // 修改原始对象
System.out.println(sb.toString()); // 输出 "Hello World"

4. 性能对比

• String：
  • 每次修改都会创建新对象，适合少量、不频繁修改的场景。
• StringBuilder：
  • 非线程安全，但性能更高，适合单线程场景下的频繁字符串修改。
• StringBuffer：
  • 线程安全，但性能较 StringBuilder 略低，适合多线程场景。

5. 拓展知识

1. StringBuilder 的动态扩展机制

• StringBuilder 的初始容量是 16，当字符数组不足时，会自动扩展，新的容量为：(oldCapacity * 2) + 2。

• 示例：

  “`java
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < 100; i++) {
  sb.append(i);
  }
  System.out.println(sb.toString());
  “`

2. Java 9 的优化

• 从 Java 9 开始，String 的底层实现从 char[] 改为 byte[]，以节省内存开销。

3. 编译器优化

• 对于常量字符串拼接（如 "Hello" + "World"），Java 编译器会在编译期优化，将其直接合成为 "HelloWorld"，避免运行时创建额外对象。

6. 总结

• String 是不可变类，任何修改操作都会创建新的字符串对象。
• 底层是基于一个 final char[] 数组实现的，保证内容不可修改。
• 频繁修改字符串时，推荐使用 StringBuilder 或 StringBuffer，以提高性能并减少内存消耗。
• 对于字符串的操作，理解其不可变特性有助于编写更高效和安全的代码。

shuaidi永久会员

收藏 海报挣佣金 推广链接