String类型

String类的说明

1.String使用private finalchar value[ ]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容,String类型是不可变的(immutable).

2.String类有一个特殊的创建方法,就是使用" "双引号来创建.例如new String("i am")实际创建了2个String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,一个是编译期,一个是运行期!

3.java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接.

4.运行期调用String类的intern()方法可以向String Pool中动态添加对象.

String的创建方法一般有如下几种

1.直接使用""引号创建.

2.使用new String()创建.

3.使用new String("someString")创建以及其他的一些重载构造函数创建.

4.使用重载的字符串连接操作符+创建.

 

例1

[java] view plain copy print ?

1. /* 
2.     *"sss111"是编译期常量,编译时已经能确定它的值,在编译 
3.     * 好的class文件中它已经在String Pool中了,此语句会在 
4.     * StringPool中查找等于"sss111"的字符串(用equals(Object)方法确定), 
5.     * 如果存在就把引用返回,付值给s1.不存在就会创建一个"sss111"放在 
6.     * StringPool中,然后把引用返回,付值给s1. 
7.     * 
8.     */  
9.     String s1= "sss111";  
10.    
11.     //此语句同上  
12.     String s2= "sss111";  
13.    
14.     /* 
15.     * 由于String Pool只会维护一个值相同的String对象 
16.     * 上面2句得到的引用是String Pool中同一个对象,所以 
17.     * 他们引用相等 
18.     */  
19.    System.out.println(s1 == s2); //结果为true  

例2

[java] view plain copy print ?

1. /* 
2.    * 在java中,使用new关键字会创建一个新对象,在本例中,不管在 
3.    * StringPool中是否已经有值相同的对象,都会创建了一个新的 
4.    * String对象存储在heap中,然后把引用返回赋给s1. 
5.    * 本例中使用了String的public String(Stringoriginal)构造函数. 
6.    */  
7.    String s1= new String("sss111");  
8.     
9.    /* 
10.     * 此句会按照例1中所述在String Pool中查找 
11.     */  
12.    String s2= "sss111";  
13.     
14.    /* 
15.     * 由于s1是new出的新对象,存储在heap中,s2指向的对象 
16.     * 存储在String Pool中,他们肯定不是同一个对象,只是 
17.     * 存储的字符串值相同,所以返回false. 
18.     */  
19.   System.out.println(s1 == s2); //结果为false  

例3 String intern() 返回字符串对象的规范化表示形式。

[java] view plain copy print ?

1. String s1= new String("sss111");  
2.     /* 
3.     * 当调用intern方法时，如果String Pool中已经包含一个等于此String对象 
4.     * 的字符串(用 equals(Object)方法确定),则返回池中的字符串.否则,将此 
5.     * String对象添加到池中，并返回此String对象在String Pool中的引用.  
6.     */  
7.     s1 =s1.intern();  
8.      
9.     String s2= "sss111";  
10.      
11.     /* 
12.      * 由于执行了s1 = s1.intern(),会使s1指向String Pool中值为"sss111" 
13.      * 的字符串对象,s2也指向了同样的对象,所以结果为true 
14.      */  
15.    System.out.println(s1 == s2);  

例4

[java] view plain copy print ?

1. String s1= new String("111");  
2.     String s2= "sss111";  
3.      
4.     /* 
5.     * 由于进行连接的2个字符串都是常量,编译期就能确定连接后的值了, 
6.     * 编译器会进行优化直接把他们表示成"sss111"存储到String Pool中, 
7.     * 由于上边的s2="sss111"已经在String Pool中加入了"sss111", 
8.     * 此句会把s3指向和s2相同的对象,所以他们引用相同.此时仍然会创建出 
9.     *"sss"和"111"两个常量,存储到String Pool中. 
10.   
11.     */  
12.     String s3= "sss" + "111";  
13.      
14.     /* 
15.      * 由于s1是个变量,在编译期不能确定它的值是多少,所以 
16.      * 会在执行的时候创建一个新的String对象存储到heap中, 
17.      * 然后赋值给s4. 
18.      */  
19.     String s4= "sss" + s1;  
20.      
21.    System.out.println(s2 == s3); //true  
22.    System.out.println(s2 == s4); //false  
23.    System.out.println(s2 == s4.intern()); //true  

结果上面分析,总结如下:

1.单独使用" "引号创建的字符串都是常量,编译期就已经确定存储到String Pool中.

2.使用new String("")创建的对象会存储到heap中,是运行期新创建的.

3.使用只包含常量的字符串连接符如"aa" + "aa"创建的也是常量,编译期就能确定,已经确定存储到String Pool中.

4.使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中.

6.使用"aa"+ s1以及new String("aa" +s1)形式创建的对象,必须调用intern()方法才加入String Pool

几个经常考的面试题:

1.

String s1 = new String("s1") ;

String s2 = new String("s1") ;

上面创建了几个String对象?

答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.

2.

String s1 = "s1";

String s2 = s1;

s2 = "s2";

s1指向的对象中的字符串是什么?

答案: "s1"