java StringBuilder、StringBuffer类说明

---

java StringBuilder、StringBuffer类说明

 

 

*************************

相关类与接口

 

StringBuilder

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuilder>, CharSequence
{

    static final long serialVersionUID = 4383685877147921099L;


*********
构造函数
 
    @HotSpotIntrinsicCandidate
    public StringBuilder() {
        super(16);
    }

    @HotSpotIntrinsicCandidate
    public StringBuilder(int capacity) {
        super(capacity);
    }

    @HotSpotIntrinsicCandidate
    public StringBuilder(String str) {
        super(str);
    }

    public StringBuilder(CharSequence seq) {
        super(seq);
    }


*********
append 操作：执行字符串拼接，避免使用"string1" + "string2" + "string3"

    public StringBuilder append(Object obj) {
    public StringBuilder append(String str) {
    public StringBuilder append(StringBuffer sb) {

    public StringBuilder append(CharSequence s) {
    public StringBuilder append(CharSequence s, int start, int end) {

    public StringBuilder append(char[] str) {
    public StringBuilder append(char[] str, int offset, int len) {

    public StringBuilder append(boolean b) {
    public StringBuilder append(char c) {
    public StringBuilder append(int i) {
    public StringBuilder append(long lng) {
    public StringBuilder append(float f) {
    public StringBuilder append(double d) {

    public StringBuilder appendCodePoint(int codePoint) {


*********
insert 操作

    public StringBuilder insert(int index, char[] str, int offset, int len) {
    public StringBuilder insert(int offset, Object obj) {
    public StringBuilder insert(int offset, String str) {
    public StringBuilder insert(int offset, char[] str) {
    public StringBuilder insert(int dstOffset, CharSequence s) {
    public StringBuilder insert(int dstOffset, CharSequence s, int start, int end)

    public StringBuilder insert(int offset, boolean b) {
    public StringBuilder insert(int offset, char c) {
    public StringBuilder insert(int offset, int i) {
    public StringBuilder insert(int offset, long l) {
    public StringBuilder insert(int offset, float f) {
    public StringBuilder insert(int offset, double d) {


*********
indexOf、lastIndexof 操作

    public int indexOf(String str) {
    public int indexOf(String str, int fromIndex) {

    public int lastIndexOf(String str) {
    public int lastIndexOf(String str, int fromIndex) {


*********
其余操作

    public StringBuilder delete(int start, int end) {
    public StringBuilder deleteCharAt(int index) {

    public StringBuilder reverse() {
    public int compareTo(StringBuilder another) {
    public StringBuilder replace(int start, int end, String str) {

    public String toString() {

    private void writeObject(java.io.ObjectOutputStream s)
    private void readObject(java.io.ObjectInputStream s)

说明：StringBuilder的方法均调用AbstractStringBuilder相应方法，非线程安全

 

StringBuffer

 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuffer>, CharSequence
{

    private transient String toStringCache;

    static final long serialVersionUID = 3388685877147921107L;


********
构造方法

    public StringBuffer() {
        super(16);
    }

    public StringBuffer(int capacity) {
    public StringBuffer(String str) {
    public StringBuffer(CharSequence seq) {


**********
append 操作

    public synchronized StringBuffer append(Object obj) {
    public synchronized StringBuffer append(String str) {
    public synchronized StringBuffer append(StringBuffer sb) {
    synchronized StringBuffer append(AbstractStringBuilder asb) {

    public synchronized StringBuffer append(CharSequence s) {
    public synchronized StringBuffer append(CharSequence s, int start, int end) {

    public synchronized StringBuffer append(char[] str) {
    public synchronized StringBuffer append(char[] str, int offset, int len) {

    public synchronized StringBuffer append(boolean b) {
    public synchronized StringBuffer append(char c) {
    public synchronized StringBuffer append(int i) {

    public synchronized StringBuffer appendCodePoint(int codePoint) {
    public synchronized StringBuffer append(long lng) {
    public synchronized StringBuffer append(float f) {
    public synchronized StringBuffer append(double d) {


**********
insert 操作

    public synchronized StringBuffer insert(int index, char[] str, int offset, int len) {
    public synchronized StringBuffer insert(int offset, Object obj) {
    public synchronized StringBuffer insert(int offset, String str) {
    public synchronized StringBuffer insert(int offset, char[] str) {
    public StringBuffer insert(int dstOffset, CharSequence s) {
    public synchronized StringBuffer insert(int dstOffset, CharSequence s, int start, int end) {
    public  StringBuffer insert(int offset, boolean b) {
    public synchronized StringBuffer insert(int offset, char c) {
    public StringBuffer insert(int offset, int i) {
    public StringBuffer insert(int offset, long l) {
    public StringBuffer insert(int offset, float f) {
    public StringBuffer insert(int offset, double d) {


**********
indexOf、lastIndexOf 操作

    public int indexOf(String str) {
    public synchronized int indexOf(String str, int fromIndex) {

    public int lastIndexOf(String str) {
    public synchronized int lastIndexOf(String str, int fromIndex) {


**********
其余操作

    public synchronized String substring(int start) {      //截取子字符串
    public synchronized CharSequence subSequence(int start, int end) {
    public synchronized String substring(int start, int end) {

    public synchronized char charAt(int index) {
    public synchronized void setCharAt(int index, char ch) {
    public synchronized void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)    {

    public synchronized StringBuffer delete(int start, int end) {
    public synchronized StringBuffer deleteCharAt(int index) {

    public synchronized StringBuffer reverse() {
    public synchronized StringBuffer replace(int start, int end, String str) {

    public synchronized int capacity() {
    public synchronized void ensureCapacity(int minimumCapacity) {

    public synchronized int length() {
    public synchronized void setLength(int newLength) {

    public synchronized int codePointAt(int index) {
    public synchronized int codePointBefore(int index) {
    public synchronized int codePointCount(int beginIndex, int endIndex) {
    public synchronized int offsetByCodePoints(int index, int codePointOffset) {

    public synchronized void trimToSize() {
    public synchronized int compareTo(StringBuffer another) {

 
    public synchronized String toString() {

    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)
    private void readObject(java.io.ObjectInputStream s)

    synchronized void getBytes(byte dst[], int dstBegin, byte coder) {

说明：StringBuffer调用AbstractStringBuilder相应方法实现，涉及线程安全的方法均使用锁（synchronized）保证线程安全

 

AbstractStringBuilder

abstract class AbstractStringBuilder implements Appendable, CharSequence {

    byte[] value;     //使用字节数组存储字符串内容

    byte coder;       //编码类型

    int count;        //字符个数

    private static final byte[] EMPTYVALUE = new byte[0];


********
构造函数

    AbstractStringBuilder() {     //无参构造函数字节数组长度为0
        value = EMPTYVALUE;
    }

    AbstractStringBuilder(int capacity) {
    AbstractStringBuilder(String str) {
    AbstractStringBuilder(CharSequence seq) {


********
append 操作

    public AbstractStringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    public AbstractStringBuilder append(String str) {
        if (str == null) {       //str如果为null，将其当做"null"处理
            return appendNull();
        }
        int len = str.length();
        ensureCapacityInternal(count + len);
        putStringAt(count, str);
        count += len;
        return this;
    }

    public AbstractStringBuilder append(StringBuffer sb) {
        return this.append((AbstractStringBuilder)sb);
    }

    AbstractStringBuilder append(AbstractStringBuilder asb) {
        if (asb == null) {
            return appendNull();
        }
        int len = asb.length();
        ensureCapacityInternal(count + len);
        if (getCoder() != asb.getCoder()) {
            inflate();
        }
        asb.getBytes(value, count, coder);
        count += len;
        return this;
    }

    public AbstractStringBuilder append(CharSequence s) {
        if (s == null) {
            return appendNull();
        }
        if (s instanceof String) {
            return this.append((String)s);
        }
        if (s instanceof AbstractStringBuilder) {
            return this.append((AbstractStringBuilder)s);
        }
        return this.append(s, 0, s.length());
    }

    private AbstractStringBuilder appendNull() {        //null当做字符串处理
        ensureCapacityInternal(count + 4);
        int count = this.count;
        byte[] val = this.value;
        if (isLatin1()) {
            val[count++] = 'n';
            val[count++] = 'u';
            val[count++] = 'l';
            val[count++] = 'l';
        } else {
            count = StringUTF16.putCharsAt(val, count, 'n', 'u', 'l', 'l');
        }
        this.count = count;
        return this;
    }

    public AbstractStringBuilder append(CharSequence s, int start, int end) {
        if (s == null) {
            s = "null";
        }
        checkRange(start, end, s.length());
        int len = end - start;
        ensureCapacityInternal(count + len);
        if (s instanceof String) {
            appendChars((String)s, start, end);
        } else {
            appendChars(s, start, end);
        }
        return this;
    }


    public AbstractStringBuilder append(char[] str) {
        int len = str.length;
        ensureCapacityInternal(count + len);
        appendChars(str, 0, len);
        return this;
    }

    public AbstractStringBuilder append(char str[], int offset, int len) {

    public AbstractStringBuilder append(boolean b) {    //true、false当做字符串处理
        ensureCapacityInternal(count + (b ? 4 : 5));
        int count = this.count;
        byte[] val = this.value;
        if (isLatin1()) {
            if (b) {
                val[count++] = 't';
                val[count++] = 'r';
                val[count++] = 'u';
                val[count++] = 'e';
            } else {
                val[count++] = 'f';
                val[count++] = 'a';
                val[count++] = 'l';
                val[count++] = 's';
                val[count++] = 'e';
            }
        } else {
            if (b) {
                count = StringUTF16.putCharsAt(val, count, 't', 'r', 'u', 'e');
            } else {
                count = StringUTF16.putCharsAt(val, count, 'f', 'a', 'l', 's', 'e');
            }
        }
        this.count = count;
        return this;
    }

    public AbstractStringBuilder append(char c) {
    public AbstractStringBuilder append(int i) {
    public AbstractStringBuilder append(long l) {
    public AbstractStringBuilder append(float f) {
    public AbstractStringBuilder append(double d) {


********
substring、subSequence：截取子字符串

    public String substring(int start) {
    public CharSequence subSequence(int start, int end) {
    public String substring(int start, int end) {


********
insert 操作

    public AbstractStringBuilder insert(int index, char[] str, int offset, int len) {
    public AbstractStringBuilder insert(int offset, Object obj) {
    public AbstractStringBuilder insert(int offset, String str) {
    public AbstractStringBuilder insert(int offset, char[] str) {

    public AbstractStringBuilder insert(int dstOffset, CharSequence s) {
        if (s == null) {
            s = "null";
        }
        if (s instanceof String) {
            return this.insert(dstOffset, (String)s);
        }
        return this.insert(dstOffset, s, 0, s.length());
    }

    public AbstractStringBuilder insert(int dstOffset, CharSequence s, int start, int end) {
    public AbstractStringBuilder insert(int offset, boolean b) {
    public AbstractStringBuilder insert(int offset, char c) {
    public AbstractStringBuilder insert(int offset, int i) {
    public AbstractStringBuilder insert(int offset, long l) {
    public AbstractStringBuilder insert(int offset, float f) {
    public AbstractStringBuilder insert(int offset, double d) {


********
indexOf、lastIndexOf 操作

    public int indexOf(String str) {
    public int indexOf(String str, int fromIndex) {

    public int lastIndexOf(String str) {
    public int lastIndexOf(String str, int fromIndex) {


********
其余操作

    public AbstractStringBuilder reverse() {
    public AbstractStringBuilder delete(int start, int end) {
    public AbstractStringBuilder appendCodePoint(int codePoint) {
    public AbstractStringBuilder deleteCharAt(int index) {
    public AbstractStringBuilder replace(int start, int end, String str) {

    public char charAt(int index) {
    public void setCharAt(int index, char ch) {
    public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {

    public int length() {        //字符串个数
    public int capacity() {      //可存储的字符个数

    public void ensureCapacity(int minimumCapacity) {         //容量不足则扩容
    private void ensureCapacityInternal(int minimumCapacity) {

    public IntStream chars() {
    public IntStream codePoints() {

    public void trimToSize() {
    public void setLength(int newLength) {

    public int codePointAt(int index) {
    public int codePointBefore(int index) {
    public int codePointCount(int beginIndex, int endIndex) {
    public int offsetByCodePoints(int index, int codePointOffset) {

    void getBytes(byte dst[], int dstBegin, byte coder) {
    void initBytes(char[] value, int off, int len) {

    final byte getCoder() {
    final byte[] getValue() {
    final boolean isLatin1() {
    int compareTo(AbstractStringBuilder another) {

    private void inflate() {
    private void shift(int offset, int n) {
    private int newCapacity(int minCapacity) {
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private final void putCharsAt(int index, char[] s, int off, int end) {
    private final void putCharsAt(int index, CharSequence s, int off, int end) {
    private final void putStringAt(int index, String str) {

    private final void appendChars(char[] s, int off, int end) {
    private final void appendChars(String s, int off, int end) {
    private final void appendChars(CharSequence s, int off, int end) {

    private static void checkRange(int start, int end, int len) {
    private static void checkRangeSIOOBE(int start, int end, int len) {

 

 

*************************

示例

 

public class MyTest2 {

    public static void main(String[] args){
        StringBuilder stringBuilder=new StringBuilder();
        for (int i=0;i<10;i++){
            stringBuilder.append("hello ").append(i).append(" ");
        }

        System.out.println("拼接后的字符串为："+stringBuilder.toString());
    }
}

 

控制台输出

拼接后的字符串为：hello 0 hello 1 hello 2 hello 3 hello 4 hello 5 hello 6 hello 7 hello 8 hello 9