本文基于JDK1.8学习与分析StringBuffer源码。
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
StringBuffer主要特性:①线程安全,我们可以看到基本上每个方法都由synchronized关键字所修饰;②可修改,字符串缓冲区就像一个String ,但可以修改。API提供了诸如append和insert等多种重载方法。
基于JDK源码,笔者分析每个方法的使用说明,希望与各位一起学习:
package java.lang;
import java.util.Arrays;
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
/**
* 返回最后一次toString的缓存值
*/
private transient char[] toStringCache;
static final long serialVersionUID = 3388685877147921107L;
/**
* 无参构造方法,初始容量为16个字符
*/
public StringBuffer() {
super(16);
}
/**
* 指定初试容量的构造方法
*/
public StringBuffer(int capacity) {
super(capacity);
}
/**
* 构造一个初始化为指定字符串内容的字符串缓冲区
*/
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
/**
* 构造一个包含与指定的相同字符的字符串缓冲区CharSequence
*/
public StringBuffer(CharSequence seq) {
this(seq.length() + 16);
append(seq);
}
/**
* 返回字符长度
*/
@Override
public synchronized int length() {
return count;
}
/**
* 返回当前容量
*/
@Override
public synchronized int capacity() {
return value.length;
}
/**
* 确保容量至少等于规定的最小值
*/
@Override
public synchronized void ensureCapacity(int minimumCapacity) {
super.ensureCapacity(minimumCapacity);
}
/**
* 减少用于字符序列的存储
*/
@Override
public synchronized void trimToSize() {
super.trimToSize();
}
/**
* 设置字符序列的长度
*/
@Override
public synchronized void setLength(int newLength) {
toStringCache = null;
super.setLength(newLength);
}
/**
* 返回 char在指定索引在这个序列值
*/
@Override
public synchronized char charAt(int index) {
if ((index < 0) || (index >= count))
throw new StringIndexOutOfBoundsException(index);
return value[index];
}
/**
* 返回指定索引处的字符
*/
@Override
public synchronized int codePointAt(int index) {
return super.codePointAt(index);
}
/**
* 返回指定索引之前的字符
*/
@Override
public synchronized int codePointBefore(int index) {
return super.codePointBefore(index);
}
/**
* 返回此序列指定文本范围内的Unicode代码点数
*/
@Override
public synchronized int codePointCount(int beginIndex, int endIndex) {
return super.codePointCount(beginIndex, endIndex);
}
/**
* 返回此序列中与 index
*/
@Override
public synchronized int offsetByCodePoints(int index, int codePointOffset) {
return super.offsetByCodePoints(index, codePointOffset);
}
/**
* 字符从该序列复制到目标字符数组dst
*/
@Override
public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
int dstBegin)
{
super.getChars(srcBegin, srcEnd, dst, dstBegin);
}
/**
* 指定索引处的字符设置为ch
*/
@Override
public synchronized void setCharAt(int index, char ch) {
if ((index < 0) || (index >= count))
throw new StringIndexOutOfBoundsException(index);
toStringCache = null;
value[index] = ch;
}
/**
* 追加字符串,以下append均为重载方法
*/
@Override
public synchronized StringBuffer append(Object obj) {
toStringCache = null;
super.append(String.valueOf(obj));
return this;
}
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
public synchronized StringBuffer append(StringBuffer sb) {
toStringCache = null;
super.append(sb);
return this;
}
@Override
synchronized StringBuffer append(AbstractStringBuilder asb) {
toStringCache = null;
super.append(asb);
return this;
}
@Override
public synchronized StringBuffer append(CharSequence s) {
toStringCache = null;
super.append(s);
return this;
}
@Override
public synchronized StringBuffer append(CharSequence s, int start, int end)
{
toStringCache = null;
super.append(s, start, end);
return this;
}
@Override
public synchronized StringBuffer append(char[] str) {
toStringCache = null;
super.append(str);
return this;
}
@Override
public synchronized StringBuffer append(char[] str, int offset, int len) {
toStringCache = null;
super.append(str, offset, len);
return this;
}
@Override
public synchronized StringBuffer append(boolean b) {
toStringCache = null;
super.append(b);
return this;
}
@Override
public synchronized StringBuffer append(char c) {
toStringCache = null;
super.append(c);
return this;
}
@Override
public synchronized StringBuffer append(int i) {
toStringCache = null;
super.append(i);
return this;
}
@Override
public synchronized StringBuffer appendCodePoint(int codePoint) {
toStringCache = null;
super.appendCodePoint(codePoint);
return this;
}
@Override
public synchronized StringBuffer append(long lng) {
toStringCache = null;
super.append(lng);
return this;
}
@Override
public synchronized StringBuffer append(float f) {
toStringCache = null;
super.append(f);
return this;
}
@Override
public synchronized StringBuffer append(double d) {
toStringCache = null;
super.append(d);
return this;
}
/**
* 删除此序列的子字符串中的字符
*/
@Override
public synchronized StringBuffer delete(int start, int end) {
toStringCache = null;
super.delete(start, end);
return this;
}
/**
* 删除 char在这个序列中的指定位置
*/
@Override
public synchronized StringBuffer deleteCharAt(int index) {
toStringCache = null;
super.deleteCharAt(index);
return this;
}
/**
* 字符串替换
*/
@Override
public synchronized StringBuffer replace(int start, int end, String str) {
toStringCache = null;
super.replace(start, end, str);
return this;
}
/**
* 字符串截取
*/
@Override
public synchronized String substring(int start) {
return substring(start, count);
}
@Override
public synchronized CharSequence subSequence(int start, int end) {
return super.substring(start, end);
}
@Override
public synchronized String substring(int start, int end) {
return super.substring(start, end);
}
/**
* 字符串插入,以下insert均为重载方法
*/
@Override
public synchronized StringBuffer insert(int index, char[] str, int offset,
int len)
{
toStringCache = null;
super.insert(index, str, offset, len);
return this;
}
@Override
public synchronized StringBuffer insert(int offset, Object obj) {
toStringCache = null;
super.insert(offset, String.valueOf(obj));
return this;
}
@Override
public synchronized StringBuffer insert(int offset, String str) {
toStringCache = null;
super.insert(offset, str);
return this;
}
@Override
public synchronized StringBuffer insert(int offset, char[] str) {
toStringCache = null;
super.insert(offset, str);
return this;
}
@Override
public StringBuffer insert(int dstOffset, CharSequence s) {
super.insert(dstOffset, s);
return this;
}
@Override
public synchronized StringBuffer insert(int dstOffset, CharSequence s,
int start, int end)
{
toStringCache = null;
super.insert(dstOffset, s, start, end);
return this;
}
@Override
public StringBuffer insert(int offset, boolean b) {
super.insert(offset, b);
return this;
}
@Override
public synchronized StringBuffer insert(int offset, char c) {
toStringCache = null;
super.insert(offset, c);
return this;
}
@Override
public StringBuffer insert(int offset, int i) {
super.insert(offset, i);
return this;
}
@Override
public StringBuffer insert(int offset, long l) {
super.insert(offset, l);
return this;
}
@Override
public StringBuffer insert(int offset, float f) {
super.insert(offset, f);
return this;
}
@Override
public StringBuffer insert(int offset, double d) {
super.insert(offset, d);
return this;
}
/**
* 返回指定子字符串第一次出现的字符串内的索引
*/
@Override
public int indexOf(String str) {
return super.indexOf(str);
}
@Override
public synchronized int indexOf(String str, int fromIndex) {
return super.indexOf(str, fromIndex);
}
/**
* 返回指定子字符串最右边出现的字符串内的索引
*/
@Override
public int lastIndexOf(String str) {
return lastIndexOf(str, count);
}
@Override
public synchronized int lastIndexOf(String str, int fromIndex) {
return super.lastIndexOf(str, fromIndex);
}
/**
* 字符串反转
*/
@Override
public synchronized StringBuffer reverse() {
toStringCache = null;
super.reverse();
return this;
}
@Override
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
private static final java.io.ObjectStreamField[] serialPersistentFields =
{
new java.io.ObjectStreamField("value", char[].class),
new java.io.ObjectStreamField("count", Integer.TYPE),
new java.io.ObjectStreamField("shared", Boolean.TYPE),
};
/**
* 将StringBuffer对象序列化输出到流中保存
*/
private synchronized void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
java.io.ObjectOutputStream.PutField fields = s.putFields();
fields.put("value", value);
fields.put("count", count);
fields.put("shared", false);
s.writeFields();
}
/**
* 从流中读取StringBuffer对象
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
java.io.ObjectInputStream.GetField fields = s.readFields();
value = (char[])fields.get("value", null);
count = fields.get("count", 0);
}
}
常见方法的使用示例:
public class TestStringBuffer {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
System.out.println(sb.length()); //0
System.out.println(sb.capacity()); //16
sb.append("a");
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(1);
System.out.println(stringBuffer); //1
System.out.println(sb); //a
sb.append(stringBuffer);
System.out.println(sb); //a1
sb.insert(1,"c"); //指定位置插入
System.out.println(sb); //ac1
String substring = sb.substring(1, 2);
System.out.println(substring); //c
sb.replace(0,1,"replace");
System.out.println(sb); //replacec1
System.out.println(sb.indexOf("a")); //4
System.out.println(sb.lastIndexOf("a")); //4
System.out.println(sb.lastIndexOf("e", 6)); //6
System.out.println(sb.lastIndexOf("e", 3)); //1
}
}