深入理解Java：String类

在讲解String之前，我们先了解一下Java的内存结构。

JVM主要管理两种类型内存：堆内存和栈内存。

按照官方的说法：JVM具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配，触发的方式是使用关键字 new 。

虚拟机必须为每个被装载的类维护一个常量池，常量池就是该类所用到常量的一个有序集合，常量池在内存当中是以表的形式存在。

下面通过一些案例来说明，String常量池。

public static void main(String[] args) {
        /**
         * 情景一：字符串池 JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象; 并且可以被共享使用，因此它提高了效率。
         * 由于String类是final的，它的值一经创建就不可改变。
         * 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。
         */
        String s1 = "abc";
        // ↑ 在字符串池创建了1个对象
        String s2 = "abc";
        // ↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建1个对象
        System.out.println("s1 == s2 : " + (s1 == s2));
        // ↑ true 指向同一个对象，
        System.out.println("s1.equals(s2) : " + (s1.equals(s2)));
        // ↑ true 值相等
        // ↑------------------------------------------------------over
        
        /**
         * 情景二：关于new String("")
         *
         */
        String s3 = new String("abc");
        // ↑ 创建了两个对象，一个存放在字符串池中，一个存在与堆区中；
        // ↑ 还有一个对象引用s3存放在栈中
        String s4 = new String("abc");
        // ↑ 字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象
        System.out.println("s3 == s4 : " + (s3 == s4));
        // ↑false s3和s4栈区的地址不同，指向堆区的不同地址；
        System.out.println("s3.equals(s4) : " + (s3.equals(s4)));
        // ↑true s3和s4的值相同
        System.out.println("s1 == s3 : " + (s1 == s3));
        // ↑false 存放的地区多不同，一个栈区，一个堆区
        System.out.println("s1.equals(s3) : " + (s1.equals(s3)));
        // ↑true 值相同
        // ↑------------------------------------------------------over
        
        /**
         * 情景三： 由于常量的值在编译的时候就被确定(优化)了。 在这里，"ab"和"cd"都是常量，因此变量str3的值在编译时就可以确定。
         * 这行代码编译后的效果等同于： String str3 = "abcd";
         */
        String str1 = "ab" + "cd"; // 1个对象
        String str11 = "abcd";
        System.out.println("str1 = str11 : " + (str1 == str11));
        // ↑------------------------------------------------------over
        
        /**
         * 情景四： 局部变量str2,str3存储的是存储两个拘留字符串对象(intern字符串对象)的地址。
         *
         * 第三行代码原理(str4 = str2+str3)： 运行期JVM首先会在堆中创建一个StringBuilder类，
         * 同时用str2指向的拘留字符串对象完成初始化，然后调用append方法完成对str3所指向的拘留字符串的合并，
         * 接着调用StringBuilder的toString()方法在堆中创建一个String对象，
         * 最后将刚生成的String对象的堆地址存放在局部变量str4中。
         *
         * 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。str4与str5地址当然不一样了。
         *
         * 内存中实际上有五个字符串对象： 三个拘留字符串对象、一个String对象和一个StringBuilder对象。
         */
        String str2 = "ab"; // 1个对象
        String str3 = "cd"; // 1个对象
        String str4 = str2 + str3;
        String str5 = "abcd";
        System.out.println("str4 = str5 : " + (str4 == str5)); 
        // ↑false ------------------------------------------------------over
        
        /**
         * 情景五： JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。
         * 运行期的两个string相加，会产生新的对象的，存储在堆(heap)中
         */
        String str6 = "b";
        String str7 = "a" + str6;
        String str67 = "ab";
        System.out.println("str7 = str67 : " + (str7 == str67));
        // ↑false str6为变量，在运行期才会被解析。
        final String str8 = "b";
        String str9 = "a" + str8;
        String str89 = "ab";
        System.out.println("str9 = str89 : " + (str9 == str89));
        // ↑true str8为常量变量，编译期会被优化
        // ↑------------------------------------------------------over
    }

总结：


1.String类初始化后是不可变的(immutable)
这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”;就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvillans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原 因了，因为StringBuffer是可改变的。 


　　下面是一些String相关的常见问题： 


　　String中的final用法和理解 
　　final StringBuffer a = new StringBuffer("111"); 
　　final StringBuffer b = new StringBuffer("222"); 
　　a=b;//此句编译不通过  final StringBuffer a = new StringBuffer("111"); 
　　a.append("222");// 编译通过 


　　可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。 


2.代码中的字符串常量在编译的过程中收集并放在class文件的常量区中，如"123"、"123"+"456"等，含有变量的表达式不会收录，如"123"+a。

3.使用String不一定创建对象
在执行到双引号包含字符串的语句时，如String a = "123"，JVM会先到常量池里查找，如果有的话返回常量池里的这个实例的引用，否则的话创建一个新实例并置入常量池里。如果是 String a = "123" + b (假设b是"456")，前半部分"123"还是走常量池的路线，但是这个+操作符其实是转换成[SringBuffer].Appad()来实现的，所以最终a得到是一个新的实例引用，而且a的value存放的是一个新申请的字符数组内存空间的地址(存放着"123456")，而此时"123456"在常量池中是未必存在的。


要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象。

4.String.intern()
String对象的实例调用intern方法后，可以让JVM检查常量池，如果没有实例的value属性对应的字符串序列比如"123"(注意是检查字符串序列而不是检查实例本身)，就将本实例放入常量池，如果有当前实例的value属性对应的字符串序列"123"在常量池中存在，则返回常量池中"123"对应的实例的引用而不是当前实例的引用，即使当前实例的value也是"123"。

public native String intern();
存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的 intern()方法就是扩充常量池的 一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中 是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常 量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了。

public static void main(String[] args) {
        String s0 = "kvill"; 
        String s1 = new String("kvill"); 
        String s2 = new String("kvill"); 
        System.out.println( s0 == s1 ); //false
        System.out.println( "**********" ); 
        s1.intern(); //虽然执行了s1.intern(),但它的返回值没有赋给s1
        s2 = s2.intern(); //把常量池中"kvill"的引用赋给s2 
        System.out.println( s0 == s1); //flase
        System.out.println( s0 == s1.intern() ); //true//说明s1.intern()返回的是常量池中"kvill"的引用
        System.out.println( s0 == s2 ); //true
    }

5.StringBuffer与StringBuilder的区别，它们的应用场景是什么？
 
JDK的实现中StringBuffer与StringBuilder都继承自AbstractStringBuilder，对于多线程的安全与非安全看到StringBuffer中方法前面的一堆synchronized就大概了解了。
这里随便讲讲AbstractStringBuilder的实现原理：我们知道使用StringBuffer等无非就是为了提高java中字符串连接的效率，因为直接使用+进行字符串连接的话，jvm会创建多个String对象，因此造成一定的开销。AbstractStringBuilder中采用一个char数组来保存需要append的字符串，char数组有一个初始大小，当append的字符串长度超过当前char数组容量时，则对char数组进行动态扩展，也即重新申请一段更大的内存空间，然后将当前char数组拷贝到新的位置，因为重新分配内存并拷贝的开销比较大，所以每次重新申请内存空间都是采用申请大于当前需要的内存空间的方式，这里是2倍。
 
【
    StringBuffer 始于 JDK 1.0 
    StringBuilder 始于 JDK 1.5 


    从 JDK 1.5 开始，带有字符串变量的连接操作（+），JVM 内部采用的是 
    StringBuilder 来实现的，而之前这个操作是采用 StringBuffer 实现的。
】

总之，StringBuffer是线程安全的，但效率低。StringBuilder是线程不安全的，但效率高。多线程用StringBuffer，单线程用StringBuilder。

链接：String 十大常见问题