String、StringBuilder和StringBuffer的区别

String、StringBuilder和StringBuffer都是Java中用于处理字符串的类，但它们在可变性、线程安全性和性能方面有显著区别。

1. 可变性

String

• 不可变(Immutable)：String对象一旦创建就不能被修改。
• 任何对String的修改操作都会创建一个新的String对象。

String str = "hello";
str = str + " world"; // 创建了一个新的String对象，原对象不变

StringBuilder

• 可变(Mutable)：StringBuilder对象创建后可以被修改。
• 不会创建新对象，而是在原对象上进行修改。

StringBuilder sb = new StringBuilder("hello");
sb.append(" world"); // 在原对象上修改，没有创建新对象

StringBuffer

• 可变(Mutable)：与StringBuilder类似，StringBuffer对象创建后可以被修改。
• 不会创建新对象，而是在原对象上进行修改。

StringBuffer sbf = new StringBuffer("hello");
sbf.append(" world"); // 在原对象上修改，没有创建新对象

2. 线程安全性

String

• 线程安全：由于String是不可变的，所以它是线程安全的。
• 多个线程可以同时访问同一个String对象，不会引起数据不一致问题。

StringBuilder

• 非线程安全：StringBuilder的方法没有同步机制。
• 不适合多线程环境：在多线程环境下同时操作一个StringBuilder对象可能会导致数据不一致。

StringBuffer

• 线程安全：StringBuffer的方法都使用synchronized关键字进行了同步。
• 适合多线程环境：多个线程可以安全地操作同一个StringBuffer对象。

// StringBuffer的部分方法实现
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

public synchronized StringBuffer delete(int start, int end) {
    toStringCache = null;
    super.delete(start, end);
    return this;
}

3. 性能

String

• 性能最低：每次修改都会创建新对象，导致内存开销大，效率低。
• 适用场景：适用于少量字符串操作或需要不可变性的场景。

StringBuilder

• 性能最高：没有同步开销，直接在原对象上修改。
• 适用场景：适用于单线程环境下的大量字符串操作。

StringBuffer

• 性能中等：由于同步机制的存在，性能低于StringBuilder但高于String。
• 适用场景：适用于多线程环境下需要频繁修改字符串的场景。

4. 使用场景对比

5. 继承关系

6. 实际应用示例

String的使用场景

// 作为常量
public static final String APPLICATION_NAME = "MyApp";

// 少量字符串操作
String greeting = "Hello";
greeting = greeting + ", " + "World";  // 少量拼接可以接受

// 作为HashMap的键
Map<String, Integer> wordCount = new HashMap<>();
wordCount.put("apple", 5);

StringBuilder的使用场景

// 单线程环境下大量字符串拼接
public String generateReport() {
    StringBuilder sb = new StringBuilder();
    sb.append("Report Title\n");
    sb.append("------------\n");
    
    for (int i = 0; i < 1000; i++) {
        sb.append("Item ").append(i).append(": ").append(getData(i)).append("\n");
    }
    
    return sb.toString();
}

StringBuffer的使用场景

// 多线程环境下共享字符串拼接
public class LogCollector {
    private final StringBuffer logBuffer = new StringBuffer();
    
    public void addLog(String message) {
        // 多个线程可以安全地调用此方法
        logBuffer.append(LocalDateTime.now()).append(": ").append(message).append("\n");
    }
    
    public String getLogs() {
        return logBuffer.toString();
    }
}

7. 性能测试对比

public class StringPerformanceTest {
    private static final int ITERATIONS = 100000;
    
    public static void main(String[] args) {
        // String拼接测试
        long startTime = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < ITERATIONS; i++) {
            str += "a";
        }
        long endTime = System.currentTimeMillis();
        System.out.println("String拼接耗时: " + (endTime - startTime) + "ms");
        
        // StringBuilder拼接测试
        startTime = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < ITERATIONS; i++) {
            sb.append("a");
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder拼接耗时: " + (endTime - startTime) + "ms");
        
        // StringBuffer拼接测试
        startTime = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer();
        for (int i = 0; i < ITERATIONS; i++) {
            sbf.append("a");
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer拼接耗时: " + (endTime - startTime) + "ms");
    }
}

运行结果通常显示StringBuilder最快，StringBuffer稍慢，而String最慢（在大量拼接时）。

总结

• String：不可变、线程安全、性能低，适合少量操作和常量定义。
• StringBuilder：可变、非线程安全、性能高，适合单线程环境下大量字符串操作。
• StringBuffer：可变、线程安全、性能中等，适合多线程环境下大量字符串操作。

在实际开发中，应根据具体场景选择合适的类。在单线程环境下，优先使用StringBuilder；在多线程环境下需要共享字符串操作时，使用StringBuffer；当字符串不需要修改时，使用String。

参考文档：

• Oracle Java文档：String
• Oracle Java文档：StringBuilder
• Oracle Java文档：StringBuffer