String对象之间的比较

public class StringTest {
    
    @Test
    public void test01() {
        int a = 50; // 基本数据类型比较的是值
        int b = 50;
        System.out.println(a == b);
    }

    @Test
    public void test02() {
        /**
         * 01.首先在栈中开辟一个空间给a
         * 02.去常量池中查询有没有“123”，如果没有创建一个  
         * 03.a指向常量池中“123”
         */
        String a = "123";
        /**
         * 01.首先在栈中开辟一个空间给b
         * 02.去常量池中查询有没有“123”，发现有！
         * 03.b直接指向常量池中“123”
         */
        String b = "123";
        System.out.println(a == b);
    }

    @Test
    public void test03() {
        String a = "123";
        /**
         * 01.首先在栈中开辟一个空间给b
         * 02.去常量池中查询有没有“123”，发现有！
         * 03.不会在常量池中创建“123”，但是会在堆中创建“123”
         * 04.只要是new,b就会指向堆中“123” 
         */
        String b = new String("123");
        System.out.println(a == b);
    }

    @Test
    public void test04() {
        String a = "1" + "2"; // 在编译期间a="12"
        String b = "12";
        System.out.println(a == b); // true
    }

    @Test
    public void test05() {
        // a 和 b都是一个变量！！！ 运行期间可以改变！
        String a = "1";
        String b = "2";
        String c = a + b; // 在编译期间 a 和 b的值 不确定！
        String d = "12";
        System.out.println(c == d); // false
    }

    @Test
    public void test06() {
        // a 和 b都是一个常量！！！ 运行期间不可以改变！
        final String a = "1";
        final String b = "2";
        String c = a + b; // 在编译期间 a 和 b的值 不确定！
        String d = "12";
        System.out.println(c == d); // true
    }

 

public class StringTest {
    /*
     * equals  和   ==的区别
     * 如果类中没有重写equals（）,那么默认比较也是内存地址
     * ==在基本数据类型中比较的是值！
     * int a =10;
     * int b=10;
     * syso(a==b);  true
     *   在引用数据类型中比较的是地址！
     *   
     * 为什么说 基本数据类型 ，对象和数组的引用 都存在栈中？？
     * 因为栈最大的优势：  存取的速度快！
     *   
     * Student  stu=new  Student();
     *            stu:  对象的引用       栈中
     * new  Student()：       对象              堆
     * new出来的数据都是存放在堆中！
     */
    
    @Test
    public  void  test01(){
        String a ="abc";
        String b =new String("abc");
        System.out.println(a==b);  //false
        /*
         * 01.首先会在栈中开辟一块空间给a
         * 02.去常量池中查询有没有"abc"
         * 03.因为没有"abc"，所以在常量池中开辟一块空间给"abc"
         * 04.栈中的a 指向了 常量池中 "abc"
         * 05.会在栈中开辟一块空间给b
         * 06.去常量池中查询有没有"abc",发现有了，就不会在常量池中创建
         * 07.去堆中开辟一块空间存放"abc"
         * 08.栈中的b 指向了 堆中 "abc"
         * 09. 地址不一样  所以结果 false
         */
    }
    
    
    @Test
    public  void  test02(){
        String a ="abc";
        String b ="abc";
        System.out.println(a=="abc");//true
        System.out.println(a==b);   //true
    }
    
    @Test
    public  void  test03(){
        String a ="abc";
        String b ="a"+"bc";
        System.out.println(a==b);   //true
    }
    
    @Test
    public  void  test04(){
        String a ="abc";
        String b ="a";
        String c ="bc"; 
        System.out.println(a==(b+c));   //false
        /*
         * 01.a的值是"abc"
         * 02.编译期间  b ="a"   c ="bc" 这个值 随时都可能改变！！
         * 03.在编译期间(b+c)不会被优化成“abc”   就是因为值不确定
         */
    }
    @Test
    public  void  test05(){
        String a ="abc";
        final String b ="a";
        final String c ="bc"; 
        System.out.println(a==(b+c));   //true
        /*
         * 01.a的值是"abc"
         * 02.编译期间  b ="a"   c ="bc" 这个值不可能改变！！
         * 03.在编译期间(b+c)被优化成“abc”   就是因为值确定 final修饰的不可变
         */
    }
    
    @Test
    public  void  test06(){
        String a =new String("abc");  //创建了几个对象？
    }
}

 参数传递

public class StringTest {    
 public static void main(String[] args) {
        /*String  str=new String("abc");
        getString(str);
        System.out.println(str);  //String在作为参数传递时  传递的是值    abc*/     
     
         StringBuffer buffer=new StringBuffer("abc");
         getString(buffer);  //传递的是地址
         System.out.println(buffer);  //abchaha
    }

     //方法重载
    private static void getString(String str) {
        str=str+"haha";
    }
    
    private static void getString(StringBuffer str) {
        str=str.append("haha");
    }
}