<pre name="code" class="java"><span style="font-size:18px;">
public class Test {
	 public static void  main(String [] args) {   
		  String s0="java";
          String s1="java";
          String s2="ja" + "va";
          
          System.out.println( s0==s1 );
          System.out.println( s0==s2 );
	 }
}
</span>

<span style="font-size:18px;">
public class Test {
	 public static void  main(String [] args) {   
		    String s0="java";
		    String s1=new String("java");
		    String s2="ja" + new String("va");

		    System.out.println( s0==s1 );
		    System.out.println( s0==s2 );
		    System.out.println( s1==s2 );
	 }
}
</span>

结果为:

    false
    false
    false

三、String 与StringBuffer的区别

1. String:在String类中没有用来改变已有字符串中的某个字符的方法，由于不能改变一个java字符串中的某个单独字符，所以在JDK文档中称String类的对象是不可改变的。然而，不可改变的字符串具有一个很大的优点:编译器可以把字符串设为共享的。

2.StringBuffer:StringBuffer类属于一种辅助类，可预先分配指定长度的内存块建立一个字符串缓冲区。

这样使用StringBuffer类的append方法追加字符 比 String使用 + 操作符添加字符 到 一个已经存在的字符串后面有效率得多。

因为使用 + 操作符每一次将字符添加到一个字符串中去时，字符串对象都需要寻找一个新的内存空间来容纳更大的字符串，这无凝是一个非常消耗时间的操作。添加多个字符也就意味着要一次又一次的对字符串重新分配内存。使用StringBuffer类就避免了这个问题.

 3.String 字符串常量
  StringBuffer 字符串变量（线程安全）
 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象,

因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，

然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，

因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

 而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。

所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。

而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
 String S1 = “This is only a” + “ simple” + “ test”;

StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。

其实这是 JVM 的一个把戏，在 JVM 眼里，这个 String S1 = “This is only a” + “ simple” + “test”;

其实就是： String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。

但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，

譬如：String S2 = “This is only a”;

String S3 = “ simple”;

String S4 = “ test”;

String S1 = S2 +S3 + S4;

这时候 JVM 会规规矩矩的按照原来的方式去做。

<span style="font-size:18px;">
public class Test {  
    public static void stringReplace(String text) {  
        //把textString的地址copy给text 
    	//在这个类中相当于又新new出一个text的对象，新对象text指向java
        //text.replace('j', 'i');的结果是"iava"   
        text = text.replace('j', 'i');  
        //输出结果为新对象中的值iava
        System.out.println (text); 
    }  
  
    public static void bufferReplace(StringBuffer text) {  
        //textBuffer的地址copy给text  
        //然后沿着text指向的字符串(其实也就是textBuffer指向的对象)操作,添加一个"C"  
    	//与原对象操作的是同一块内存区域
        text = text.append("C");  
        //输出结果为是原来对象改变后的值javac
        System.out.println (text); 
    }  
  
    public static void main(String args[]) {  
        String textString = new String("java");  
        StringBuffer textBuffer = new StringBuffer("java");  
  
        stringReplace(textString);  
        bufferReplace(textBuffer);  
  
        System.out.println(textString + textBuffer);  
    }  
}
</span>

输出： 
iava