AbstractStringBuilder

1
2
3
4
5
6
7
8
9
10
11
12
/*抽象类
  实现两个接口：Appendable和CharSequence
  Appendable：表明类中序列是可拓展的
  CharSequence：只读的字符序列接口
*/
abstract class AbstractStringBuilder implements Appendable, CharSequence

public interface Appendable {
    Appendable append(CharSequence csq) throws IOException;
    Appendable append(CharSequence csq, int start, int end) throws IOException;
    Appendable append(char c) throws IOException;
}

成员变量

1
2
char[] value;   //底层是一个可变的字符数组
int count;      //字符数组中含有的元素

构造器

1
2
3
4
5
6
7
8
 //无参构造器
AbstractStringBuilder() {
}

 //给定容量的构造器
AbstractStringBuilder(int capacity) {
    value = new char[capacity];
}

扩容机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

 /**
 * 确保数组的大小够用，不够用就调用方法进行拓展
 * 调用方法 newCapacity来确定扩容后数组的大小
 * @param minimumCapacity 添加元素后字符数组所需要的最小容量
 */
public void ensureCapacity(int minimumCapacity) {
    if (minimumCapacity > 0)
        ensureCapacityInternal(minimumCapacity);
}
private void ensureCapacityInternal(int minimumCapacity) {
    if (minimumCapacity - value.length > 0) {
        value = Arrays.copyOf(value,
                newCapacity(minimumCapacity));
    }
}

private int newCapacity(int minCapacity) {
     //如果 新容量（原来容量*2+2） 还是小于所需要的容量，直接将 新容量=所需要的容量
    int newCapacity = (value.length << 1) + 2;
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    //当新容量过大时，调用hugeCapacity方法，否则直接返回新容量
    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;
}

其他方法

  • trimToSize():如果value数组的容量有多余的，那么就把多余的全部都释放掉
  • append() delete() insert() relpace()方法都是调用 System.arrayCopy()或者Arrays.copyOf()方法
  • reverse方法是设置两个指针分别指向中间元素和中间边上的元素，交换后向两侧移动，直至整个数组颠倒完成

StringBuffer

  • 线程安全的可变字符序列
1
2
3
4
5
//继承自AbstractStringBuilder，实现了Serializable、CharSequence两个接口
//CharSequence：可序列化接口，是一个空接口，只是一个可序列化的标志
 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence

成员变量

1
2
3
4
//？？？
private transient char[] toStringCache;
//序列化id
static final long serialVersionUID = 3388685877147921107L;

构造器

线程安全

1
2
3
4
5
//使用synchronized关键字修饰，确保线程安全
public synchronized StringBuffer append(...)
public synchronized StringBuffer delete(...) 
public synchronized StringBuffer replace(...)
public synchronized StringBuffer delete(...)
  • 对数组进行修改的方法中会先将数组toStringCache置空
    1
    2
    3
    4
    5
    6
    @Override
    public synchronized StringBuffer append(char c) {
        toStringCache = null;
        super.append(c);
        return this;
    }

StringBuilder

  • 非线程安全、可变的字符序列
  • 运行速度快，一般情况（单线程）推荐使用
1
2
3
public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence

构造器