java---String、StringBuilder、StringBuffer

StringBuilder简介

StringBuilder最早出现在JDK1.5，是一个字符拼接的工具类，它和StringBuffer一样都继承自父类AbstractStringBuilder，在AbstractStringBuilder中使用char[] value字符数组保存字符串，但是没有用final关键字修饰，所以StringBuilder是可变的。

StringBuilder常用方法

StringBuilder—append

可以把任意类型添加到字符串缓冲区里面,并返回字符串缓冲区本身
可接收大部分基本数据类型、String、char[]等等，甚至能接收StringBuilder。

//append源码
@Override
public StringBuilder append(Object obj) {
    return append(String.valueOf(obj));
}

@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

/**
 * Appends the specified {@code StringBuffer} to this sequence.
 * <p>
 * The characters of the {@code StringBuffer} argument are appended,
 * in order, to this sequence, increasing the
 * length of this sequence by the length of the argument.
 * If {@code sb} is {@code null}, then the four characters
 * {@code "null"} are appended to this sequence.
 * <p>
 * Let <i>n</i> be the length of this character sequence just prior to
 * execution of the {@code append} method. Then the character at index
 * <i>k</i> in the new character sequence is equal to the character at
 * index <i>k</i> in the old character sequence, if <i>k</i> is less than
 * <i>n</i>; otherwise, it is equal to the character at index <i>k-n</i>
 * in the argument {@code sb}.
 *
 * @param   sb   the {@code StringBuffer} to append.
 * @return  a reference to this object.
 */
public StringBuilder append(StringBuffer sb) {
    super.append(sb);
    return this;
}

@Override
public StringBuilder append(CharSequence s) {
    super.append(s);
    return this;
}

/**
 * @throws     IndexOutOfBoundsException {@inheritDoc}
 */
@Override
public StringBuilder append(CharSequence s, int start, int end) {
    super.append(s, start, end);
    return this;
}

@Override
public StringBuilder append(char[] str) {
    super.append(str);
    return this;
}

/**
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
@Override
public StringBuilder append(char[] str, int offset, int len) {
    super.append(str, offset, len);
    return this;
}

@Override
public StringBuilder append(boolean b) {
    super.append(b);
    return this;
}

@Override
public StringBuilder append(char c) {
    super.append(c);
    return this;
}

@Override
public StringBuilder append(int i) {
    super.append(i);
    return this;
}

@Override
public StringBuilder append(long lng) {
    super.append(lng);
    return this;
}

@Override
public StringBuilder append(float f) {
    super.append(f);
    return this;
}

@Override
public StringBuilder append(double d) {
    super.append(d);
    return this;
}

//示例代码
StringBuilder sb = new StringBuilder();
sb.append(8).append("乘以").append(6.6).append('=').append(true);
sb.append(new StringBuilder("!!!"));
System.out.println(sb); // 输出结果为：8乘以6.6=true!!!

StringBuilder-----revserse()

根据索引把某部分替换成其它的。

    @Override
    public StringBuilder reverse() {
        super.reverse();
        return this;
    }
    
public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;
            if (Character.isSurrogate(cj) ||
                Character.isSurrogate(ck)) {
                hasSurrogates = true;
            }
        }
        if (hasSurrogates) {
            reverseAllValidSurrogatePairs();
        }
        return this;
    }

//示例代码
        StringBuilder sb = new StringBuilder("猪头大一来过上海");
        sb.reverse();
        System.out.println(sb); // 输出结果为：海上过来一大头猪

StringBuilder-----replace(int start,int end,String str)

根据索引把某部分替换成其它的。

@Override
    public StringBuilder replace(int start, int end, String str) {
        super.replace(start, end, str);
        return this;
    }

   public AbstractStringBuilder replace(int start, int end, String str) {
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (start > count)
            throw new StringIndexOutOfBoundsException("start > length()");
        if (start > end)
            throw new StringIndexOutOfBoundsException("start > end");

        if (end > count)
            end = count;
        int len = str.length();
        int newCount = count + len - (end - start);
        ensureCapacityInternal(newCount);

        System.arraycopy(value, end, value, start + len, count - end);
        str.getChars(value, start);
        count = newCount;
        return this;
    }

  StringBuilder sb = new StringBuilder("春眠不觉晓，处处闻啼鸟。");
    sb.replace(8, 11, "蚊子咬");
    System.out.println(sb); // 输出结果为：春眠不觉晓，处处蚊子咬。

StringBuilder-----void delete(int start, int end)

根据索引删减某部分。

  @Override
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder deleteCharAt(int index) {
        super.deleteCharAt(index);
        return this;
    }

StringBuilder sb = new StringBuilder("爸爸的脸蛋有很多褶皱");
sb.delete(3, 4);
System.out.println(sb); // 输出结果为：爸爸的蛋有很多褶皱

StringBuilder-----void insert(int offset, XXX xxx)

在索引位置插入一段。

 @Override
    public StringBuilder insert(int index, char[] str, int offset,
                                int len)
    {
        super.insert(index, str, offset, len);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, Object obj) {
            super.insert(offset, obj);
            return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, String str) {
        super.insert(offset, str);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, char[] str) {
        super.insert(offset, str);
        return this;
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int dstOffset, CharSequence s) {
            super.insert(dstOffset, s);
            return this;
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int dstOffset, CharSequence s,
                                int start, int end)
    {
        super.insert(dstOffset, s, start, end);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, boolean b) {
        super.insert(offset, b);
        return this;
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, char c) {
        super.insert(offset, c);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, int i) {
        super.insert(offset, i);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, long l) {
        super.insert(offset, l);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, float f) {
        super.insert(offset, f);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int offset, double d) {
        super.insert(offset, d);
        return this;
    }




   public AbstractStringBuilder insert(int offset, double d) {
        return insert(offset, String.valueOf(d));
    }
    public AbstractStringBuilder insert(int offset, String str) {
        if ((offset < 0) || (offset > length()))
            throw new StringIndexOutOfBoundsException(offset);
        if (str == null)
            str = "null";
        int len = str.length();
        ensureCapacityInternal(count + len);
        System.arraycopy(value, offset, value, offset + len, count - offset);
        str.getChars(value, offset);
        count += len;
        return this;
    }

//示例代码
StringBuilder sb = new StringBuilder("《摔跤吧！爸爸》");
sb.insert(3, "了");
System.out.println(sb); // 输出结果为：《摔跤了吧！爸爸》

其他方法：
int indexOf(String str)，输出第一个匹配的索引。
int indexOf(String str, int fromIndex)，从指定的索引处开始，输出第一个匹配的索引。
int lastIndexOf(String str)，输出最后一个匹配的索引。
int lastIndexOf(String str, int fromIndex)，从指定的索引处开始，输出最后一个匹配的索引。
toString()
writeObject(java.io.ObjectOutputStream s)
readObject(java.io.ObjectInputStream s)
new StringBuilder(int capacity)
StringBuilder默认的初始容量是16，可用带参构造器来自定义初始容量。当字符个数达到了当前容量，则容量会自动提升，容量提升的规律为：新容量 = 旧容量 * 2 + 2。

int capacity() 返回当前字符序列的容量。

int length() 返回当前已存储的字符的个数
char charAt(int index)，根据索引，得到相应字符。
String substring(int start)，根据索引，以字符串形式截取尾部段。
String substring(int start, int end)，根据索引，以字符串形式截取内部段。
String toString()，以字符串形式输出整段。

StringBuffer

StringBuilder常用方法

方法摘要

所有方法实例方法具体的方法 变量和类型 方法 描述 StringBuffer append​(boolean b) 将 boolean参数的字符串表示形式追加到序列中。
StringBuffer append​(char c) 将 char参数的字符串表示形式追加到此序列。
StringBuffer append​(char[] str) 将char数组参数的字符串表示形式追加到此序列。
StringBuffer append​(char[] str, int offset,int len) 将 char数组参数的子数组的字符串表示形式追加到此序列。
StringBuffer append​(doubled) 将 double参数的字符串表示形式追加到此序列。
StringBuffer append​(float f) 将float参数的字符串表示形式追加到此序列。
StringBuffer append​(int i) 将 int参数的字符串表示形式追加到此序列。
StringBuffer append​(long lng) 将long参数的字符串表示形式追加到此序列。
StringBuffer append​(CharSequence s) 将指定的CharSequence追加到此序列。
StringBuffer append​(CharSequence s, int start,int end) 将指定的 CharSequence序列附加到此序列。 StringBuffer append​(Object obj) 追加 Object参数的字符串表示形式。
StringBuffer append​(String str)将指定的字符串追加到此字符序列。
StringBuffer append​(StringBuffer sb) 将指定的StringBuffer追加到此序列。
StringBuffer appendCodePoint​(int codePoint) 将codePoint参数的字符串表示形式追加到此序列。
int capacity() 返回当前容量。
char charAt​(intindex) 返回指定索引处的此序列中的 char值。
IntStream chars() 返回 int的流，对此序列中的char值进行零扩展。
int codePointAt​(int index) 返回指定索引处的字符（Unicode代码点）。
int codePointBefore​(int index) 返回指定索引之前的字符（Unicode代码点）。
int codePointCount​(int beginIndex, int endIndex) 返回此序列的指定文本范围内的Unicode代码点数。
IntStream codePoints() 返回此序列中的代码点值流。
int compareTo​(StringBuffer another) StringBuffer字典顺序比较两个StringBuffer实例。
StringBuffer delete​(int start, int end) 删除此序列的子字符串中的字符。
StringBuffer deleteCharAt​(int index) 按此顺序删除指定位置的 char 。
void ensureCapacity​(int minimumCapacity) 确保容量至少等于指定的最小值。
void getChars​(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst 。
int indexOf​(String str) 返回指定子字符串第一次出现的字符串中的索引。
int indexOf​(String str, int fromIndex) 从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
StringBuffer insert​(int offset,boolean b) 将 boolean参数的字符串表示形式插入此序列中。
StringBuffer insert​(int offset, char c) 将 char参数的字符串表示形式插入此序列中。
StringBuffer insert​(int offset, char[] str) 将 char数组参数的字符串表示形式插入此序列中。
StringBuffer insert​(int index, char[] str, int offset, int len) 将 str数组参数的子数组的字符串表示形式插入此序列中。
StringBuffer insert​(int offset, double d) 将 double参数的字符串表示形式插入此序列中。
StringBuffer insert​(int offset, float f) 将float参数的字符串表示形式插入此序列中。
StringBuffer insert​(int offset, int i) 将第二个int参数的字符串表示形式插入到此序列中。
StringBuffer insert​(int offset, long l) 将long参数的字符串表示形式插入此序列中。
StringBuffer insert​(int dstOffset, CharSequences) 将指定的 CharSequence插入此序列。
StringBuffer insert​(int dstOffset, CharSequence s, int start, int end) 将指定的 CharSequence序列插入此序列。
StringBuffer insert​(int offset, Object obj) 将 Object参数的字符串表示形式插入此字符序列。
StringBuffer insert​(int offset, String str) 将字符串插入此字符序列。
int lastIndexOf​(String str) 返回指定子字符串最后一次出现的字符串中的索引。
int lastIndexOf​(String str, int fromIndex) 返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。
int offsetByCodePoints​(int index, int codePointOffset) 返回此序列中的索引，该索引从给定的 index偏移 codePointOffset代码点。
StringBuffer replace​(int start, int end, String str) 使用指定的String的字符替换此序列的子字符串中的字符。
StringBuffer reverse() 导致此字符序列被序列的反向替换。
void setCharAt​(int index, char ch) 指定索引处的字符设置为 ch 。
void setLength​(int newLength) 设置字符序列的长度。
CharSequence subSequence​(int start, int end) 返回一个新的字符序列，它是该序列的子序列。
String substring​(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。
String substring​(int start, int end) 返回一个新的 String
，其中包含当前包含在此序列中的字符的子序列。 void trimToSize() 尝试减少用于字符序列的存储空间。