深入理解String、StringBuffer 和 StringBuilder类的区别

小鲁蛋儿

已于 2023-07-28 11:26:55 修改

阅读量400

点赞数

分类专栏： Java基础文章标签： java

于 2022-08-23 12:20:05 首次发布

原文链接：https://cloud.tencent.com/developer/article/1414756

版权

Java基础专栏收录该内容

40 篇文章 3 订阅

订阅专栏

一、可变与不可变

二、字符串修改方式

三、是否实现了equals和hashCode方法

四、是否线程安全

五、为什么 StringBuffer 有 toStringCache 而 StringBuilder 没有？

六、总结

Java提供了String、StringBuffer和StringBuilder类来封装字符串，并提供了一系列操作字符串对象的方法。

StringBuffer 在 JDK 1 中就提出，而 StringBuilder 在 JDK 5 才被提出。

它们的相同点是都用来封装字符串；都实现了CharSequence接口。它们之间的区别如下：

一、可变与不可变

String类是一个不可变类，即创建String对象后，该对象中的字符串是不可改变的，直到这个对象被销毁。StringBuffer与StringBuilder都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，是可变类。

继承结构

value没有final声明，value可以不断扩容。

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    byte[] value;

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

    /**
     * The value is used for character storage.
     *
     * @implNote This field is trusted by the VM, and is a subject to
     * constant folding if String instance is constant. Overwriting this
     * field after construction will cause problems.
     *
     * Additionally, it is marked with {@link Stable} to trust the contents
     * of the array. No other facility in JDK provides this functionality (yet).
     * {@link Stable} is safe here, because value is never null.
     */
    @Stable
    private final byte[] value;

由于String是可变类，适合在需要被共享的场合中使用，当一个字符串经常被修改时，最好使用StringBuffer或StringBuilder实现。如果用String保存一个经常被修改的字符串，该字符串每次修改时都会创建新的无用的对象，这些无用的对象会被垃圾回收器回收，会影响程序的性能，不建议这么做。

二、字符串修改方式

String字符串修改方法是首先创建一个StringBuffer，其次调用StringBuffer的append方法，最后调用StringBuffer的toString()方法把结果返回，示例代码如下：

String str = "hello";
str += "java";

以上代码等价于下面的代码：

StringBuffer sb = new StringBuffer(str);
sb.append("java");
str = sb.toString();

上述String字符串的修改过程要比StringBuffer多一些额外操作，会增加一些临时的对象，从而导致程序的执行效率降低。StringBuffer和StringBuilder在修改字符串方面比String的性能要高。

三、是否实现了equals和hashCode方法

String实现了equals()方法和hashCode()方法

new String("java").equals(new String("java"))

结果为true

而 StringBuffer 和 StringBuilder 没有实现equals()方法和hashCode()方法

new StringBuffer("java").equals(new StringBuffer("java"))

结果为false

四、是否线程安全

StringBuffer与StringBuilder都提供了一系列插入、追加、改变字符串里的字符序列的方法，它们的用法基本相同，只是StringBuilder是线程不安全的，StringBuffer是线程安全的。如果只是在单线程中使用字符串缓冲区，则StringBuilder的效率会高些，但是当多线程访问时，最好使用StringBuffer。

因为 StringBuffer 的所有公开方法都是 synchronized 修饰的，而 StringBuilder 并没有。

分析源码

    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

对比执行效率

    @Test
    public void test3(){
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
//开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));
    }

StringBuffer的执行时间：7
StringBuilder的执行时间：4
String的执行时间：271

综上，在执行效率方面，StringBuilder最高，StringBuffer次之，String最低，对于这种情况，一般而言，如果要操作的数量比较小，应优先使用String类；如果是在单线程下操作大量数据，应优先使用StringBuilder类；如果是在多线程下操作大量数据，应优先使用StringBuilder类。

五、为什么 StringBuffer 有 toStringCache 而 StringBuilder 没有？

对比 StringBuilder 和 StringBuffer 的源码会发现，StringBuffer 中有一个叫 toStringCache 的成员变量，用来缓存 toString() 方法返回字符串对应的字符数组，而在 StringBuilder 里面却没有。

先看一下代码：

StringBuilder片段：

    public String toString() {
        // Create a copy, don't share the array
        return isLatin1() ? StringLatin1.newString(value, 0, count)
                          : StringUTF16.newString(value, 0, count);
    }

StringBuffer片段：

    public synchronized String toString() {
        if (toStringCache == null) {
            return toStringCache =
                    isLatin1() ? StringLatin1.newString(value, 0, count)
                               : StringUTF16.newString(value, 0, count);
        }
        return new String(toStringCache);
    }

StringBuffer 中的 toStringCache 是字节数组 value 复制的一个副本，每当 StringBuffer 对象发生改变，toStringCache 都会被置为空，再调用 toString() 方法就产生一个新的 toStringCache 数组。

比如它的添加操作，修改某个字符的操作

    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

    public synchronized void setCharAt(int index, char ch) {
        toStringCache = null;
        super.setCharAt(index, ch);
    }

从源码中可以知道，StringBuffer 中使用 toStringCache 通过共享一个字符数组，提供构造 String 的速度。但是，这个好处仅仅是在多次调用 toString() 方法且 StringBuffer 对象没有发生改变时才能体现。而实际编写代码的过程中，很少会在没有修改 StringBuffer 的情况下重复调用 toString() 方法，所以它并没有太大的实际作用。

之所以它存在 JDK 源码里，有人解释是由于历史代码遗留的原因，现在不修改是因为它没有什么坏处，修改了反而需要重新测试代码。