String 类

[b]对象的创建：[/b]


[code]String str1 = new String("abc");
Stirng str2 = "abc"; [/code]

说明：String是一个非可变类（immutable）,实例是不能被修改的，每个实例中包含的信息都必须在该实例创建的时候就提供出来，并且在对象的整个生存周期内固定不变，存在String类型字面值常量表。

[b]常用api及某些源码[/b]

String string = new String();
		byte [] b= string.getBytes();
		char [] charArray = string.toCharArray();
		String [] str = string.split("|");
		int srcBegin = 0; 
                  int srcEnd = 0; 
                  char dst[] = null; 
                  int dstBegin = 0;
		string.getChars(srcBegin, srcEnd, dst, dstBegin);
		String s = string.trim();
		String subString = string.substring(0);
		int i = string.indexOf("");
		int len = string.length();
		boolean flag = string.equals("abc");
		boolean flag0 = string.isEmpty();

public static String valueOf(Object obj) {
	return (obj == null) ? "null" : obj.toString();
    }
public static String valueOf(boolean b) {
	return b ? "true" : "false";
    }
public static String valueOf(char c) {
	char data[] = {c};
	return new String(0, 1, data);
    }
 public static String valueOf(int i) {
        return Integer.toString(i, 10);
    }
public static String valueOf(long l) {
        return Long.toString(l, 10);
    }
public static String valueOf(float f) {
	return Float.toString(f);
    }
public static String valueOf(double d) {
	return Double.toString(d);
    }
 public static String valueOf(char data[]) {
	return new String(data);
    }

[quote][url] [b][size=large]http://dustin.iteye.com[/size][/b][/url]
对于第一种，jvm会马上在heap中创建一个String对象，然后将该对象的引用返回给用户。对于第二种，jvm首先会在内部维护的strings pool中通过String的 equels 方法查找是对象池中是否存放有该String对象，如果有，则返回已有的String对象给用户，而不会在heap中重新创建一个新的String对象；如果对象池中没有该String对象，jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings pool中。注意：使用第一种方法创建对象时，jvm是不会主动把该对象放到strings pool里面的，除非程序调用 String的intern方法。

[code]String str1 = new String("abc"); //jvm 在堆上创建一个String对象，jvm 在strings pool中找不到值为“abc”的字符串，因此
//在堆上创建一个String对象，并将该对象的引用加入至strings pool中，此时堆上有两个String对象
Stirng str2 = "abc";
if(str1 == str2){
System.out.println("str1 == str2");
}else{
System.out.println("str1 != str2");
} //打印结果是 str1 != str2,因为它们是堆上两个不同的对象
String str3 = "abc";
//此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equels “abc”
//因此直接返回str2指向的对象给str3，也就是说str2和str3是指向同一个对象的引用
if(str2 == str3){
System.out.println("str2 == str3");
}else{
System.out.println("str2 != str3");
} //打印结果为 str2 == str3

String str1 = new String("abc"); //jvm 在堆上创建一个String对象

str1 = str1.intern();
//程序显式将str1放到strings pool中，intern运行过程是这样的：首先查看strings pool
//有没“abc”对象的引用，没有，则在堆中新建一个对象，然后将新对象的引用加入至
//strings pool中。执行完该语句后，str1原来指向的String对象已经成为垃圾对象了，随时会被GC收集。

//此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equels “abc”
//因此直接返回str1指向的对象给str2，也就是说str2和str1引用着同一个对象，
//此时，堆上的有效对象只有一个。
Stirng str2 = "abc";
if(str1 == str2){
System.out.println("str1 == str2");
}else{
System.out.println("str1 != str2");
} //打印结果是 str1 == str2

String hello = "Hello", lo = "lo";
System.out.print((hello == "Hello") + " "); //true
System.out.print((hello == ("Hel"+"lo")) + " "); //true
System.out.print((hello == ("Hel"+lo)) + " "); //false--lo为非literal的
System.out.println(hello == ("Hel"+lo).intern());//true

String AA = new String("AA");
System.out.println(AA == "AA");// false
System.out.println(AA == AA.intern());// false
System.out.println("AA" == AA.intern());// true

[/code]
[b]串接（Concatenation）[/b]
java程序员应该都知道滥用String的串接操作符是会影响程序的性能的。性能问题从何而来呢？归根结底就是String类的非可变性。既然String对象都是非可变的，也就是对象一旦创建了就不能够改变其内在状态了，但是串接操作明显是要增长字符串的，也就是要改变String的内部状态，两者出现了矛盾。怎么办呢？要维护String的非可变性，只好在串接完成后新建一个String 对象来表示新产生的字符串了。也就是说，每一次执行串接操作都会导致新对象的产生，如果串接操作执行很频繁，就会导致大量对象的创建，性能问题也就随之而来了。
为了解决这个问题，jdk为String类提供了一个可变的配套类，StringBuffer。使用StringBuffer对象，由于该类是可变的，串接时仅仅时改变了内部数据结构，而不会创建新的对象，因此性能上有很大的提高。针对单线程，jdk 5.0还提供了StringBuilder类，在单线程环境下，由于不用考虑同步问题，使用该类使性能得到进一步的提高。
[b] String的长度[/b]
我们可以使用串接操作符得到一个长度更长的字符串，那么，String对象最多能容纳多少字符呢？查看String的源代码我们可以得知类String中是使用域 count 来记录对象字符的数量，而count 的类型为 int，因此，我们可以推测最长的长度为 2^32，也就是4G。
不过，我们在编写源代码的时候，如果使用 Sting str = "aaaa";的形式定义一个字符串，那么双引号里面的ASCII字符最多只能有 65534 个。为什么呢？因为在class文件的规范中， CONSTANT_Utf8_info表中使用一个16位的无符号整数来记录字符串的长度的，最多能表示 65536个字节，而java class 文件是使用一种变体UTF-8格式来存放字符的，null值使用两个字节来表示，因此只剩下 65536－ 2 ＝ 65534个字节。也正是变体UTF-8的原因，如果字符串中含有中文等非ASCII字符，那么双引号中字符的数量会更少（一个中文字符占用三个字节）。如果超出这个数量，在编译的时候编译器会报错。
[url] [b][size=x-large]http://hxraid.iteye.com[/size][/b][/url]
[color=red]String 不可变字符序列
StringBuffer 线程安全的可变字符序列
StringBuilder 非线程安全的可变字符序列 [/color]

public final class String   
{   
        private final char value[];   

         public String(String original) {   
              // 把原字符串original切分成字符数组并赋给value[];   
         }   
}   

//StringBuffer    
public final class StringBuffer extends AbstractStringBuilder   
{   
         char value[]; //继承了父类AbstractStringBuilder中的value[]   
         public StringBuffer(String str) {   
                 super(str.length() + 16); //继承父类的构造器，并创建一个大小为str.length()+16的value[]数组   
                 append(str); //将str切分成字符序列并加入到value[]中   
        }   
}  

很显然，String和StringBuffer中的value[]都用于存储字符序列。但是,
(1) String中的是常量(final)数组，只能被赋值一次。
比如：new String("abc")使得value[]={'a','b','c'}，之后这个String对象中的value[]再也不能改变了。这也正是大家常说的，String是不可变的原因 。
注意：这个对初学者来说有个误区，有人说String str1=new String("abc"); str1=new String("cba");不是改变了字符串str1吗？那么你有必要先搞懂对象引用和对象本身的区别。
(2) StringBuffer中的value[]就是一个很普通的数组，而且可以通过append()方法将新字符串加入value[]末尾。这样也就改变了value[]的内容和大小了。
比如：new StringBuffer("abc")使得value[]={'a','b','c','',''...}(注意构造的长度是str.length()+16)。如果再将这个对象append("abc")，那么这个对象中的value[]={'a','b','c','a','b','c',''....}。这也就是为什么大家说 StringBuffer是可变字符串 的涵义了。
从这一点也可以看出，StringBuffer中的value[]完全可以作为字符串的缓冲区功能。
[color=red] String s1=new String("aaa");
StringBuffer sb1=new StringBuffer(); //一个字符串缓冲区
sb1.append(s1);//将字符串s1加进缓冲区[/color] 注意，讨论String和StringBuffer可不可变。本质指对象内部的value[]字符数组可不可变，而不是对象引用可不可变。

[color=brown]StringBuffer与StringBuilder的线程安全性问题 [/color]
StringBuffer和StringBuilder可以算是双胞胎了，这两者的方法没有很大区别。但在线程安全性方面，StringBuffer允许多线程进行字符操作。这是因为在源代码中StringBuffer的很多方法都被关键字synchronized 修饰了，而StringBuilder没有。
有多线程编程经验的程序员应该知道synchronized。这个关键字是为线程同步机制 设定的。我简要阐述一下synchronized的含义：
每一个类对象都对应一把锁，当某个线程A调用类对象O中的synchronized方法M时，必须获得对象O的锁才能够执行M方法，否则线程A阻塞。一旦线程A开始执行M方法，将独占对象O的锁。使得其它需要调用O对象的M方法的线程阻塞。只有线程A执行完毕，释放锁后。那些阻塞线程才有机会重新调用M方法。这就是解决线程同步问题的锁机制。
了解了synchronized的含义以后，大家可能都会有这个感觉。多线程编程中StringBuffered比StringBuilder要安全多了 ，事实确实如此。如果有多个线程需要对同一个字符串缓冲区进行操作的时候，StringBuffer应该是不二选择。
注意：是不是String也不安全呢？事实上不存在这个问题，String是字符串常量，不可变。线程对于String对象只能读取，无法修改。
String和StringBuffer的效率问题（这可是个热门话题呀!）
首先说明一点：StringBuffer和StringBuilder可谓双胞胎，StringBuilder是1.5新引入的，其前身就是StringBuffer。在Core Java editior 7 中文版P611页中有这么一句话： StringBuffer比StringBuilder的效率稍低 。
我们用下面的代码运行1W次字符串的连接操作，测试String,StringBuffer所运行的时间。

//测试代码
public class RunTime{
    public static void main(String[] args){
           //位置1
          long beginTime=System.currentTimeMillis();
          for(int i=0;i<10000;i++){
                //位置2
          }
          long endTime=System.currentTimeMillis();
          System.out.println(endTime-beginTime);   
    }
}   

(1) String常量与String变量的"+"操作比较
首先声明两个概念：String str="Heart"中"Heart"是String常量(存放在常量池中)；而str则是String变量,是String对象的引用。
▲测试①代码： (测试代码位置1) String str="";
(测试代码位置2) str="Heart"+"Raid";
[耗时： 0ms]

▲测试②代码 (测试代码位置1) String s1="Heart";
String s2="Raid";
String str="";
(测试代码位置2) str=s1+s2;
[耗时： 15—16ms]
结论：String常量的“+连接” 稍优于 String变量的“+连接”。
原因：测试①的"Heart"+"Raid"在编译阶段就已经连接起来，并形成了一个新的字符串常量"HeartRaid"。运行阶段只需要将"HeartRaid"存入常量池。循环1W次也只不过将常量池中"HeartRaid"的地址取出1W次赋值给String对象的引用而已。
测试②在编译阶段，编译器并不知道s1和s2代表什么，它会将这句话编译成几个指令，大体上是这样的。
首先：StringBuilder temp=new StringBuilder(s1)，
然后：temp.append(s2)
最后：str=temp.toString();
我们发现，虽然在中间的时候也用到了append()方法，但是在开始和结束的时候分别创建了StringBuilder和String对象。可想而知：调用1W次，是不是就创建了1W次这两中对象呢？不划算。
不言而喻：String变量的"+"连接操作比String常量操作使用的更加广泛。
(2)String对象的"累+"连接操作与StringBuffer对象的append()累和连接操作比较。
▲测试①代码： (代码位置1) String s1="Heart";
String s="";
(代码位置2) s=s+s1;
[耗时： 4200—4500ms]

▲测试②代码 (代码位置1) String s1="Heart";
StringBuffer sb=new StringBuffer();
(代码位置2) sb.append(s1);
[耗时： 0ms(当循环100000次的时候，耗时大概16—31ms)]
结论：StringBuffer的append()累和连接 远好于 String对象的"累+"连接
原因：测试①中s=s+s1我们知道编译器也会使用StringBuilder的append方法，但是首先编译器会将new StringBuilder存放s，然后在通过 StringBuilder.append(s1)，最后在new一个新的String对象存放 StringBuilder的连接后的内容 。试想这个过程一次就需要创建一个新的String并赋值给引用s，10000次就需要创建了1W次新String对象。正式因为String中的value[]数组不可变，只能不停的创建新的String来存放变化中的字符串。效率可想而知了。
测试②中sb.append(s1);只需要将自己的value[]数组不停的扩大来存放s1即可。无需在堆中创建一大堆的对象。效率高就不足为奇了。
镜头总结： (1) 在编译阶段就能够确定的字符串常量，完全没有必要创建String或StringBuffer对象。直接使用字符串常量的"+"连接操作效率最高。
(2)否则，StringBuffer对象的append效率要高于String对象的"+"连接操作。
(3) intern()方法很有用。
当调用String 对象的intern方法时，如果池已经包含一个等于此对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。
也就是如果我们需要使用new关键字来创建很多内容重复的字符串的话，使用String.intern()方法可以提高效率。

[/quote]