4-String创建方式内存分析

问题：

看下面的代码，能否说出运行结果？

public class TestString {

    public static void m1() {
        String a = "a1";
        String b = "a" + 1;
        System.out.println(a == b);
    }

    public static void m2() {
        String a = "ab";
        String bb = "b";
        String b = "a" + bb;
        System.out.println(a == b);
    }

    public static void m3() {
        String a = "ab";
        final String bb = "b";
        String b = "a" + bb;
        System.out.println(a == b);
    }

    public static void m4() {
        String a = "ab";
        final String bb = getBB();
        String b = "a" + bb;
        System.out.println(a == b);
    }

    private static String getBB() {
        return "b";
    }


    private static String a = "ab";
    public static void m5() {
        String s1 = "a";
        String s2 = "b";
        String s = s1 + s2;
        System.out.println(s == a);
        System.out.println(s.intern() == a);
    }

    private static String ab = new String("ab");
    public static void m6() {
        String s1 = "a";
        String s2 = "b";
        String s = s1 + s2;
        System.out.println(s == ab);
        System.out.println(s.intern() == ab);
        System.out.println(s.intern() == ab.intern());
    }

    private static void m7() {
        String s1 = "a";
        String s2 = new String("a");
        s2.intern();
        System.out.println(s1 == s2);
        s2 = s2.intern();
        System.out.println(s1 == s2);
    }

    public static void main(String[] args) {
        m1();
        m2();
        m3();
        m4();
        m5();
        m6();
        m7();
    }
}

如果能不含糊的说出运行结果，这篇博文不用看了。。。

概念：

要想解释清楚原理，首先要明确几个概念：

1. String： String对象是一种特殊的对象。String类是一个不可变的类(final修饰的类)。也就说，String对象一旦创建就不允许修改。
2. String池： 在java用于保存String，在编译期已确定的，已编译的class文件中的一份可扩充数据。为了提高效率Java引用了字符串池的概念，用于维护java中String的一块独立内存，不同于堆内存和栈内存。
3. Java中==比较： 通俗的说，==比较内存地址，如果内存地址相同，才返回true。
4. 编译期和运行期： 在编译期能确定的String存储在String池中，不能确定的在运行期存在java堆中。
5. String.intern()方法： 官方解释Returns a canonical representation for the string object.（返回字符串对象的规范化表示形式。）简单点说就是返回String池的字符串。

创建String的三种方式：

1. 直接定义：如：String s1 = “myString”;  
   首先在String池中查找是否存在”myString”，如果没有，在String池中创建”myString”，如果有，编译期间直接指向该String池地址。  
   

2. 使用关键字new：如：String s1 = new String(“myString”);  
   可以拆分成两句理解，String buffer = “myString”;String s1 = new String(buffer);编译期：首先检查String池中有无myString，没有就在String池中创建；运行期：为new的s1开辟堆内存空间，s1指向堆内存中”myString”。  
   

3. 串联生成：如：String s1 = “my” + “String”;或String s1 = “my”;String s2 = s1 + “String”;  
   这种方法比较复杂。如果是第一种常量拼接，编译期间就能确定，s1指向String池；如果是第二种拼接，由于s1在编译期间不能确定，所以s2在运行期间指向java堆。

解释：

接下来一个一个看:

1.

public static void m1() {
    String a = "a1";
    String b = "a" + 1;
    System.out.println(a == b);  // true
}

• 1
• 2
• 3
• 4
• 5

• 1
• 2
• 3
• 4
• 5

首先在String池中创建”a1”，a指向String池中”a1”，然后在String池中创建”a”和”1”，b是前两者的拼接，所以首先在String池中查找有无”a1”，有就直接指向，所以b也指向String池中的”a1”，在编译期间就已经确定了内存地址，所以true。

2.

public static void m2() {
    String a = "ab";
    String bb = "b";
    String b = "a" + bb;
    System.out.println(a == b);  // false
}

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

a指向String池中的”ab”，bb指向String池中的”b”，b在编译期间不能确定，所以在运行期间b会指向Java堆中的”ab”，所以false。

3.

public static void m3() {
    String a = "ab";
    final String bb = "b";
    String b = "a" + bb;
    System.out.println(a == b);  // true
}

a指向String池中”ab”，因为bb是final类型，所以在编译期间会当做常量处理，bb在编译期间等同于”b”，所以a和b都指向String池中”ab”，所以true。

4.

public static void m4() {
    String a = "ab";
    final String bb = getBB();
    String b = "a" + bb;
    System.out.println(a == b);  // false
}
private static String getBB() {
    return "b";
}

方法也是在运行期间才能确定，所以false。

5.

private static String a = "ab";
public static void m5() {
    String s1 = "a";
    String s2 = "b";
    String s = s1 + s2;
    System.out.println(s == a);  // false
    System.out.println(s.intern() == a);  // true
}

a指向String池中”ab”，s在编译期间不确定，运行期间指向堆内存中”ab”，所以第一个是false；第二个用了intern()方法，返回String池中字符串，所以true。

6.

private static String ab = new String("ab");
public static void m6() {
    String s1 = "a";
    String s2 = "b";
    String s = s1 + s2;
    System.out.println(s == ab);  // false
    System.out.println(s.intern() == ab);  // false
    System.out.println(s.intern() == ab.intern());  // true
}

s1指向String池的”a”，s2指向String池的”b”，ab因为是new出来的，所以运行期间指向堆内存的”ab”，s编译期间不能确定，在运行期间指向堆内存的”ab”，堆内存中每次都是创建新字符串，所以第一个是false；第二个由于用了intern()方法，返回String池中的”ab”，但ab指向的是堆内存的”ab”，所以第二个也是false；第三个由于都用了intern()方法，都是String池中的”ab”，所以true。

7.

    private static void m7() {
        String s1 = "a";
        String s2 = new String("a");
        s2.intern();
        System.out.println(s1 == s2);  // false
        s2 = s2.intern();
        System.out.println(s1 == s2);  // true
    }

s2.intern();调用一下s2的intern()方法，首先在String池中寻找有无”a”，有直接返回引用，没有的话先在String池中创建”a”，再返回引用。第一个输出没有赋值，所以false，第二个将s2指向String池中的”a”，所以true。

总结：

引用网上的不错的总结：

• 原理1： 当使用任何方式来创建一个字符串对象s时，Java运行时（运行中JVM）会拿着这个X在String池中找是否存在内容相同的字符串对象，如果不存在，则在池中创建一个字符串s，否则，不在池中添加。

• 原理2： Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。

• 原理3： 使用直接指定或者使用纯字符串串联来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象。

• 原理4： 使用包含变量的表达式来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String对象。

Java常量池

• 在java中，不光String包含运用了常量池技术，java基本类型的包装类的大部分都实现了常量池技术，这些类是Byte、Short、Integer、Long、Character、Boolean，另外两种浮点数类型的包装类则没有实现。另外Byte、Short、Integer、Long、Character这5种整型的包装类也只是在对应值小于等于127时才可使用常量池，也即常量池不负责创建和管理大于127的这些类的对象。
• 常量池是为了方便快捷地创建某些对象而出现的，当需要一个对象时，就可以从池中取一个出来（如果池中没有则创建一个），在需要重复创建相等变量时节省了很多时间。常量池其实也就是一个内存空间，不同于使用new关键字创建的对象所在的堆空间。