Java学习笔记之StringStringBuffer和StringBuilder

Posted 2020-07-16 GongchuangSu

更多博文可参考我的个人博客：贱贱的梦想

基本概念

• String：此类代表字符串常量，它们的值在创建之后不能更改。
• StringBuffer：是一个线程安全的可变字符序列，它与String一样，在内存中保存的都是一个有序的字符串序列（char类型的数组），不同点是StringBuffer对象的值是可变的。
• StringBuilder：与StringBuffer类基本相同，都是可变字符串系列，不同点是StringBuilder是线程不安全的。

分析

1. 简单的说，String类型和StringBuilder、StringBuffer类型的主要性能区别在于String是不可变的对象。这是由于，每次对String类型进行改变的时候，其实都等同于生成了一个新的String对象，然后将指针指向新的String对象。所以经常改变内容的字符串最好不要用String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
2. 对StringBuffer类型进行改变时，就是对其对象本身进行改变，而不是生成新的对象，再改变对象引用。在一般情况下，推荐使用StringBuffer，特别是字符串对象经常改变的情况下。
3. StringBuffer在程序中可将字符串缓冲区安全地用于多线程，而且在必要时可以对这些方法进行同步。而StringBuilder的使用场景是单线程，不保证同步，该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用时。在这种情况下，它比StringBuffer要快。

equal 和 ==

==用于在比较两个对象的时候，检查两个引用是否指向了同一块内存。
equals() 是object的方法，默认情况下，它与==一样，比较的地址。但是当equal被重载之后，根据设计，equal 会比较对象的value。而这个是java希望有的功能。String 类就重写了这个方法。
例1：

String obj1 = new String("hello");
String obj2 = new String("hello");
if(obj1 == obj2)
    System.out.println(true);
else
    System.out.println(false);

输出为false。

例2：

String obj1 = new String("hello");
String obj2 = new String("hello");
if(obj1.equals(obj2))
    System.out.println(true);
else
    System.out.println(false);

输出为true。

例3：obj1与obj2指向同一块内存

String obj1 = new String("hello");
String obj2 = obj1;
if(obj1 == obj2)
    System.out.println(true);
else
    System.out.println(false);

输出为true。

例4：一种特殊情况

String obj1 = "hello";
String obj2 = "hello";
if(obj1 == obj2)
    System.out.println(true);
else
    System.out.println(false);

输出为true。这是因为程序在运行的时候会创建一个字符串缓冲池。当使用 String obj1 = "xyz"; 这样的表达是创建字符串的时候（非new这种方式），程序首先会在这个 String 缓冲池中寻找相同值的对象，在 String str1 = "xyz"; 中，obj1 先被放到了池中，所以在 obj2 被创建的时候，程序找到了具有相同值的 str1并将 s2 引用 s1 所引用的对象 "xyz"。

例5：

String obj1 = new String("hello");
String obj2 = "hello";
if(obj1 == obj2)
    System.out.println(true);
else
    System.out.println(false);

输出为false。由输出结果可知，obj1对象不在字符串缓冲池中，故在创建obj2时，在缓冲池中没有找到相同值的对象，因此obj1与obj2所指向的引用是不同的。
在Java中，对象都创建在堆内存中。

例6：字符串操作符+

public class Test {
  public static void main(String[] args) {    
      int a = 1;
      int b = 2;
      System.out.println( a + b + "");
      System.out.println("" + a + b );
      System.out.println( a + b + "" + a + b);
      System.out.println("" + ( a + b ));
  }
} 
/** output
3
12
312
3
*/

第一个输出语句：先进行整数求和运算，再将运算结果转换成String输出；
第二个输出语句：由于第一个变量类型为String，后面的变量都得转换成String，然后进行String组合，而不是先进行整数求和运算；
第三个输出语句：由于第一个变量类型不是String，所以先进行求和运算，然后遇到了String类型，运算结果要进行转换，并且后面的int也需要进行转换；
第四个输出语句：虽然第一个变量类型为String，但是后面的括号控制了表达式的赋值顺序，以使得int类型的变量在显示之前确实进行了求和操作。

CharSequence源码分析(基于jdk1.7.79)

package java.lang;
public interface CharSequence {
    /**
     *  返回字符序列的长度
     */
    int length();

    /**
     *  返回指定索引的char值
     */
    char charAt(int index);

    /**
     * 返回该序列的子序列
     * @param start 开始位置的索引值(包括)
     * @param end   结束位置的索引值(不包括)
     * 说明：当start=end时，返回一个空序列
     */
    CharSequence subSequence(int start, int end);

    /**
     *  返回一个包含该序列中字符的字符串，该字符串与序列的顺序相同
     */
    public String toString();
}

StringBuilder源码分析(基于jdk1.7.79)

package java.lang;

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

    /** use serialVersionUID for interoperability */
    static final long serialVersionUID = 4383685877147921099L;

    /**
     * 构造一个不带任何字符的字符串生成器，其初始容量为16个字符
     */
    public StringBuilder() {
        super(16);
    }

    /**
     * 构造一个不带任何字符的字符串生成器，其初始容量由capacity参数设定
     * 说明：其capacity参数值不能小于0，否则会抛出异常NegativeArraySizeException
     */
    public StringBuilder(int capacity) {
        super(capacity);
    }

    /**
     * 构造一个字符串生成器，并初始化指定的字符串内容。其初始容量为指定字符串的
     *     长度加上16
     * 说明：其str不能为null，否则会抛出异常NullPointerException
     */
    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

    /**
     * 构造一个字符串生成器，其包含与指定的字符序列相同的字符。其初始容量为字符
     *     序列的长度加上16
     * 说明：其seq不能为null，否则会抛出异常NullPointerException
     */
    public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }

    /** 
     * 追加Object参数的字符串表示形式到此序列 
     * 说明：如果obj为null，则追加"null"；如果obj不为null，则追加obj.toString()
     */
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    /** 
     * 将指定的字符串追加到此序列 
     * 说明：如果str为null，则追加"null"
     */
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

    /** 将指定的StringBuilder参数追加到此序列 */
    private StringBuilder append(StringBuilder sb) {
        if (sb == null)                     // 如果sb为null，则追加"null"
            return append("null");
        int len = sb.length();
        int newcount = count + len;         // count为之前的字符长度
        if (newcount > value.length)        // 若新的字符长度newcount大于存储容量
            expandCapacity(newcount);       // 则进行扩容
        sb.getChars(0, len, value, count);  // 将sb复制到原字符序列的尾部
        count = newcount;                   // 更新字符长度
        return this;
    }

    /** 将指定的StringBuffer追加到此序列 */ 
    public StringBuilder append(StringBuffer sb) {
        super.append(sb);
        return this;
    }

    /** 将指定的CharSequence追加到此序列 */
    public StringBuilder append(CharSequence s) {
        if (s == null)
            s = "null";
        if (s instanceof String)
            return this.append((String)s);
        if (s instanceof StringBuffer)
            return this.append((StringBuffer)s);
        if (s instanceof StringBuilder)
            return this.append((StringBuilder)s);
        return this.append(s, 0, s.length());
    }

    /** 将指定的CharSequence子序列追加到此序列 */
    public StringBuilder append(CharSequence s, int start, int end) {
        super.append(s, start, end);
        return this;
    }

    /** 将char数组参数的字符串表示形式追加到此序列 */
    public StringBuilder append(char[] str) {
        super.append(str);
        return this;
    }

    /** 将char数组参数的子数组的字符串表示形式追加到此序列 */
    public StringBuilder append(char[] str, int offset, int len) {
        super.append(str, offset, len);
        return this;
    }

    /**
     * 将boolean参数的字符串表示形式追加到此序列
     * 说明：若b为true，则追加"true"；若b为false，则追加"false"
     */
    public StringBuilder append(boolean b) {
        super.append(b);
        return this;
    }

    /** 将char字符的字符串表示形式追加到此序列 */
    public StringBuilder append(char c) {
        super.append(c);
        return this;
    }

    /** 将int参数的字符串表示形式追加到此序列 */
    public StringBuilder append(int i) {
        super.append(i);
        return this;
    }

    /** 将int参数的字符串表示形式追加到此序列 */
    public StringBuilder append(long lng) {
        super.append(lng);
        return this;
    }

    /** 将float参数的字符串表示形式追加到此序列 */
    public StringBuilder append(float f) {
        super.append(f);
        return this;
    }

    /** 将double参数的字符串表示形式追加到此序列 */
    public StringBuilder append(double d) {
        super.append(d);
        return this;
    }

    /** 将codePoint参数的字符串表示形式追加到此序列 */
    public StringBuilder appendCodePoint(int codePoint) {
        super.appendCodePoint(codePoint);
        return this;
    }

    /** 
     * 移除此序列的子字符串中的字符 
     * 说明：包含起始索引但不包括结束索引
     */
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }

    /** 移除此序列指定位置上的字符 */
    public StringBuilder deleteCharAt(int index) {
        super.deleteCharAt(index);
        return this;
    }

    /** 
      * 使用给定的String中的字符替换此序列的子字符串中的字符
      * 该子字符串从指定的start处开始，一直到索引end-1处的字符
      */
    public StringBuilder replace(int start, int end, String str) {
        super.replace(start, end, str);
        return this;
    }

    /**
     * 将str数组参数的子数组的字符串表示形式插入到此序列中
     * 子数组从指定的offset(包括offset)开始，包括len个char
     * 子数组的字符将被插入到index所指示的位置
     */
    public StringBuilder insert(int index, char[] str, int offset,
                                int len)
    {
        super.insert(index, str, offset, len);
        return this;
    }

    /** 将Object参数的字符串表示形式插入到此字符序列中 */
    public StringBuilder insert(int offset, Object obj) {
        return insert(offset, String.valueOf(obj));
    }

    /** 将字符串插入到此序列 */
    public StringBuilder insert(int offset, String str) {
        super.insert(offset, str);
        return this;
    }

    /** 将char数组参数的字符串表示形式插入此序列中 */
    public StringBuilder insert(int offset, char[] str) {
        super.insert(offset, str);
        return this;
    }

    /** 将指定的CharSequence插入此序列中 */
    public StringBuilder 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());
    }

    /** 将指定 CharSequence 的子序列插入此序列中 */
    public StringBuilder insert(int dstOffset, CharSequence s,
                                int start, int end)
    {
        super.insert(dstOffset, s, start, end);
        return this;
    }

    /** 将 boolean 参数的字符串表示形式插入此序列中 */
    public StringBuilder insert(int offset, boolean b) {
        super.insert(offset, b);
        return this;
    }

    /** 将 char 参数的字符串表示形式插入此序列中 */
    public StringBuilder insert(int offset, char c) {
        super.insert(offset, c);
        return this;
    }

    /** 将 int 参数的字符串表示形式插入此序列中 */
    public StringBuilder insert(int offset, int i) {
        return insert(offset, String.valueOf(i));
    }

    /** 将 long 参数的字符串表示形式插入此序列中 */
    public StringBuilder insert(int offset, long l) {
        return insert(offset, String.valueOf(l));
    }

    /** 将 float 参数的字符串表示形式插入此序列中 */
    public StringBuilder insert(int offset, float f) {
        return insert(offset, String.valueOf(f));
    }

    /** 将 double 参数的字符串表示形式插入此序列中 */
    public StringBuilder insert(int offset, double d) {
        return insert(offset, String.valueOf(d));
    }

    /** 返回指定子字符串在此字符串中第一次出现处的索引 */
    public int indexOf(String str) {
        return indexOf(str, 0);
    }

    /** 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始*/
    public int indexOf(String str, int fromIndex) {
        return String.indexOf(value, 0, count,
                              str.toCharArray(), 0, str.length(), fromIndex);
    }

    /** 返回最右边出现的指定子字符串在此字符串中的索引 */
    public int lastIndexOf(String str) {
        return lastIndexOf(str, count);
    }

    /** 从指定位置开始，返回最右边出现的指定子字符串在此字符串中的索引 */
    public int lastIndexOf(String str, int fromIndex) {
        return String.lastIndexOf(value, 0, count,
                              str.toCharArray(), 0, str.length(), fromIndex);
    }

    /** 将此字符序列用其反转形式取代 */
    public StringBuilder reverse() {
        super.reverse();
        return this;
    }

    /** 返回此序列中数据的字符串表示形式 */
    public String toString() {
        // Create a copy, don‘t share the array
        return new String(value, 0, count);
    }

    /**
     * Save the state of the <tt>StringBuilder</tt> instance to a stream
     * (that is, serialize it).
     *
     * @serialData the number of characters currently stored in the string
     *             builder (<tt>int</tt>), followed by the characters in the
     *             string builder (<tt>char[]</tt>).   The length of the
     *             <tt>char</tt> array may be greater than the number of
     *             characters currently stored in the string builder, in which
     *             case extra characters are ignored.
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        s.defaultWriteObject();
        s.writeInt(count);
        s.writeObject(value);
    }

    /**
     * readObject is called to restore the state of the StringBuffer from
     * a stream.
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        count = s.readInt();
        value = (char[]) s.readObject();
    }

}