StringBuffer、StringBuilder与为什么说StringBuilder是不安全的

长久以来，我们被教导字符串的连接最好用StringBuffer、StringBuilder，但是我们却不知道这两者之间的区别.跟字符串相关的一些方法中总是有CharSequence、StringBuffer、StringBuilder、String，他们之间到底有什么联系呢？

1、从类的定义看CharSequence、StringBuffer、StringBuilder、String的关系

下面先贴上这四者的定义（来自JDK1.6,Q:JDK1.7以后有没有对这些类进行修改呢?）

CharSequence是一个定义字符串操作的接口，StringBuffer、StringBuilder、String中都实现了这个接口.

//CharSequence定义
public interface CharSequence

//StringBuffer定义
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence

//StringBuilder定义
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence

//String定义
public final class String
implements
java.io.Serializable, Comparable<String>, CharSequence

String 是java中的字符串，它继承于CharSequence。

String类所包含的API接口非常多。为了便于今后的使用，我对String的API进行了分类，并都给出的演示程序。

String 和 CharSequence 关系

String 继承于CharSequence，也就是说String也是CharSequence类型。

CharSequence是一个接口，它只包括length(), charAt(int index), subSequence(int start, int end)这几个API接口。除了String实现了CharSequence之外，StringBuffer和StringBuilder也实现了CharSequence接口。

也就是说，CharSequence其实也就是定义了字符串操作的接口，其他具体的实现是由String、StringBuilder、StringBuffer完成的，String、StringBuilder、StringBuffer都可以转化为CharSequence类型。

StringBuilder 和 StringBuffer 的区别

StringBuilder 和 StringBuffer都是可变的字符序列。它们都继承于AbstractStringBuilder，实现了CharSequence接口。

但是，StringBuilder是非线程安全的，而StringBuffer是线程安全的。

它们之间的关系图如下：



2、从构造函数到具体的字符串拼接操作看看String、StringBuffer、StringBuilder的区别

下面我们来分析一下String、StringBuffer、StringBuilder具体的构造函数，了解他们是怎么构造出来的，再看看具体的字符串连接操作。

（1）String

String的构造函数(几个常见的构造函数)

public String() {
this.offset = 0;
this.count = 0;
this.value = new char[0];
}

/**
* Initializes a newly created {@code String} object so that it
d989
represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {@code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
*
* @param  original
*         A {@code String}
*/
public String(String original) {
int size = original.count;
char[] originalValue = original.value;
char[] v;

if (originalValue.length > size) {
// The array representing the String is bigger than the new
// String itself.  Perhaps this constructor is being called
// in order to trim the baggage, so make a copy of the array.
int off = original.offset;
v = Arrays.copyOfRange(originalValue, off, off + size);
} else {
// The array representing the String is the same
// size as the String, so no point in making a copy.
v = originalValue;
}

this.offset = 0;
this.count = size;
this.value = v;
}

/**
* Allocates a new {@code String} so that it represents the sequence of
* characters currently contained in the character array argument. The
* contents of the character array are copied; subsequent modification of
* the character array does not affect the newly created string.
*
* @param  value
*         The initial value of the string
*/
public String(char[] value) {
this.offset = 0;
this.count = value.length;
this.value = StringValue.from(value);
}

再看看String中具体的Concat函数

public String concat(String str) {
int otherLen = str.length();

if (otherLen == 0) {
return this;
}

char[] buf = new char[count + otherLen];
getChars(0, count, buf, 0);
str.getChars(0, otherLen, buf, count);

return new String(0, count + otherLen, buf);
}

从Concat函数中，我们可以知道在对字符串使用concat操作后，具体的操作new出一个等同于两个字符串连接总长度的新的char数组，然后将两个字符串复制到新的char数组中，然后返回一个新的String对象。

（2）StringBuilder

StringBuilder常见构造函数

public StringBuffer() {
super(16);
}

public StringBuffer(int capacity) {
super(capacity);
}

从StringBuilder的构造函数中，我们可以看见StringBuilder直接调用父类（AbstractStringBuilder）的构造函数，我们再看看AbstractStringBuilder的构造函数

abstract class AbstractStringBuilder implements Appendable, CharSequence {
final static int[] sizeTable = {
9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,
Integer.MAX_VALUE
};

/**
* The value is used for character storage.
*/
char[] value;

/**
* The count is the number of characters used.
*/
int count;

/**
* 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];
}
//其他的一些逻辑
}

从AbstractStringBuilder的构造函数中，我们可以看出StringBuilder中存储字符串其实用的是一个char数组，capacity其实就是指定这个char数组的大小。

下面我们再从StringBuilder中的append函数看看他具体是怎么做的(以 append(String str) 为例看看)。

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

又是直接调用父类（AbstractStringBuilder）的append方法，再跟到父类中去看看。

/**
*  value 用来存储字符串.
*/
char value[];

/**
* 有效字符串的数目.
*/
int count;

public AbstractStringBuilder append(String str) {
if (str == null) {
str = "null";
}

int len = str.length();
if (len == 0) {
return this;
}

int newCount = count + len;
if (newCount > value.length) {
expandCapacity(newCount);
}
//getChars将字符串复制到指定的位置
str.getChars(0, len, value, count);
count = newCount;
return this;
}

上面的逻辑还是比较简单的，在append(str)函数调用的时候，首先会判断原来用于存储字符串的values的字符串数组有没有足够的大小来存储将要新添加入StringBuilder的字符串。如果不够用，那么就调用expandCapacity(int minimumCapacity)让容量翻两倍(一般是扩大两倍，特殊情况见代码)，如果够用，那么就直接添加进去。

/**
* This implements the expansion semantics of ensureCapacity with no
* size check or synchronization.
*/
void expandCapacity(int minimumCapacity) {
int newCapacity = (value.length + 1) * 2;

if (newCapacity < 0) {
newCapacity = Integer.MAX_VALUE;
} else if (minimumCapacity > newCapacity) {
newCapacity = minimumCapacity;
}

value = Arrays.copyOf(value, newCapacity);
}

（3）StringBuffer

StringBuffer的构造函数

/**
* Constructs a string buffer with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuffer() {
super(16);
}

/**
* 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</code>
*               argument is less than <code>0</code>.
*/
public StringBuffer(int capacity) {
super(capacity);
}

StringBuffer也是直接调用父类（AbstractStringBuilder）的构造函数，那么我们从上面的分析中，就可以知道StringBuffer其实也是利用char[]类型的数组来保存字符串数组的。

再看看StringBuffer的append函数

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

还是调用父类的append函数，但是在这里有值得注意的地方，StringBuffer的append函数有一个synchronized标识符，也就是说StringBuffer中的append函数是线程安全的，通过继续查阅其他StringBuffer中的函数，我们也可以发现他们有synchronized标识符，这就不难理解为什么StringBuffer是线程安全的，但是很明显加上线程控制会拖慢程序运行的速度，所以如果不需要线程控制，那么最好就用StringBuilder。

//下面只是节选一些StringBuffer中的函数
synchronized StringBuffer     append(char ch)
synchronized StringBuffer     append(char[] chars)
synchronized StringBuffer     append(char[] chars, int start, int length)
synchronized StringBuffer     append(Object obj)
synchronized StringBuffer     append(String string)
synchronized StringBuffer     append(StringBuffer sb)
synchronized StringBuffer     append(CharSequence s)
synchronized StringBuffer     append(CharSequence s, int start, int end)
synchronized StringBuffer     insert(int index, char ch)
synchronized StringBuffer     insert(int index, char[] chars)
synchronized StringBuffer     insert(int index, char[] chars, int start, int length)
synchronized StringBuffer     insert(int index, String string)
StringBuffer     insert(int index, Object obj)

转载自:

https://www.cnblogs.com/kissazi2/p/3648671.html 作者：kissazi2

2.为什么说StringBuilder操作字符串不安全呢?

StringBuilder和Stringbuffer的append方法中都有一步super.append(str)方法;而这个方法是AbstractStringBuilder 的append(str)方法;

public AbstractStringBuilder append(String str) {
if (str == null) str = "null";
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}

即StringBuilder和StringBuffer的append(String str)方法都是通过getChars方法来实现字符串的拼接.

public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
{
if (srcBegin < 0)
throw new StringIndexOutOfBoundsException(srcBegin);
if ((srcEnd < 0) || (srcEnd > count))
throw new StringIndexOutOfBoundsException(srcEnd);
if (srcBegin > srcEnd)
throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}

这个方法没有加synchronized关键字,即多个线程可以同时访问这个方法;这样就可能造成AbstractStringBuilder 中的count相同,自然也就不安全了.