String创建方式内存终极分析

/ 转载 / 无站内评论 / 1186浏览

前言

以前对String 也是一知半解那种,最近刷牛客网经常刷到string创建问题,就兴起想了解透彻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();
    }
}

如果能不含糊的说出运行结果,那你不用往下看了

概念

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

String

String对象是一种特殊的对象。String类是一个不可变的类(final修饰的类)。也就说,String对象一旦创建就不允许修改。 String池: 在java用于保存String,在编译期已确定的,已编译的class文件中的一份可扩充数据。为了提高效率Java引用了字符串池的概念,用于维护java中String的一块独立内存,不同于堆内存和栈内存。 Java中==比较: 通俗的说,==比较内存地址,如果内存地址相同,才返回true。

编译期和运行期

在编译期能确定的String存储在String池中,不能确定的在运行期存在java堆中。 String.intern()方法: 官方解释Returns a canonical representation for the string object.(返回字符串对象的规范化表示形式。)简单点说就是返回String池的字符串。 创建String的三种方式:

直接定义

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

使用关键字new

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

串联生成

如: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
}

首先在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
}

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关键字创建的对象所在的堆空间。

本文转载自: https://blog.csdn.net/kevindai007/article/details/56046570

召唤蕾姆
琼ICP备18000156号

鄂公网安备 42011502000211号