==和equals的区别

String本身是final类

字符串是不可变的对象

 

 

== 比较的是值

比较基本的数据类型，比较的是数值 ，基本数据类型就在栈

比较引用类型：比较引用指向的值（地址） ，

 

equals

默认比较也是地址，因为这个方法的最初定义在Object上，默认的实现就是比较地址

自定义的类，如果需要比较的是内容，那么就要学String，重写equals方法

 

 

 

public class EqualsTest {
    public static void main(String[] args) {
        String s1 = new String("zs");
        String s2 = new String("zs");
        System.out.println(s1 == s2);  //false
        String s3 = "zs";
        String s4 = "zs";
        System.out.println(s3 == s4); //true  常量池
        System.out.println(s3 == s1);  //false 一个指向常量地址，一个指向堆的地址
        String s5 = "zszs";
        String s6 = s3+s4;
        System.out.println(s5 == s6);  //false  s3+s4,会通过StringBulid生成新的对象
        final String s7 = "zs";
        final String s8 = "zs";
        String s9 = s7+s8;
        System.out.println(s5 == s9);  //true  s7,s8前面有final修饰，说明是常量，没有final修饰时才是变量编译量在处理常量相+时，
                                        // 会进行优化，S7+S8双成了常量，与s5一样，所以是true
        final String s10 = s3+s4;
        System.out.println(s5 == s10);  //false s3+s4,会通过StringBulid生成新的对象， 这里final有点迷惑人，它只对s10有影响，说明只让s10赋值一次

        System.out.println(s1.equals(s2)); //true
    }
}

 

 

 

String类对象两种实例化方式的区别

String类对象存在两种实例化的操作形式，那么这两种有什么区别，在开发之中应该使用那一种更好呢？

1、直接赋值的实例化方式：

  String str = "Hello" ;
1
此时，只分配了一块堆内存空间和一块栈内存空间： 

再看一下代码：

public class StringDemo {
         public static void main(String args[]) {
                   String str1 = "Hello" ;
                   String str2 = "Hello" ;
                   String str3 = "Hello" ;
                   System.out.println(str1 == str2) ;
                   System.out.println(str1 == str3) ;
                   System.out.println(str2 == str3) ;
         }
}
 
运行结果：

true
true
true
 
我们发现以上所有直接赋值的String类对象的内存地址完全相同，内存分配图如下：

在设计String类的时候采用了一种称为共享设计模式的概念。在运行的JVM底层存在一个字符串的对象池（Object Pool），如果用户采用了直接赋值的方式时，会将字符串的内容放入池保存，如果以后其他String对象继续使用直接赋值方式实例化，并且设置了同样的内容时，那么将不会分配新的堆内存空间，而是使用已有对象的引用进行分配继续使用。如果新声明的字符串内容不在对象池中，则会分配一个新的，然后继续放到池中以供下次使用。

2、采用构造方法实例化的方式：

使用构造方法实例化一定要用到new关键字，而一旦使用了new就表示要分配新的内存空间。

 String str = new String("Hello") ;
 
内存分配图如下：

从上可以发现，分配了两块堆内存空间，其中一块是垃圾。这样处理内存的浪费外，使用构造方法定义的String类对象，其内容不会保存在对象中（因为重新分配了新的一块堆内存）。

现在希望使用构造方法定义的String类对象，其内容要保存在对象中，该怎么办么？我们可以使用String类定义的一个手工入池的方法：

public String intern()

 

对于通过new产生一个字符串（假设为”Hello”）时，会先去常量池中查找是否已经有了”china”对象，如 果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。这也就是有道面试题：String str = new String(“Hello”);产生几个对象？一个或两个，如果常量池中原来没有”Hello”,就是两个。

 

jdk8后，常量放到了无空间，也就是内存，不在JVM 堆 。
 
范例如下：

public class StringDemo {
         public static void main(String args[]) {
                   String str1 = new String("Hello").intern() ;   //intern就是取常量池
                   String str2 = "Hello" ;  // 入池 
                   String str3 = "Hello" ;  // 使用池对象

                   System.out.println(str1 == str2) ;
                   System.out.println(str1 == str3) ;
                   System.out.println(str2 == str3) ;
         }
}
 
运行结果：

true
true
true
 
小结：String类对象两种实例化的区别？ 
（1）直接赋值实例化方式（String str = “xxx”）：只会分配一块堆内存空间，并且对象内容自动入池，以供重复使用； 
（2）构造方法实例化方式（String str = new String(“xxx”)）：会分配两块堆内存空间，其中有一块是垃圾，并且不会自动入池，用户可以使用intern()方法手动入池。
 

 

字符串的内容一旦定义则不可改变

先看一段代码：

public class StringDemo {
         public static void main(String args[]) {
                   String str = "Hello " ;
                   str += "World " ;
                   str = str + "!!!" ;
                   System.out.println(str) ;
         }
}
 
运行结果：

Hello World !!!
1
我们通过内存分配图分析一下：

通过以上的分析可以发现：字符串内容的更改，实际上改变的是字符串对象的引用过程，并且会伴随有大量的垃圾出现，在实际开发中应该避免。