new String("abc")创建了几个对象引发的思考

1.首先回到问题本身，new String(“abc”)到底会创建几个对象？

1个？2个？正确的说应该是1个或2个吧

情况一：

String str = new String("abc");

这种情况下回创建两个对象。一个是放在堆区的String对象。一个是放在字符串常量池中的“abc”对象。

情况二：

String str = "abc";
String str2 = new String("abc");

这种情况new String(“abc”)只会产生一个对象。

第一种情况：在String的构造函数中的参数是String常量，在这个时候已经创建出了一个在字符串常量池中的“abc”。new String本身也会在堆区中创建一个对象，并把对象的地址引用返回给str变量。

第二种情况：String str = “abc”;这一步已经在字符串常量池中创建了一个abc对象。当String str2 = new String(“abc”);时，参数"abc"用的就是上一步在字符串常量池中创建的“abc”对象。

注：字符串常量池从jdk1.7之后已经从方法区，转移到了堆中

2.String的一些其他思考

思考1. 字符串通过“+”拼接效率真的低吗？

这里的效率和StringBuilder和StringBuffer对比。
在超大（1000万次）的拼接次数下结论是:

StringBuilder > StringBuffer > str + “a”

StringBuilder线程不安全，StringBuffer线程安全

但是我忘了在某个地方看到过（听到过）String字符串拼接在低频次下，做了很多优化，已经和StringBuilder没什么区别了。抱着好奇心就去做了个试验:

public class StringDemo {
    public static void main(String[] args) {
        testString(); //1461
        testStringBuilder();//130
        testStringBuffer();//299

    }

    /**
     * -XX:+PrintGCDetails
     */
    public static void testString() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            String str = i + "";
            for (int j = 0; j < 100; j++) {
                str += "a";
            }

        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void testStringBuilder() {
        long start = System.currentTimeMillis();

        for (int i = 0; i < 100000; i++) {
            StringBuilder builder = new StringBuilder(i+"");
            for (int j = 0; j < 100; j++) {
                builder.append("a");
            }

        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void testStringBuffer() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            StringBuffer buffer = new StringBuffer(i+"");
            for (int j = 0; j < 100; j++) {
                buffer.append("a");
            }

        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

因为低频次下执行一个100个字符串的平均用时太短了，无法测试。所以在外面套了一个10万次的循环。将时间横向放大。结果：

testString(); //1461

testStringBuilder();//130

testStringBuffer();//299

依然是：StringBuilder > StringBuffer > str + “a”；

呵呵。我信了你个鬼。

那么为什么string的拼接效率低呢？

因为Stirng类是final修饰的，在字符串常量中保持值的唯一和不可变的特性。所以在每一次拼接的时候都会创建一个字符串常量，所以性能比较低。其次字符串常量池大小有限，如果在字符串常量中的值过多，容易触发gc。以下是我做测试时，发送的gc情况，惨不忍睹。

思考二：用StringBuilder好还是StringBuffer好？

StringBuilder效率更高，StringBuffer线程安全。用哪个？

我的个人结论：在并发环境下，必用StringBuffer，在单线程环境下，两个区别不大。因为StringBuilder的效率比StringBuffer只是高了一点点。在大频次拼接的情况下才能体现出差别（测试的结论）。当然如果明确是不会有并发问题的情况下StringBiulder当然更好。

思考三：String.intern()的作用？

源码的翻译：当intern方法被执行的时候，如果常量池（字符串常量池）中已经有了这个string（用equals做的比较），那么返回常量池中的string。如果常量池中不存在，那么将其添加到常量池中，并把当前对象的引用返回

测试代码如下：

    public static void testIntern() {
        String str1 = "abc"; //指向常量池abc的引用
        String str2 = new String("abc");//指向堆内存string的引用
        String str3 = str1.intern();//指向常量池abc的引用
        String str4 = str2.intern();//指向常量池abc的引用
        System.out.println("str1 == str2:  " +(str1 == str2));// false
        System.out.println("str1 == str3:  " +(str1 == str3));// true
        System.out.println("str1 == str4:  " +(str1 == str4));// true
        System.out.println("str2 == str3:  " +(str2 == str3));// false
        System.out.println("str2 == str4:  " +(str2 == str4));// false
        System.out.println("str3 == str4:  " +(str3 == str4));// true
    }