Java String总结

String 类

String类定代码如下：

/**
* The <code>String</code> class represents character strings. All
* string literals in Java programs, such as <code>"abc"</code>, are
* implemented as instances of this class.
* <p>
* Strings are constant; their values cannot be changed after they
* are created. String buffers support mutable strings.
* Because String objects are immutable they can be shared.
*/

public final class String
   implements java.io.Serializable, Comparable<String>, CharSequence {
}

从代码看有两点需要注意：

String类为 final 不可以被继承
String对象一旦创建就不可改变

常量池

常量池常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final)，以及还包含一些以文本形式出现的符号引用，比如：

类和接口的全限定名
字段的名称和描述符
方法和名称和描述符

以字面值出现的字符串会保存在常量池中，以new创建的字符串则会保存在堆中，例如：

String str = "ABC";

这段代码执行时，首现创建一个String类型的引用str，然后再常量池中，查找"ABC"，如果找到则str指向"ABC"，如果没有找到先将"ABC"放入常量池，再将str指向"ABC"。下面是一个例子：

public class ContactPollTest {

    String mString = "ABC";

    /**
     * @param args
     */
    public static void main(String[] args) {
        ContactPollTest newTest = new ContactPollTest();
        newTest.testConstantPoll();
    }

    public void testConstantPoll() {
        String stra = "ABC";
        String strb = "ABC";
        String strc = "A" + "BC";
        String strd = "A";
        String stre = strd + "BC";
        final String strf = "A";
        String strg = strf + "BC";
        String strh = new String("ABC");
        System.out.print("testFieldAndVariant stra = mString?:" + (stra == mString) + "\r\n");
        System.out.print("testConstantPoll stra = strb?:" + (stra == strb) + "\r\n");
        System.out.print("testConstantPoll stra = strc?:" + (stra == strc) + "\r\n");
        System.out.print("testConstantPoll stra = stre?:" + (stra == stre) + "\r\n");
        System.out.print("testConstantPoll stra = strg?:" + (stra == strg) + "\r\n");
        System.out.print("testConstantPoll stra = strh?:" + (stra == strh) + "\r\n");
        System.out.print("testConstantPoll stra = stri?:" + (stra == stri) + "\r\n");
        System.out.print("testConstantPoll stra = strj?:" + (stra == strj) + "\r\n");
    }

    static String getString() {
        return "BC";
    }
    
    final static String sFianlString = "BC";
    
    static String getFinalString() {
        return sFianlString;
    }
}

输出结果如下:

testFieldAndVariant stra = mString?:true
testConstantPoll stra = strb?:true
testConstantPoll stra = strc?:true
testConstantPoll stra = stre?:false
testConstantPoll stra = strg?:true
testConstantPoll stra = strh?:false
testConstantPoll stra = stri?:false#

解释如下:

mString 和 stra，strb都指向了常量池中的 "ABC" 因此前行输出为true
String strc = "A" + "BC" 在编译时被优化为了 String stra = "ABC"因此第三行输出为true
String stre = strd + "BC"，引用了strd，需要重新在堆中创建
strf为final，因此strg = strf + "BC"; 也被编译器优化为strg = "ABC";
strh是通过new创建，所以内存分配在堆上，因此最后一行结果为false
通过函数获得字符串，都会在堆上创建新的对象

StringBuilder & StringBuffer

String具有不可变性，StringBuilder和StringBuffer用于创建一个可变的字符串，两者的区别在后者是前者的同步版本。下面我们来比较几段代码的性能：

public class StringBuilderTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        testStringConstant();
        testStringVariant();
        testStringBuilder();
        testStringBuffer();
    }

    static void testStringConstant() {
        String a = "";
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            a += "a";
        }
        long end = System.currentTimeMillis();
        System.out.print("testStringConstant consume:" + (end - begin) + " \r\n");
    }

    static void testStringVariant() {
        String b = "a";
        String a = "";
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            a += b;
        }
        long end = System.currentTimeMillis();
        System.out.print("testStringVariant consume:" + (end - begin) + " \r\n");
    }

    static void testStringBuilder() {
        StringBuilder sb = new StringBuilder();
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            sb.append("a");
        }
        long end = System.currentTimeMillis();
        System.out.print("testStringBuilder consume:" + (end - begin) + " \r\n");
    }

    static void testStringBuffer() {
        StringBuffer sb = new StringBuffer();
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            sb.append("a");
        }
        long end = System.currentTimeMillis();
        System.out.print("testStringBuffer consume:" + (end - begin) + " \r\n");
    }

}

输出结果为:

testStringConstant consume:3902
testStringVariant consume:3538
testStringBuilder consume:6
testStringBuffer consume:6

性能的差异可以从编译出的字节码看出：

testStringConstant
[站外图片上传中...(image-e51349-1511918381002)]

从字节码的9行可以看出编译器已经使用StringBuilder进行优化，但是每次循环都会new一个StringBuilder对象。

testStringVariant

testStringVariant

从字节码的10行可以看出编译器已经使用StringBuilder进行优化，但是每次循环都会new一个StringBuilder对象.
和testStringConstant的性能差距应该在于前者"a"需要在常量池中查找，后者直接通过栈中的引用取值。
testStringBuilder & testStringBuffer

testStringBuilder

从字节码可以看出testStringBuilder函数的写法，可以避免多次创建StringBuilder对象，以及该toString方法。testStringBuffer的情况类似。