在Java中字符串的使用非常广泛，我们常用的如：String ,StringBuffer, StringBuilder.但是一直都没有系统的整理过他们的区别，今天就系统的整理一下，记录自己的学习历程。

一：String

---

首先我们看下String的源码：

public final class String implementsjava.io.Serializable, Comparable, CharSequence

从String的类声明上就可以发现，String是一个类而不是基本数据类型。

既然是一个类，那String的使用也很简单，直接new就可以了。

String可以通过 “+ “来完成字符串的拼接，那我们来做个测试：

使用是很简单，但是通过我们上面的测试发现一个问题就是，当我们 给str + “test”后，他的hashCode发生了变化，说明了第10行的str已经是一个新的对象了。

在String的源码中维护了一个finalchar value[],如下：

private final charvalue[];

所以从源码中我们可以发现，value是final类型的，是不能被改变的，所以只要改变就只能生一个新的String对象。也可以说String类型的对象是长度不可变的，String拼接字符串每次都要生成一个新的对象，所以拼接字符串的效率也比较低。

二：StringBuffer

---

首先我们看下StringBuffer的源码：

public final class StringBuffer extends AbstractStringBuilder

                 implementsjava.io.Serializable, CharSequence

从源码中我们可以看出，StringBuffer也是一个final class,也不能被继承。既然是类，那使用也一样直接new一个对象出来。

StringBuffer是通过.append 来完成字符串的拼接，那让我们来做个测试

从我们的测试来看，StringBuffer和 String 类是不同的，因为StringBuffer被修改后并没有产生新的对象，是在之前的对象上修改的。下面我们来看下部分源码：

   publicStringBuffer() {

      super(16);

     }

    public StringBuffer append(CharSequence s) {

         if (s == null) s = "null";

         if (s instanceofString) return this.append((String)s);

         if (s instanceofStringBuffer) return this.append((StringBuffer)s);

          return this.append(s, 0, s.length());

     }

     public synchronized StringBuffer append(CharSequence s, int start, intend)

     {

        super.append(s, start, end);

        return this；

     }

 从上面的代码中可以看出来，StringBuffer的初始容量可以容纳16个字符，当该对象的实体存放的字符的长度大于16时，实体容量就自动增加。

StringBuffer的函数都是加了Synchronized关键字的，所以StringBuffer的方法是线程安全的，可以在多线程中使用。

总结：

如果对字符串的改变少，使用String；

如果对字符串修改的较多或需要线程安全就用StringBuffer，

三：StringBuilder

---

首先我们看下StringBuilder的源码：

public final class StringBuilder extends AbstractStringBuilder 

                        implements java.io.Serializable, CharSequence

从源码中我们可以看出，StringBuilder和StringBuffer一样，也是一个final class,也不能被继承。既然是类，那使用也一样直接new一个对象出来。

StringBuilder是通过.append 来完成字符串的拼接，那让我们来做个测试

从上面的测试我门可以发现StringBuilder 类的对象能够被多次的修改，并且不产生新对象。

下面我们来看下部分源码：

 public StringBuilder(String str) {

         super(str.length() + 16);

         append(str);

    }

   private StringBuilder append(StringBuilder sb) {

         if (sb == null) returnappend("null");

         int len = sb.length();

         int newcount = count + len;

         if(newcount > value.length)

             expandCapacity(newcount);

         sb.getChars(0, len, value, count);

         count = newcount;

         return this;

     }

从源码中我们可以发现它和StringBuffer 之间的最大不同在于StringBuilder 的方法不是线程安全的（不能同步访问）。所以在单线程的环境下StringBuilder相较于StringBuffer 有速度优势，因为它不需要做同步处理。

StringBuffer的默认长度是16, StringBuilder的默认长度是16+初始化传入字符串的长度。

四：扩容

---

下面是扩容的源码：

void expandCapacity(int minimumCapacity) {

    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.copyOf(value, newCapacity);

 }

当我们对StringBuffer和StringBuilder进行append的时候，会先判断当前的容量是否可以放下，如果长度不够，就会调用expandCapacity来进行扩容

扩容的计算公式：现在的长度*2 + 2;

如果我们扩容后的长度(newCapacity)还是放不下(minimumCapacity)的长度那就直接把所需要的长度赋值给扩容后的长度(newCapacity = minimumCapacity);

因为当int的最大值 + 1就会变成负数，所以我们需要在扩容完后验证，newCapacity的正确性防止内存溢出，如果超过了int的最大长度，那么就把NewCapacity 设置成Integer.MAX_VALUE,

newCapacity = Integer.MAX_VALUE;

最后把原数组copy到扩容后的数组中：

 value = Arrays.copyOf(value,newCapacity);

总结：

    当需要频繁的字符串拼接和删除时，建议使用StringBuffer或StringBuilder

    在单线程的程序中，使用String或StringBuilder

    在多线程的程序中，使用StringBuffer.