【Java String学习】String s1 = new String(“abc”)创建了几个对象？String s1 =new String(“abc）和String s2 = “abc”的区别

写了有关String创建的一系列的问题,总结为:(假设字符串常量池为空)
● 使用String s=new String(“abc”)，如果常量池没有，则在堆和常量池创建对象，最后指向堆
● 直接赋值String s=“abc”，只在常量池创建,栈中放引用，堆中没有创建对象，最后指向常量池。
● 使用String s=new String(“ab”)+"c"拼接，则在池中创建new的字符串和赋值的字符串，最后指向堆
● 使用String s=“ab”+"c"拼接，在池中创建拼接好的字符串“abc”，最后指向常量池
下面是测试详细的过程：

public class StringTest {
    @Test
    public void StringInfo() {
        String s1 = new String("abc");
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = "abc";

        //s1和s2不同，因为s1会同时在堆和字符串常量池中创建对象，s1中存到是指向堆中“abc"的引用，s2存的是指向字符串常量池中的引用
        System.out.println(s1 == s2); //false

        //s1和s3也不同，因为显示的使用了new，肯定会在堆里新建一个“abc”，字符串常量池中已经有“abc”了，就不会再创建了，但是s3会指向堆里新创建的“abc”
        System.out.println(s1 == s3); //false

        //s2和s3不同，因为虽然字符串常量池中有了“abc”，但是s3使用了new，所以会在堆里创建对象，并指向堆。
        System.out.println(s2 == s3); //false

        //s2和s4相同，他们没有使用new，都指向字符串常量池中的“abc”
        System.out.println(s2 == s4); //true

        System.out.println("----------------------------------");
        //进一步的
        System.out.println("前提：s1为堆中的“abc”，s2为字符串常量池中的“abc”");

        String s5 = new String("ab") + "c";
        String s6 = "ab" + "c";
        String s7_1 = "ab";
        String s7_2 = "c";
        String s7 = s7_1 + s7_2;

        //s5会在堆里和池中新建对象“ab”，在编译时把“c”放到池中。然后使用StringBuilder拼接“ab”和“c”，最后使用toString创建一个新的堆里的对象，不是池中的。
        System.out.println(s5 == s1);//false
        System.out.println(s5 == s2);//false

        //s6中字符会自动拼接成“abc”，然后指向常量池中的数据，
        System.out.println(s6 == s2);//true

        //s7同样是拼接，但是由于String是不可变的，第三步拼接实际上会返回一个新的String对象，也指向堆，这个新建的对象不会在常量池中检测和创建
        System.out.println(s7 == s2);//false
        System.out.println(s7 == s6);//false
    }

    /**
     * 判断字符串是否在字符串常量池中
     * @param str
     * @return
     */

    /**
     * 到底在字符串常量池创建了什么
     */
    @Test
    public void StringInfo2(){
        //再进一步的
        String s1 = new String("abc");
        String s2 = "abc";
        System.out.println("前提：s1为堆中的“abc”，s2为字符串常量池中的“abc”");

        //String s5 = new String("ab") + "c";，如果拼接得到的“abc”常量池中没有， 这个新创建的对象会不会同步到池中去呢？
        //为了方便判断，先看一个之前没有的例子
        //一般会这么问，给3个变量
        String s5_1 = new String("ab") + "cd";
        String s5_2="abcd";
        String s5_3=s5_1.intern();
        System.out.println(s5_3 == s5_1); //1是指向堆的，3是指向常量池的 false
        System.out.println(s5_3 == s5_2); //2是常量池的，所以true

        //但是，如果不定义String s5_2="abcd";，即该步骤不会在常量池放"abcd"，会得到不一样的结果
        String s5_4=new String("xy")+"z";
        String s5_5=s5_4.intern();
        System.out.println(s5_5 == s5_4); //true 会得到true的结果，如果String s5_4=new String("xy")+"z";会在常量池创建“xyz”，
                                            // 那么这里s5_5应该指向常量池中的“xyz",应该为false才对，但是现在为true


        //todo 暂定答案是：不会
        //总结：new String("ab")创建了一个新的字符串对象，会在堆中创建一个“ab”，同时检测常量池，没有也同样创建“ab”
        //"c"是一个字符串字面量，在编译时就会放入常量池中。
        //所以常量池中创建的是“ab”和“c“
        String s5 = new String("ab") + "c";
        System.out.println(s5 == s2);//false

        //那么，String s6 = "ab" + "c"; 呢
        //在Java中，编译器会对字符串常量进行编译时优化，将相邻的字符串常量直接连接起来，形成一个新的字符串常量。
        // 因此，对于 String s6 = "ab" + "c"; 如果常量池为空，
        // 编译器会在常量池中创建一个值为 "abc" 的字符串常量，而不是创建 "ab" 和 "c" 两个分开的字符串常量。
        String s6 = "ab" + "c";
        System.out.println(s6 == s2);//true

        //在常量池创建的是“ab”和“c“，“abc”最后一步是拼接的，所以没有在常量池创建
        String s7_1 = "ab";
        String s7_2 = "c";
        String s7 = s7_1 + s7_2;
        System.out.println(s7 == s2);//false

        //toLowerCase和toUpperCase都会指向堆的对象
        String s2_2="ABC";
        String s8_1="abc".toLowerCase();
        String s8_2="abc".toUpperCase();
        isInConstantPool("s8_2",s8_2);
        String s8_3="ABc".toLowerCase();
        isInConstantPool("s8_3",s8_3);
        System.out.println(s8_1 == s2);//true 因为本来就是小写，返回原字符串
        System.out.println(s8_2 == s2_2);//false
        System.out.println(s8_3 == s2_2);//false
        //todo 待研究 String s8_3="ABc".toLowerCase(); 在常量池中创建了什么，是“ABc”还是“abc”

        //substring也会新建一个对象在堆中，不会指向常量池
        String s9 = "abc".substring(0, 2);
        isInConstantPool("s9",s9);
        System.out.println(s9 == "ab");//false
        //todo substring得到的对象如果常量池中没有，会不会在常量池中创建

    }
    public static void isInConstantPool(String strName,String str) {
        // 获取字符串在常量池中的引用
        String internedString = str.intern();
        // 检查两个引用是否相等
        if (str == internedString)
            System.out.println(strName+ "在常量池中");
        else
            System.out.println(strName + "不在常量池中");
    }
}