java中String的用法

s2=s2.intern(); //把常量池中“kvill”的引用赋给s2
System.out.println( s0==s1); //所以这个为false
System.out.println( s0==s1.intern() ); //true
s1==s1.intern()为false说明原来的“kvill”仍然存在；
s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。
从以上就可以看出来，
String s0= “kvill”;
String s1=new String(”kvill”); 这两种赋值方法的区别。同样根据这里，可以推断出String的其他几个性质
Hale Waihona Puke 结果： false kvill kvill
true
在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。
结果为
true
false
说明虽然前后两个str1.concat(str2)的值一样，但是他们的存储单元都与str1不相同，自身也各不相同；
我们再看看StringBuffer 类
那么在运行下面的代码
StringBuffer str11 = new StringBuffer("mutou");
System.out.println( “**********” );
s1.intern(); //java查找常量池中是否有相同Unicode的字符串常量kvill，发现有，返回他的引用，但是并没有赋予给任何人，所以是s1仍然是对内存中kvill的引用
我们常说String对象是不可改变的，但是运行下面代码
public class TestString{
public static void main(String[] args){
String str = "Programming";
str = str + "S";
System.out.println("str = " + str);
StringBuffer str22=str11.append("asd");
StringBuffer str33=str11.append("ert");
System.out.println( str33.equals(str22));
System.out.println( str33==str22);
false
eg2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。
所以这两种创建字符串本质上是不一样的，补充一点，存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了
所以我们得出s0==s1==s2;
用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们在内存中有自己的地址空间。
看eg2：
String s0=”kvill”;
String s1=new String(”kvill”);
}
}
测试结果输出ProgrammingS str的字符串改变了，这是为什么呢？因为我们所说的String对象不可改变，指的是这个对象指向的存储单元中的字符串不可改变，可是str = str + "S";却改变了他的存储单元，所以他指的向的字符串相应的发生了改变。
运行下面代码：
String str1 = new String("mutou");
System.out.println( "1: "+s1);
t.setValue(s1);
System.out.println( "3: "+s1);
}
void setValue(String s)
{
s = "bbb ";
String s2=”kv” + new String(“ill”);
System.out.println( s0==s1 );
System.out.println( s0==s2 );
System.out.println( s1==s2 );
结果为：
false
false
关于equals()和==:
这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。
关于String是不可变的
这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”;
我们知道java中有8种基本数据类型，而String却不属于8种数据类型里面，String是一个类，用来定义字符串的类。
那么，首先讲讲怎么创建一个字符串
String str1=“我爱java”；
String str2=new String（“我爱java”）；
这两种创建方法不一样吗，当然不一样。
这说明什么，说明虽然str22和str33是不同的变量，但是他们指向的内存地址始终与str11相同，所以只要str11指向的内存地址发生什么改变，都会发生相应的改变。所以当我们改变str33的值时候，str11和str22的值也改变了，且都是一样的。
综上，String指向的内存单元可以发生改变，但是每一个内存单元的值是不会发生改变的，任何一个String对象相对这个内存中的字符串引用，都必须自己开辟一块内存，拷贝这个内存的值；StringBuffer始终指向一个固定的内存单元，并且所有引用这个内存单元的其他的StringBuffer对象，也是始终指向这个内存单元，这就是String和StringBuffer本质区别。
str33.append("LOVE ");
System.out.println(str11);
System.out.println(str22);
结果都是
true
true
mutouasdertLOVE
mutouasdertLOVE
true
最后再破除一个错误的理解：
有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：
我们首先了解简单的常量池的概念，常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。
看eg1：
String s0=”kvill”;
String s1=”kvill”;
String s2=”kv” + “ill”;
{
public static void main( String args[])
{
就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。
看例4：
String s1=new String("kvill");
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );
String str2 = new String("test");
System.out.println(str1.concat(str2).equals(str1.concat(str2)));
System.out.println(str1.concat(str2)==str1.concat(str2));
System.out.println( s0==s1 );
System.out.println( s0==s2 );
结果为：