Java8 源码解析 StringBuilder

Posted 2020-10-12

 

1 package java.lang;

 

1 // 继承了抽象类AbstractStringBuilder
2 // 实现了序列化和字符序列接口
3 public final class StringBuilder
4     extends AbstractStringBuilder
5     implements java.io.Serializable, CharSequence

 

1 // 序列化版本唯一标识符，版本向下兼容。
2 static final long serialVersionUID = 4383685877147921099L;

 

1 // 无参构造方法
2 public StringBuilder() {
3     super(16); // 默认容量是16
4 }

 

1 // 容量作为参数的构造方法
2 public StringBuilder(int capacity) {
3     super(capacity);
4 }

 

1 // String对象引用作为参数的构造方法
2 public StringBuilder(String str) {
3     super(str.length() + 16); // 容量是字符串长度+16
4     append(str); // 末尾追加字符串
5 }

 

1 // 字符序列引用作为参数的构造方法
2 public StringBuilder(CharSequence seq) {
3     this(seq.length() + 16); // 容量是字符序列长度+16
4     append(seq); // 末尾追加字符序列
5 }

 

1 // 末尾追加Object对象
2 @Override
3 public StringBuilder append(Object obj) {
4     return append(String.valueOf(obj));
5 }

 

1 // 末尾追加String对象
2 @Override
3 public StringBuilder append(String str) {
4     super.append(str);
5     return this;
6 }

 

1 // 末尾追加字符序列
2 @Override
3 public StringBuilder append(CharSequence s) {
4     super.append(s);
5     return this;
6 }

 

1 // 末尾追加部分字符序列
2 @Override
3 public StringBuilder append(CharSequence s, int start, int end) {
4     super.append(s, start, end);
5     return this;
6 }

 

1 // 末尾追加字符数组
2 @Override
3 public StringBuilder append(char[] str) {
4     super.append(str);
5     return this;
6 }

 

1 // 末尾追加字符数组中的子串
2 @Override
3 public StringBuilder append(char[] str, int offset, int len) {
4     super.append(str, offset, len);
5     return this;
6 }

 

1 // 末尾追加布尔类型变量值
2 @Override
3 public StringBuilder append(boolean b) {
4     super.append(b);
5     return this;
6 }

 

1 // 末尾追加单个字符
2 @Override
3 public StringBuilder append(char c) {
4     super.append(c);
5     return this;
6 }

 

1 // 末尾追加整型变量值
2 @Override
3 public StringBuilder append(int i) {
4     super.append(i);
5     return this;
6 }

 

1 // 末尾追加长整型变量值
2 @Override
3 public StringBuilder append(long lng) {
4     super.append(lng);
5     return this;
6 }

 

1 // 末尾追加浮点型变量值
2 @Override
3 public StringBuilder append(float f) {
4     super.append(f);
5     return this;
6 }

 

1 // 末尾追加双精度型变量值
2 @Override
3 public StringBuilder append(double d) {
4     super.append(d);
5     return this;
6 }

 

1 // 删除子串
2 @Override
3 public StringBuilder delete(int start, int end) {
4     super.delete(start, end);
5     return this;
6 }

 

1 // 根据下标，删除单个字符
2 @Override
3 public StringBuilder deleteCharAt(int index) {
4     super.deleteCharAt(index);
5     return this;
6 }

 

1 // 用字符串替换一个区间内的所有字符
2 @Override
3 public StringBuilder replace(int start, int end, String str) {
4     super.replace(start, end, str);
5     return this;
6 }

 

1 // 插入字符串
2 @Override
3 public StringBuilder insert(int index, char[] str, int offset,
4                             int len)
5 {
6     super.insert(index, str, offset, len);
7     return this;
8 }

 

1 // 插入Object对象
2 @Override
3 public StringBuilder insert(int offset, Object obj) {
4         super.insert(offset, obj);
5         return this;
6 }

 

1 // 插入String对象
2 @Override
3 public StringBuilder insert(int offset, String str) {
4     super.insert(offset, str);
5     return this;
6 }

 

1 // 插入字符数组
2 @Override
3 public StringBuilder insert(int offset, char[] str) {
4     super.insert(offset, str);
5     return this;
6 }

 

1 // 插入字符序列
2 @Override
3 public StringBuilder insert(int dstOffset, CharSequence s) {
4         super.insert(dstOffset, s);
5         return this;
6 }

 

1 // 插入部分字符序列
2 @Override
3 public StringBuilder insert(int dstOffset, CharSequence s,
4                             int start, int end)
5 {
6     super.insert(dstOffset, s, start, end);
7     return this;
8 }

 

1 // 插入布尔类型变量值
2 @Override
3 public StringBuilder insert(int offset, boolean b) {
4     super.insert(offset, b);
5     return this;
6 }

 

1 // 插入单个字符
2 @Override
3 public StringBuilder insert(int offset, char c) {
4     super.insert(offset, c);
5     return this;
6 }

 

1 // 插入整型变量值
2 @Override
3 public StringBuilder insert(int offset, int i) {
4     super.insert(offset, i);
5     return this;
6 }

 

1 // 插入长整型变量值
2 @Override
3 public StringBuilder insert(int offset, long l) {
4     super.insert(offset, l);
5     return this;
6 }

 

1 // 插入浮点型变量值
2 @Override
3 public StringBuilder insert(int offset, float f) {
4     super.insert(offset, f);
5     return this;
6 }

 

1 // 插入双精度变量值
2 @Override
3 public StringBuilder insert(int offset, double d) {
4     super.insert(offset, d);
5     return this;
6 }

 

1 // 获取子串顺序下首次出现的位置
2 @Override
3 public int indexOf(String str) {
4     return super.indexOf(str);
5 }

 

1 // 获取子串顺序下从某位置开始首次出现的位置
2 @Override
3 public int indexOf(String str, int fromIndex) {
4     return super.indexOf(str, fromIndex);
5 }

 

1 // 获取子串逆序下首次出现的位置
2 @Override
3 public int lastIndexOf(String str) {
4     return super.lastIndexOf(str);
5 }

 

1 // 获取子串逆序下从某位置开始首次出现的位置
2 @Override
3 public int lastIndexOf(String str, int fromIndex) {
4     return super.lastIndexOf(str, fromIndex);
5 }

 

1 // 反转
2 @Override
3 public StringBuilder reverse() {
4     super.reverse();
5     return this;
6 }

 

1 // 返回String对象的引用
2 @Override
3 public String toString() {
4     // Create a copy, don‘t share the array
5     return new String(value, 0, count);
6 }

 

1 // 序列化
2 private void writeObject(java.io.ObjectOutputStream s)
3     throws java.io.IOException {
4     s.defaultWriteObject();
5     s.writeInt(count);
6     s.writeObject(value);
7 }

 

1 // 反序列化
2 private void readObject(java.io.ObjectInputStream s)
3     throws java.io.IOException, ClassNotFoundException {
4     s.defaultReadObject();
5     count = s.readInt();
6     value = (char[]) s.readObject();
7 }