【JDK源码】StringBuffer类源码分析

Java中的String类是用来创建不可变的字符串，每次追加字符串都要创建新的String对象，而Java中对象的每次创建都需要开辟内存空间来存储，这无疑是一种低效率而又耗内存的方式。StringBuffer类、StringBuilder类都能创建可变的字符串，每次追加字符串不再有创建新字符串对象的问题了，另外，二者在线程安全方面还存在差异，通过StringBuffer类源码分析来一探究竟。

目录

源码分析

1、构造方法

2、操作字符串的API

3、重写的Object方法

---

源码分析

1、构造方法

 /**
  * StringBuffer的父类为AbstractStringBuilder，重写了许多父类的方法。
 **/
public final class StringBuffer extends AbstractStringBuilder
     implements java.io.Serializable, CharSequence{ 
    /**
     * StringBuffer构造器的三种形式 均是通过super()调用父类构造器定义的，本质是初始化一个字符数组：
     *    char[] value = new char[capacity]; 默认容量大小为16。
    **/
     // 无参
     public StringBuffer() {super(16);}
         
     // 传入字符串
     public StringBuffer(String str) {
        super(str.length() + 16);
        append(str); //append()是个同步方法，看下面的操作字符串的API源码分析
    }

    // 传入字符序列
    public StringBuffer(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }
    public StringBuffer(int capacity) {super(capacity);}
}

小结一下：

• StringBuffer类的构造器，本质上也是通过维护一个字符数组value[]来存储字符的，这里可以把该字符数组理解为是一个字符串缓存区，默认缓冲区容量大小为16；

2、操作字符串的API

说明：字符串的添加，删除，替换，查找，截取，替换，反转等操作。

 public final class StringBuffer extends AbstractStringBuilder
     implements java.io.Serializable, CharSequence{
     private transient char[] toStringCache; // 看样子是没啥作用，可能会当作一种缓存使用

    /**
     * append()是一个同步方法，线程安全，作用是将内容追加到StringBuffer，可追加的类型有：
     *   boolean、char、int、long、float、double、char[]、CharSequence、Object、String、StringBuffer、AbstractStringBuilder等，
     *   StringBuffer类几乎都是重写父类ASB中的append()，而父类ASB几乎是重写Appendable接口中的append()方法。
     *     然而无论追加的内容是哪种类型，父类在实现逻辑后返回的都是this当前对象，没有新的对象产生。
    **/
    @Override
    public synchronized StringBuffer append(xxx x) { //xxx表示追加的类型
        toStringCache = null; 
        super.append(x);
        return this;
    }

    /**
     * insert()也是一个含有线程同步的方法，作用也是将内容追加到StringBuffer,
     *    它也是几乎重写了父类ASB中的insert()，父类具体实现了业务逻辑，insert()存在线程安全与非安全的两类方法，参数有所区别
     *     可追加的类型有：String、char[]、char等等。
     **/
    @Override
    public synchronized StringBuffer insert(int offset, xxx x) {
        toStringCache = null;
        super.insert(offset, x);
        return this;
    }

    /**
     * 非线程安全的insert()可追加的类型有：boolean、int、long、float、double、CharSequence等
     **/
    @Override
    public StringBuffer insert(int offset, xxx x) {
        // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
        // after conversion of i to String by super class method
        // Ditto for toStringCache clearing
        super.insert(offset, x);
        return this;
    }

    /**
     * deleteCharAt()删除单个字符、delete()删除字符串，均为同步方法
     **/
    @Override
    public synchronized StringBuffer deleteCharAt(int index) {
        toStringCache = null;
        super.deleteCharAt(index);
        return this;
    }
    @Override
    public synchronized StringBuffer delete(int start, int end) {
        toStringCache = null;
        super.delete(start, end);
        return this;
    }

    /**
     * 截取字符串 或 字符序列，均为同步方法，均会产生新的String对象
     **/
    @Override
    public synchronized String substring(int start) {
        return substring(start, count);
    }
    @Override
    public synchronized String substring(int start, int end) {
        return super.substring(start, end); // 本质为父类ABS的：return new String(value, start, end - start);
    }
    @Override
    public synchronized CharSequence subSequence(int start, int end) {
        return super.substring(start, end);
    }

    /**
     * 替换字符串，为同步方法，但不会产生新的String对象
     **/
    @Override
    public synchronized StringBuffer replace(int start, int end, String str) {
        toStringCache = null;
        super.replace(start, end, str); //父类ABS：return this;
        return this;
    }

    /**
     * 从前往后查找字符串indexOf()，存在同步方法和非同步方法，底层调用String.indexOf()
     **/
    @Override
    public int indexOf(String str) {
        // Note, synchronization achieved via invocations of other StringBuffer methods
        return super.indexOf(str);
    }
    @Override
    public synchronized int indexOf(String str, int fromIndex) {
        return super.indexOf(str, fromIndex);
    }
    /**
     * 从后往前查找字符串lastIndexOf()，同步方法，底层调用String.lastIndexOf()
     **/
    @Override
    public int lastIndexOf(String str) {
        // Note, synchronization achieved via invocations of other StringBuffer methods
        return lastIndexOf(str, count);
    }
    @Override
    public synchronized int lastIndexOf(String str, int fromIndex) {
        return super.lastIndexOf(str, fromIndex);
    }

    /**
     * 字符串反转，同步方法，不会产生新的String对象
     **/
    @Override
    public synchronized StringBuffer reverse() {
        toStringCache = null;
        super.reverse(); // 父类ABS：return this;
        return this;
    }
}

小结一下：

• StringBuffer类绝大多数的方法都是同步的，因此使用StringBuffer操作字符串是线程安全的；
• 之所以说StringBuffer类创建的是可变字符串，是通过append方法或insert方法实现的。追加的类型有很多种，追加的逻辑都是在其父类ABS内实现，而且父类返回的this对象指的就是字符数组vaule[]，而构造器里维护的也是父类的字符数组vaule[]，所以API操作的是一个对象，当然不会产生新的String对象。

3、重写的Object方法

说明：StringBuffer类没有重写equals()/hashCode() ，因此用equals()比较两个StringBuffer对象时，比较的是对象引用（即对象在内存中的地址）而非对象的内容。未重写equals()，和==没有区别。

 public final class StringBuffer extends AbstractStringBuilder
     implements java.io.Serializable, CharSequence{
    // 重写了toString()，并未重写equals()/hashCode() 
    @Override
    public synchronized String toString() {
        if (toStringCache == null) {
            toStringCache = Arrays.copyOfRange(value, 0, count);
        }
        return new String(toStringCache, true);
    }
}

StringBuffer类的源码分析到此，与String类相比最大的不同在于以下几点：

• StringBuffer创建的是可变字符串，追加删除等操作不会产生新的String对象；
• StringBuffer类中的方法几乎都是synchronized的，多线程环境中操作字符串时线程是安全的；
• StringBuffer类没有重写equals()和hashCode()，进行StringBuffer对象比较时，和==结果一样，比较的是对象的内存地址。

这里并没有分析父类AbstractStringBuilder实现append()的逻辑，以及追加方法涉及到的扩容机制，准备把这个过程放在StringBuilder类源码分析中进行，StringBuilder类除了非同步的特点外，所有的API实现逻辑是和StringBuffer类一模一样的。