【深入Java字符串】（2）Java String案例分析

浅浅的花香味﹌ 2022-07-13 04:50 157阅读 0赞

# #

public static void main(String[] args) {  
            /** 
             * 情景一：字符串池 
             * JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象; 
             * 并且可以被共享使用，因此它提高了效率。 
             * 由于String类是final的，它的值一经创建就不可改变。 
             * 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。  
             */  
            String s1 = "abc";     
            //↑ 在字符串池创建了一个对象  
            String s2 = "abc";     
            //↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建一个对象  
            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));  true
            //↑------------------------------------------------------over  
            /** 
             * 情景四：  
             * 局部变量str2,str3存储的是存储两个拘留字符串对象(intern字符串对象)的地址。 
             *  
             * 第三行代码原理(str2+str3)： 
             * 运行期JVM首先会在堆中创建一个StringBuilder类， 
             * 同时用str2指向的拘留字符串对象完成初始化， 
             * 然后调用append方法完成对str3所指向的拘留字符串的合并， 
             * 接着调用StringBuilder的toString()方法在堆中创建一个String对象， 
             * 最后将刚生成的String对象的堆地址存放在局部变量str3中。 
             *  
             * 而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));  
            //↑str6为变量，在运行期才会被解析。  
            final String str8 = "b";  
            String str9 = "a" + str8;  
            String str89 = "ab";  
            System.out.println("str9 = str89 : "+ (str9 == str89));  
            //↑str8为常量变量，编译期会被优化  
            //↑------------------------------------------------------over  
        }

看这个例子，用JDK5+junit4.5写的例子，完全通过测试

import static org.junit.Assert.assertNotSame;
    import static org.junit.Assert.assertSame;
    
    import org.junit.Test;
    
    /**
     * @author Heis
     *
     */
    public class StringTest{
    
        @Test
        public void testTheSameReference1(){
            String str1="abc";
            String str2="abc";
            String str3="ab"+"c";
            String str4=new String(str2);
            
            //str1和str2引用自常量池里的同一个string对象
            assertSame(str1,str2);
            //str3通过编译优化，与str1引用自同一个对象
            assertSame(str1,str3);
            //str4因为是在堆中重新分配的另一个对象，所以它的引用与str1不同
            assertNotSame(str1,str4);
        }
        
    }

*  第一个断言很好理解，因为在编译的时候，"abc"被存储在常量池中，str1和str2的引用都是指向常量池中的"abc"。**所以str1和str2引用是相同的。**
 *  第二个断言是由于编译器做了优化，编译器会先把字符串拼接，再在常量池中查找这个字符串是否存在，如果存在，则让变量直接引用该字符串。**所以str1和str3引用也是相同的。**
 *  str4的对象不是显式赋值的，编译器会在堆中重新分配一个区域来存储它的对象数据。**所以str1和str4的引用是不一样的。**

![Center][]

总结：

## 1.String类初始化后是不可变的(immutable) ##

这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了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.JVM在加载类的时候，根据常量区中的字符串生成常量池，每个字符序列如"123"会生成一个实例放在常量池里，这个实例是不在堆里的，也不会被GC，这个实例的value属性从源码的构造函数看应该是用new创建数组置入123的，所以按我的理解此时value存放的字符数组地址是在堆里，如果有误的话欢迎大家指正。

## 2.使用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()方法才能保证每次都创建一个新的对象

## 3.使用new String，一定创建对象 ##

在执行String a = new String("123")的时候，首先走常量池的路线取到一个实例的引用，然后在堆上创建一个新的String实例，走以下构造函数给value属性赋值，然后把实例引用赋值给a：

![复制代码][copycode.gif]

public String(String original) {
        int size = original.count;
        char[] originalValue = original.value;
        char[] v;
          if (originalValue.length > size) {
             // The array representing the String is bigger than the new
             // String itself.  Perhaps this constructor is being called
             // in order to trim the baggage, so make a copy of the array.
                int off = original.offset;
                v = Arrays.copyOfRange(originalValue, off, off+size);
         } else {
             // The array representing the String is the same
             // size as the String, so no point in making a copy.
            v = originalValue;
         }
        this.offset = 0;
        this.count = size;
        this.value = v;
        }

![复制代码][copycode.gif]

从中我们可以看到，虽然是新创建了一个String的实例，但是value是等于常量池中的实例的value，即是说没有new一个新的字符数组来存放"123"。

如果是String a = new String("123"+b)的情况，首先看回第4点，"123"+b得到一个实例后，再按上面的构造函数执行。

## 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的字符串并返回它的引用；看示例就清楚了

![复制代码][copycode.gif]

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
        }

![复制代码][copycode.gif]

最后我再破除一个错误的理解：有人说，“使用 String.intern() 方法则可以将一个 String 类的保存到一个全局 String 表中 ，如果具有相同值的 Unicode 字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果我把他说的这个全局的 String 表理解为常量池的话，他的最后一句话，”如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

![复制代码][copycode.gif]

public static void main(String[] args) {        
            String s1 = new String("kvill"); 
            String s2 = s1.intern(); 
            System.out.println( s1 == s1.intern() ); //false
            System.out.println( s1 + " " + s2 ); //kvill kvill
            System.out.println( s2 == s1.intern() ); //true
        }

![复制代码][copycode.gif]

在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一 个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。   
  
　　s1==s1.intern() 为false说明原来的”kvill”仍然存在；s2现在为常量池中”kvill”的地址，所以有s2==s1.intern()为true。

> ## 欢迎关注公众号： ##
> 
> # ![70][] #

[Center]: /images/20220713/c96c2b44736a4ac189d4fc0a1f973404.png
[copycode.gif]: /images/20220713/6dbc39d02a4647c294f840f8e00ab5c5.png
[70]: /images/20220713/82e95bef563c4b2baaaf7318fc0d0566.png