对String类的一些认识

可能以前一直对String类的一些认识不太够,所以感觉一直都不是很懂,最近看书,有了一些新的认识,所以记下来
在Java中,字符串是做为String类的实例出现的,其实字符串就是字符数组,
首先String对象有几个基本的方法,如

 

1. public class StringDemo {   
2.     public static void main(String[] args) {   
3.         String text = "hello";   
4.    
5.         System.out.println("字符串内容:" + text);   
6.         System.out.println("字符串长度:" + text.length());   
7.         System.out.println("等于hello?" +   
8.                                  text.equals("hello"));   
9.         System.out.println("转为大写:" +   
10.                                  text.toUpperCase());   
11.         System.out.println("转为小写:" +   
12.                                  text.toLowerCase());   
13.     }   
14. }   

这很好理解,就不多说了,
因为字符串的本质就是字符数组,这样也就具有了数组索引的性质,如

 

1. public class CharAtString {   
2.     public static void main(String[] args) {   
3.         String text = "One's left brain has nothing right.\n"   
4.                  + "One's right brain has nothing left.\n";   
5.    
6.         System.out.println("字符串内容: ");   
7.         for(int i = 0; i < text.length(); i++)   
8.             System.out.print(text.charAt(i));   
9.   
10.         System.out.println("\n第一个left: " +   
11.                               text.indexOf("left"));   
12.         System.out.println("最后一个left: " +   
13.                               text.lastIndexOf("left"));   
14.    
15.         char[] charArr = text.toCharArray();   
16.         System.out.println("\n字符Array内容:");   
17.         for(int i = 0; i < charArr.length; i++)   
18.             System.out.print(charArr[i]);   
19.     }   
20. }  

这也很好理解,略过,String对象里还有个endsWith()方法蛮有意思的

接着我想说的是,

字符串是不可变的
一个字符串对象一旦被配置,它的内容就是固定不可变的,如

 

1. String str = "Just";  
2. str = "Justin";  

上面的语句并没有改变一个字符串对象的内容,事实上在这个程序片段中会有两个字符串对象,一个是Just字符串对象, 一个是Justin字符串对象,两个是不同的字符串对象,
在Java中,使用"="将一个字符串对象指定给一个变量名称, 其意义为改变该名称所引用的对象,原来被引用的字符串对象若没有其它名称来引用它,就会在适当的时候被Java的"垃圾回收"机制回收.
在Java执行时会维护一个String Pool,对于一些可以共享的字符串对象,会先在String Pool中查找是否存在相同的String内容,如果有就直接返回,而不是直接创造一个新的String对象,以减少内存的耗用,
如果在程序中使用下面的方式来声明,则实际上是指向同一个字符串对象:

 

1. String str1 = "flyweight";  
2. String str2 = "flyweight";  
3. System.out.println(str1 == str2);  

其结果会

 

1. true  

注:   在Java中,如果==被使用于两个对象类型的变量,它是用于比较两个变量是否引用自同一对象.

在这还要提一上String的intern()方法,如

 

1. public class InternString {   
2.     public static void main(String[] args) {   
3.         String str1 = "fly";   
4.         String str2 = "weight";   
5.         String str3 = "flyweight";   
6.         String str4 = null;   
7.   
8.         str4 = str1 + str2;  
9.         System.out.println(str3 == str4);   
10.   
11.         str4 = (str1 + str2).intern();   
12.         System.out.println(str3 == str4);   
13.     }   
14. }  

其结果为

 

1. false  
2. true  

在Java中使用 + 串联字符串会产生一个新的字符串对象,所以在第一次比较str3 与 str4对象是否为同一个对象时,结果为false,

然, intern()方法会先检查String Pool中是否存在字符部分相同的字符串对象,如果有就返回,由于程序中之前已经声明flyweight字符串对象,intern()方法在String Pool中发现了它,所以直接返回,这时再比较,str3 与 str4 就指向同一个对象了,所以结果为true

另外提一点:

 

1. String str1 = new String("hello");  
2. String str2 = new String("hello");  
3. // System.out.println(str1 == str2);  
4. System.out.println(str1.equals(str2);  

如上,这才产生了两个不同的String对象,使用 == 在这是用来比较两个字符串对象是否指向同一对象的,要比较两个字符串对象内容是否相同要使用equals()方法

接下来我想说一下StringBuilder类的使用
这是在jdk5.0中新增的一个类,
一个String对象的长度是固定的,不能改变它的内容,或者是附加新的字符至String对象中,也许可以使用 + 来串联字符串以达到目的,但 + 会产生一个新的String对象, 如果程序对这种附加字符串的需求很频繁, 并不建议用 + 来串联,这时候,StringBuilder就派上用场了,不过在之前的版本中的StringBuffer也可以实现同样的操作.这样就可以让程序的效率大大提高,
现给出证明代码

 

1. public class AppendStringTest {  
2.     public static void main(String[] args) {  
3.         String text = "";  
4.   
5.         long beginTime = System.currentTimeMillis();  
6.         for(int i = 0; i < 10000; i++)  
7.             text = text + i;  
8.         long endTime = System.currentTimeMillis();  
9.         System.out.println("执行时间：" + (endTime - beginTime));  
10.   
11.         StringBuilder builder = new StringBuilder("");  
12.         beginTime = System.currentTimeMillis();  
13.         for(int i = 0; i < 10000; i++)  
14.             builder.append(String.valueOf(i));  
15.         endTime = System.currentTimeMillis();  
16.         System.out.println("执行时间：" + (endTime - beginTime));  
17.     }  
18. }  

其运行结果大概为:

 

1. 执行时间: 4641  
2. 执行时间: 16  

此差距是明显的,
说明一点的是,如果在单机非多线程的情况下使用StringBuilder会有较好的效率,因为StringBuilder没有处理同步问题
所以在多线程情况下就使用StringBuffer会好一些..

这就是我对String对象的一些认识,记下来而已..