StringBuilder的底层实现原理整理笔记
目录
1、StringBuilder的结构
2、创建StringBuilder对象，看下它的构造函数
3、再看下StringBuilder的拼接方法append，部分源码如下：
4、总结
tringBuilder简介
StringBuilder 最早出现在JDK1.5，是一个字符拼接的工具类，它和StringBuffer一样都继承自父类AbstractStringBuilder，在AbstractStringBuilder中使用char[] value字符数组保存字符串，但是没有用final关键字修饰，所以StringBuilder是可变的。
性能
StringBuilder 对字符串的操作是直接改变字符串对象本身，而不是生成新的对象，所以新能开销小。
与StringBuffer相比StringBuilder的性能略高（15%~30%），StringBuffer为保证多线程情况下的安全性（synchronize加锁）而牺牲了性能，以时间来换取安全。而StringBuilder则没有保证线程的安全，从而性能略高于StringBuffer。
使用场景
频繁使用字符串拼接的时候可以用StringBuilder（推荐）或者StringBuffer。
StringBuilder是我们常用来动态拼接字符串的一个类，通常在面试中被问到这个可能就离不开这个问题“String、StringBuffer和StringBuilder的区别？”。这个问题也是老生常谈的，相信大家都不陌生。一个最明显的区别就是String是不可变的，在动态拼接字符串时会产生很多新的对象，StringBuffer和StringBuilder就是用来解决这个问题的，它们继承了 AbstractStringBuilder ，底层基于可修改的char数组（JDK8），而这两个的区别是StringBuffer加了synchronized关键字，是线程安全的，而StringBuilder是非线程安全的。
知道它们的区别，那么StringBuilder的底层到底是如何实现修改的呢？分析部分源码如下：
1、StringBuilder的结构
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{
....
}
~~~~~~~~~~~~~~~~~~~~~~~萌萌哒分割线~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
char[] value;
/**
* The count is the number of characters used.
*/
int count;
}
可以看到StringBuilder继承自AbstractStringBuilder，底层有一个char数组存放字符，count记录字符个数。
2、创建StringBuilder对象，看下它的构造函数
/**
* Constructs a string builder with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuilder() {
super(16);
}
/**
* Constructs a string builder with no characters in it and an
* initial capacity specified by the {@code capacity} argument.
*
* @param capacity the initial capacity.
* @throws NegativeArraySizeException if the {@code capacity}
* argument is less than {@code 0}.
*/
public StringBuilder(int capacity) {
super(capacity);
}
/**
* Creates an AbstractStringBuilder of the specified capacity.
*/
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
3、再看下StringBuilder的拼接方法append，部分源码如下：
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
~~~~~~~~~~~~~~~~~萌萌哒分割线~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
父类AbstractStringBuilder的appeng方法实现：
/**
* Appends the specified string to this character sequence.
*
* The characters of the {@code String} argument are appended, in
* order, increasing the length of this sequence by the length of the
* argument. If {@code str} is {@code null}, then the four
* characters {@code "null"} are appended.
*
* Let n be the length of this character sequence just prior to
* execution of the {@code append} method. Then the character at
* index k in the new character sequence is equal to the character
* at index k in the old character sequence, if k is less
* than n; otherwise, it is equal to the character at index
* k-n in the argument {@code str}.
*
* @param str a string.
* @return a reference to this object.
*/
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();//@1
int len = str.length();//@2
ensureCapacityInternal(count + len);//@3
str.getChars(0, len, value, count);//@4
count += len;@5
return this;//@6
}
逐个分析上面的@1~@6，看看具体每步做了什么。
@1：appentNull()
private AbstractStringBuilder appendNull() {
int c = count;
ensureCapacityInternal(c + 4);
final char[] value = this.value;
value[c++] = 'n';
value[c++] = 'u';
value[c++] = 'l';
value[c++] = 'l';
count = c;
return this;
}
@2：int len = str.length();待添加的字符串长度
@3：ensureCapacityInternal(count + len);将当前char数组中字符个数加上待添加的字符串长度，也调用的这个方法和拼接null时一样，只不过拼接null时待添加的字符串长度等于4，看下这个方法做了什么
/**
* For positive values of {@code minimumCapacity}, this method
* behaves like {@code ensureCapacity}, however it is never
* synchronized.
* If {@code minimumCapacity} is non positive due to numeric
* overflow, this method throws {@code OutOfMemoryError}.
*/
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
看代码结合方法注释就很清楚，就是将字符总数和char数组的长度比对，确保char数组长度是否足够，如果不够就需要扩容，copy一个新的数组，将旧数组的数据复制到新数组中，然后将引用赋值给value，同时这里newCapacity里面对于新数组的长度也有一些判断逻辑，源码如下：
/**
* Returns a capacity at least as large as the given minimum capacity.
* Returns the current capacity increased by the same amount + 2 if
* that suffices.
* Will not return a capacity greater than {@code MAX_ARRAY_SIZE}
* unless the given minimum capacity is greater than that.
*
* @param minCapacity the desired minimum capacity
* @throws OutOfMemoryError if minCapacity is less than zero or
* greater than Integer.MAX_VALUE
*/
private int newCapacity(int minCapacity) {
// overflow-conscious code
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
private int hugeCapacity(int minCapacity) {
if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
throw new OutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE)
? minCapacity : MAX_ARRAY_SIZE;
}
@4：str.getChars(0, len, value, count);将待添加的字符添加到char数组
@5：count += len;将count记录的字符个数加上新加的
@6：return this;返回当前对象
4、总结
通过上面的分析总结下StringBuilder的底层实现原理：
（1）new StringBuilder()默认创建一个容量大小=16的char数组
（2）调用append方法拼接字符串首先会判断char数组容量是否组足够，如果不够需要扩容，按原来数组大小的2倍+2扩容，将原来char数组的元素赋值到新扩容的数组中，并将新数组引用赋值给原来的value，
（3）将待拼接的字符也添加到新数组中，将记录字符个数的count更新
（4）返回当前对象
分析StringBuilder其他更多的方法会发现每次操作返回的都是当前对象，这也是为什么在动态拼接字符串的时候推荐使用它而非String的原因。另一个点就是由于 StringBuilder 底层是基于 char 数组存放字符，而数组是连续内存结构，为了防止频繁地复制和申请内存，在预先知道字符串大概长度的情况下，new StringBuilder()时可以先指定capacity的值，减少数组的扩容次数提高效率。