StringBuffer里面的方法几乎都是AbstractStringBuilder里面的方法、具体的实现也都是在AbstractStringBuilder里面,需要结合AbstractStringBuilder源码一起查看。
AbstractStringBuilder源码分析:https://blog.csdn.net/qq_26896085/article/details/95593388
package java.lang;
import java.util.Arrays;
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
// transient 让某些被修饰的成员属性变量不被序列化
// 在toString方法中使用到,
private transient char[] toStringCache;
static final long serialVersionUID = 3388685877147921107L;
// 初始化长度默认为16
public StringBuffer() {
super(16);
}
// 传入参数初始化默认为capacity
public StringBuffer(int capacity) {
super(capacity);
}
// 构造函数, 传入一个字符串
public StringBuffer(String str) {
// 初始化的长度为传入长度+16
super(str.length() + 16);
append(str);
}
// 构造函数, 传入一个字符序列
public StringBuffer(CharSequence seq) {
// 初始化的长度为传入长度+16
this(seq.length() + 16);
append(seq);
}
// 获取当前StringBuffer的长度
@Override
public synchronized int length() {
return count;
}
// 获取当前StringBuffer的容量
@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);
}
// 获取当前字符串中的某个字符
@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);
}
// 获取到value[index]前面一位的字符编码,即value[--index]的字符编码
@Override
public synchronized int codePointBefore(int index) {
return super.codePointBefore(index);
}
// 计算beginIndex与endIndex索引之间字符的数量,[beginIndex, endIndex),
@Override
public synchronized int codePointCount(int beginIndex, int endIndex) {
return super.codePointCount(beginIndex, endIndex);
}
// 返回偏移位置的字符,返回value[(index+codePointOffset)]
@Override
public synchronized int offsetByCodePoints(int index, int codePointOffset) {
return super.offsetByCodePoints(index, codePointOffset);
}
/**
* 将字符串中的数据复制到dst中
* @param srcBegin 字符串中开始的下标
* @param srcEnd 字符串中结束的下标
* @param dst 将字符串中的字符串复制到dst中
* @param dstBegin dst中接收字符开始的位置
*/
// System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
@Override
public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
int dstBegin)
{
super.getChars(srcBegin, srcEnd, dst, dstBegin);
}
// 用ch替换value[index]
@Override
public synchronized void setCharAt(int index, char ch) {
if ((index < 0) || (index >= count))
throw new StringIndexOutOfBoundsException(index);
toStringCache = null;
value[index] = ch;
}
// 在当前字符串末尾追加字符串
// 调用父类中的append方法
// toStringCache = null;暂时不明白这句的意义
@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 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;
}
// 在当前字符串的末尾追加字符,codePoint为字符的编码
@Override
public synchronized StringBuffer appendCodePoint(int codePoint) {
toStringCache = null;
super.appendCodePoint(codePoint);
return this;
}
// 删除当前字符下标为[start, end)的字符
@Override
public synchronized StringBuffer delete(int start, int end) {
toStringCache = null;
super.delete(start, end);
return this;
}
// 删除当前字符串下标为index的字符
@Override
public synchronized StringBuffer deleteCharAt(int index) {
toStringCache = null;
super.deleteCharAt(index);
return this;
}
// 用str替换掉当前字符串下标为[start, end)的字符串
@Override
public synchronized StringBuffer replace(int start, int end, String str) {
toStringCache = null;
super.replace(start, end, str);
return this;
}
// 截取当前字符串,下标为start至最后
@Override
public synchronized String substring(int start) {
return substring(start, count);
}
// 截取当前字符串,下标为start至最后
@Override
public synchronized CharSequence subSequence(int start, int end) {
return super.substring(start, end);
}
// 截取当前字符串,下标为start至最后
@Override
public synchronized String substring(int start, int end) {
return super.substring(start, end);
}
//插入操作
@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) {
// 注意,通过调用其他StringBuffer方法实现同步
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) {
// 通过调用StringBuffer insert(int,String)实现同步
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) {
// 通过调用StringBuffer insert(int,String)实现同步
super.insert(offset, i);
return this;
}
@Override
public StringBuffer insert(int offset, long l) {
// 通过调用StringBuffer insert(int,String)实现同步
super.insert(offset, l);
return this;
}
@Override
public StringBuffer insert(int offset, float f) {
// 通过调用StringBuffer insert(int,String)实现同步
super.insert(offset, f);
return this;
}
@Override
public StringBuffer insert(int offset, double d) {
// 通过调用StringBuffer insert(int,String)实现同步
super.insert(offset, d);
return this;
}
// 获取str在当前字符串中第一次出现的位置
@Override
public int indexOf(String str) {
// 注意,通过调用其他StringBuffer方法实现同步
return super.indexOf(str);
}
// 获取str在当前字符串fromIndex下标以后第一次出现的位置
@Override
public synchronized int indexOf(String str, int fromIndex) {
return super.indexOf(str, fromIndex);
}
// 获取str在当前字符串中最后一次出现的位置
@Override
public int lastIndexOf(String str) {
// 注意,通过调用其他StringBuffer方法实现同步
return lastIndexOf(str, count);
}
// 获取str在当前字符串fromIndex下标之前最后一次出现的位置
@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;
}
// 将当前的StringBuffer转换成String
// 先将StringBuffer中的数据存放在toStringCache中,在new一个String对象
@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),
};
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();
}
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);
}
}