Java基础学习总结（65）——Java中的String,StringBuilder和StringBuffer比较

字符串，就是一系列字符的集合。

Java里面提供了String，StringBuffer和StringBuilder三个类来封装字符串，其中StringBuilder类是到jdk 1.5才新增的。字符串操作可以说是几乎每门编程语言中所必不可少的，你真的理解其内幕吗？

下面让我们开始探秘之旅吧！

1、既然都是用来封装字符串的，那为什么还要3个类来封装呢？

2、它们三者之间到底有何区别？

3、它们三者之间的使用场景分别是什么？

4、它们三者之间从内存角度来看又是怎么来实现的呢？

5、它们三者之间的性能效率是怎么排列的？

下面就让我们逐一破解这几个谜团吧！

一、概述

字符串是由若干个字符线性排列组成的，所以我们可以把字符串当作数组（Array）来看待。众所周知，数组就是内存里线性排列的有序地址空间块。既然是线性排列，有序的一组地址块，那么在分配数组空间时就必须指定空间大小也就是数组大小，这也是大多数编程语言里规定在定义数组时要指定数组大小的原因（ 某些编程语言中可变数组的实现另当别论 ）。换言之，
数组就分为可变数组和不可变数组。可变数组能够动态插入和删除，而不可变数组一旦分配好空间后则不能进行动态插入或删除操作。

二、从实际应用可能的场景中分析String,StringBuilder,StringBuffer产生的背景

在实际应用当中我们可能会对字符串经常做如下几种操作：插入，删除，修改，拼接，截取，查到，替换……其中，“插入”和“删除”操作就涉及到对 原字符串的长度 进行修改（ 其实，“拼接”和“截取”也分为可以理解为插入和删除操作 ）。

然而，在jdk 1.0中就出现的 String类封装的字符串是不可变的 ，即不能在原字符串上进行 插入 和删除 操作，String的API是通过新建临时变量的方式来实现字符串的插入和删除操作。因为是新建临时变量，所以
当你调用String类的API对字符串进行插入和删除操作时原来的字符串是不会有任何改变的，返回给你的是一个新的字符串对象 。关于这一点，我们将在后面通过分析源码的方式来证实！既然String类封装的是不可变数组，那么对应的就应该有一个类来封装可变数组。没错！ StringBuffer类封装的就是可变数组，并且还是线程安全的。 所以，在非多线程环境下效率相对较低。正如大家所想的一样，JDK里也提供了非多线程环境下使用的可变字符串的封装类，它就是在jdk 1.5里面才姗姗来迟的StringBuilder类， StringBuilder类是非线程安全的可变字符串封装类 ，也是我们今天要讨论的成员之一。

到此，我们基本上就已经回答了在文章开始处提出的第1，2，3个问题。接下来，我们再从源码的角度来更深入讨论。

三、从源码角度进一步探讨其内部实现方式

1、String类的关键源码分析如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
   private final char value[];//final类型char数组
//省略其他代码……
……
}

从上述的代码片段中我们可以看到，String类在类开始处就定义了一个final 类型的char数组value。也就是说通过 String类定义的字符串中的所有字符都是存储在这个final
类型的char数组中的。

下面我们来看一下String类对字符串的截取操作，关键源码如下：

public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
       //当对原来的字符串进行截取的时候（beginIndex >0），返回的结果是新建的对象
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

当我们对字符串从第beginIndex（beginIndex >0） 个字符开始进行截取时，返回的结果是重新new出来的对象。所以，在对String类型的字符串进行大量“插入”和“删除”操作时会产生大量的临时变量。

2、StringBuffer和StringBuilder类关键源码分析：

在进行这两个类的源码分析前，我们先来分析下一个抽象类AbstractStringBuilder，因为，StringBuffer和StringBuilder都继承自这个抽象类，即AbstractStringBuilder类是StringBuffer和StringBuilder的共同父类。AbstractStringBuilder类的关键代码片段如下：

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;//一个char类型的数组，非final类型，这一点与String类不同
    /**
     * This no-arg constructor is necessary for serialization of subclasses.
     */
    AbstractStringBuilder() {
    }
    /**
     * Creates an AbstractStringBuilder of the specified capacity.
     */
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];//构建了长度为capacity大小的数组
    }
//其他代码省略……
……
}

StringBuffer类的关键代码如下：

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
   /**
     * Constructs a string buffer with no characters in it and an
     * initial capacity of 16 characters.
     */
    public StringBuffer() {
        super(16);//创建一个默认大小为16的char型数组
    }
    /**
     * Constructs a string buffer with no characters in it and
     * the specified initial capacity.
     *
     * @param      capacity  the initial capacity.
     * @exception  NegativeArraySizeException  if the {@code capacity}
     *               argument is less than {@code 0}.
     */
    public StringBuffer(int capacity) {
        super(capacity);//自定义创建大小为capacity的char型数组
    }
//省略其他代码……
……

StringBuilder类的构造函数与StringBuffer类的构造函数实现方式相同，此处就不贴代码了。

下面来看看StringBuilder类的append方法和insert方法的代码，因StringBuilder和StringBuffer的方法实现基本上一致，不同的是StringBuffer类的方法前多了个synchronized关键字，即StringBuffer是线程安全的。所以接下来我们就只分析StringBuilder类的代码了。StringBuilder类的append方法，insert方法都是Override
父类AbstractStringBuilder的方法，所以我们直接来分析AbstractStringBuilder类的相关方法。

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
       //调用下面的ensureCapacityInternal方法
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }
private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0)
           //调用下面的expandCapacity方法实现“扩容”特性
            expandCapacity(minimumCapacity);
    }
   /**
     * This implements the expansion semantics of ensureCapacity with no
     * size check or synchronization.
     */
    void expandCapacity(int minimumCapacity) {
       //“扩展”的数组长度是按“扩展”前数组长度的2倍再加上2 byte的规则来扩展
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        //将value变量指向Arrays返回的新的char[]对象，从而达到“扩容”的特性
        value = Arrays.copyOf(value, newCapacity);
    }

从上述代码分析得出，StringBuilder和StringBuffer的append方法“扩容”特性本质上是通过调用Arrays类的copyOf方法来实现的。接下来我们顺藤摸瓜，再分析下Arrays.copyOf(value,
newCapacity)这个方法吧。代码如下：

public static char[] copyOf(char[] original, int newLength) {
        //创建长度为newLength的char数组，也就是“扩容”后的char 数组，并作为返回值
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;//返回“扩容”后的数组变量
    }

其中，insert方法也是调用了expandCapacity方法来实现“扩容”特性的，此处就不在赘述了。

接下来，分析下delete(int start, int end)方法，代码如下：

public AbstractStringBuilder delete(int start, int end) {
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            end = count;
        if (start > end)
            throw new StringIndexOutOfBoundsException();
        int len = end - start;
        if (len > 0) {
            //调用native方法arraycopy对value数组进行复制操作，然后重新赋值count变量达到“删除”特性
            System.arraycopy(value, start+len, value, start, count-end);
            count -= len;
        }
        return this;
    }

从源码可以看出delete方法的“删除”特性是调用native方法arraycopy对value数组进行复制操作，然后重新赋值count变量实现的

最后，来看下substring方法，源码如下 ：

public String substring(int start, int end) {
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            throw new StringIndexOutOfBoundsException(end);
        if (start > end)
            throw new StringIndexOutOfBoundsException(end - start);
        //根据start,end参数创建String对象并返回
        return new String(value, start, end - start);
    }

四、总结：

1、String类型的字符串对象是不可变的，一旦String对象创建后，包含在这个对象中的字符系列是不可以改变的，直到这个对象被销毁。

2、StringBuilder和StringBuffer类型的字符串是可变的，不同的是StringBuffer类型的是线程安全的，而StringBuilder不是线程安全的

3、如果是多线程环境下涉及到共享变量的插入和删除操作，StringBuffer则是首选。如果是非多线程操作并且有大量的字符串拼接，插入，删除操作则StringBuilder是首选。毕竟String类是通过创建临时变量来实现字符串拼接的，耗内存还效率不高，怎么说StringBuilder是通过JNI方式实现终极操作的。

4、StringBuilder和StringBuffer的“可变”特性总结如下：

（1）append，insert，delete方法最根本上都是调用System.arraycopy()这个方法来达到目的

（2）substring(int, int)方法是通过重新new String(value, start, end - start)的方式来达到目的。因此，在执行substring操作时，StringBuilder和String基本上没什么区别。