String、StringBuilder、StringBuffer 的区别？

参考回答

String、StringBuilder 和 StringBuffer 是 Java 中常用的字符串处理类，它们的主要区别如下：

1. String
   • 不可变：String 是不可变类，每次对字符串的修改都会生成新的字符串对象。
   • 线程安全：因为不可变，所以天然线程安全。
   • 性能：由于每次修改都会创建新对象，频繁操作时效率较低。
2. StringBuilder
   • 可变：StringBuilder 是可变类，对字符串的操作会直接在原对象上修改。
   • 线程不安全：不适用于多线程场景。
   • 性能：在单线程环境中，操作效率比 String 和 StringBuffer 高。
3. StringBuffer
   • 可变：和 StringBuilder 类似，也是可变类。
   • 线程安全：通过同步方法实现线程安全，适用于多线程场景。
   • 性能：由于线程安全机制的开销，操作效率比 StringBuilder 略低。

适用场景：

• 如果字符串内容 不会改变，用 String。
• 如果字符串内容会频繁修改，且在 单线程 环境下使用，选 StringBuilder。
• 如果字符串内容会频繁修改，且在 多线程 环境下使用，选 StringBuffer。

详细讲解与拓展

1. String 的特点

• 不可变性：

  String
  

  对象一旦创建，内容就无法修改。对字符串的任何修改（如拼接、替换）都会生成一个新的对象。

  优点：

  • 线程安全。
  • 可用于字符串常量池，提高内存使用效率。 缺点：
  • 频繁修改字符串时会产生大量临时对象，导致性能较差。

示例代码：

public class Main {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = s1.concat(" world"); // 拼接字符串
        System.out.println(s1); // 输出：hello（s1 不变）
        System.out.println(s2); // 输出：hello world
    }
}

注意：

• String 的不可变性适合用于 常量、配置值 等不需要修改的场景。

2. StringBuilder 的特点

• 可变性：

  StringBuilder
  

  对象内部维护一个可变的字符数组，修改字符串时直接操作数组，不会生成新对象。

  优点：

  • 性能高，特别适合在单线程环境下处理大量字符串操作。 缺点：
  • 非线程安全，不能用于多线程场景。

示例代码：

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("hello");
        sb.append(" world"); // 直接修改原对象
        System.out.println(sb); // 输出：hello world
    }
}

适用场景：

• 适用于 单线程 环境下的频繁字符串操作（如拼接、插入、删除）。

3. StringBuffer 的特点

• 线程安全：StringBuffer

  通过加锁机制（synchronized）保证线程安全，适用于多线程环境。

  优点：

  • 能在多线程中安全使用。 缺点：
  • 同步的开销导致性能比 StringBuilder 略低。

示例代码：

public class Main {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("hello");
        sb.append(" world"); // 直接修改原对象
        System.out.println(sb); // 输出：hello world
    }
}

适用场景：

• 适用于 多线程 环境下的频繁字符串操作。

性能对比

示例对比

拼接 10,000 次字符串的性能测试：

public class Main {
    public static void main(String[] args) {
        long startTime, endTime;

        // 使用 String
        startTime = System.currentTimeMillis();
        String str = "hello";
        for (int i = 0; i < 10000; i++) {
            str += " world";
        }
        endTime = System.currentTimeMillis();
        System.out.println("String time: " + (endTime - startTime) + "ms");

        // 使用 StringBuilder
        startTime = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder("hello");
        for (int i = 0; i < 10000; i++) {
            sb.append(" world");
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder time: " + (endTime - startTime) + "ms");

        // 使用 StringBuffer
        startTime = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("hello");
        for (int i = 0; i < 10000; i++) {
            sbf.append(" world");
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer time: " + (endTime - startTime) + "ms");
    }
}

可能的输出结果：

String time: 1200ms
StringBuilder time: 10ms
StringBuffer time: 15ms

原因：

• String 每次拼接都会创建新的对象，效率最低。
• StringBuilder 和 StringBuffer 直接修改对象，效率较高，但 StringBuffer 由于线程安全的开销，性能略低于 StringBuilder。

拓展知识

1. 字符串常量池

• String 的不可变性使得它可以存储在字符串常量池中，避免重复创建相同内容的对象。

• 例如：

  “`java
  String s1 = "hello";
  String s2 = "hello";
  System.out.println(s1 == s2); // true，指向同一个常量池对象
  “`

2. 多线程下的优化

• 如果使用 StringBuffer 的性能仍不够理想，可以考虑其他线程安全的工具（如 ConcurrentLinkedQueue 或 StringBuilder 的局部实例）。

3. 选择的建议

• String：适合少量、不变的字符串操作（如配置、日志信息等）。
• StringBuilder：单线程环境下频繁修改字符串的最佳选择。
• StringBuffer：多线程环境下频繁修改字符串时使用。

shuaidi永久会员

收藏 海报挣佣金 推广链接