StringBuffer类之详解(一)
一、概述
线程安全的可变字符序列。一个类似于 String
的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。
StringBuffer
上的主要操作是 append
和 insert
方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符添加或插入到字符串缓冲区中。append
方法始终将这些字符添加到缓冲区的末端;而 insert
方法则在指定的点添加字符。
只要发生有关源序列(如在源序列中添加或插入)的操作,该类就只在执行此操作的字符串缓冲区上而不是在源上实现同步。
每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量,就无需分配新的内部缓冲区数组。如果内部缓冲区溢出,则此容量自动增大。从 JDK 5 开始,为该类补充了一个单个线程使用的等价类,即 StringBuilder
。与该类相比,通常应该优先使用 StringBuilder 类,因为它支持所有相同的操作,但由于它不执行同步(线程不安全),所以速度更快。
二、构造方法
StringBuffer()
构造一个其中不带字符的字符串缓冲区,初始容量为 16 个字符。StringBuffer(CharSequence seq)
public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区,它包含与指定的CharSequence
相同的字符。StringBuffer(int capacity)
构造一个不带字符,但具有指定初始容量的字符串缓冲区。StringBuffer(String str)
构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容。
继承于AbstractStringBuilder
构造方法:
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
public StringBuffer() {
super(16);
}
StringBuffer(int capacity)
public StringBuffer(int capacity) {
super(capacity);
}
StringBuffer(String str)
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
初始容量为指定字符创长度+默认长度16
StringBuffer(CharSequence seq)
java.lang
接口 CharSequence所有已知子接口:
所有已知实现类:
CharBuffer, Segment, String, StringBuffer, StringBuilder
CharSequence 是
char
值的一个可读序列。此接口对许多不同种类的char
序列提供统一的只读访问。
多态的体现
public StringBuffer(CharSequence seq) {
this(seq.length() + 16);
append(seq);
}
调用本类中的构造方法
三、序列长度的方法
容器中字符的个数,实际值
int
length
()
Returns the length (character count).容器的初始容量,理论值
int
capacity
()
Returns the current capacity.
@Override
public synchronized int length() {
return count;
}
@Override
public synchronized int capacity() {
return value.length;
}
父类中属性的定义
/**
* The value is used for character storage.
*/
char[] value;
/**
* The count is the number of characters used.
*/
int count;
四、添加功能的方法
StringBuffer
append(String str)
Appends the specified string to this character sequence.
StringBuffer
insert(int offset, String str)
Inserts the string into this character sequence.
append()方法可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
insert()方法在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
@Override
public synchronized StringBuffer insert(int offset, String str) {
toStringCache = null;
super.insert(offset, str);
return this;
}
public AbstractStringBuilder insert(int offset, String str) {
//越界异常
if ((offset < 0) || (offset > length()))
throw new StringIndexOutOfBoundsException(offset);
if (str == null)
str = "null";
int len = str.length();
ensureCapacityInternal(count + len);
//将数组的插入点之前和出入点之后的字符复制到新数组两头,中间为待插入字符长度
System.arraycopy(value, offset, value, offset + len, count - offset);
//插入中间字符
str.getChars(value, offset);
count += len;
return this;
}
StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组 当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区添加字符
五、删除功能的方法
删除指定位置的字符,并返回本身
StringBuffer
deleteCharAt(int index)
Removes thechar
at the specified position in this sequence.删除从指定位置开始指定位置结束的内容,并返回本身
StringBuffer
delete(int start, int end)
Removes the characters in a substring of this sequence.
@Override
public synchronized StringBuffer delete(int start, int end) {
toStringCache = null;
super.delete(start, end);
return this;
}
@Override
public synchronized StringBuffer deleteCharAt(int index) {
toStringCache = null;
super.deleteCharAt(index);
return this;
}
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) {
System.arraycopy(value, start+len, value, start, count-end);
count -= len;
}
return this;
}
public AbstractStringBuilder deleteCharAt(int index) {
if ((index < 0) || (index >= count))
throw new StringIndexOutOfBoundsException(index);
System.arraycopy(value, index+1, value, index, count-index-1);
count--;
return this;
}
特殊用法:
sb.delete(0, sb.length()); //清空缓冲区
sb = new StringBuffer(); //不要用这种方式清空缓冲区,原来的会变成垃圾,浪费内存