java StringBuilder、StringBuffer类说明

川长思鸟来 2022-12-18 04:57 89阅读 0赞

--------------------

### 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