Java学习笔记之String、StringBuffer和StringBuilder

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

基本概念

• 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 ));  }} /** output3123123*/

第一个输出语句：先进行整数求和运算，再将运算结果转换成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();    }}