String s="xyz" 与 String s=new String("xyz")

不知道以下说的对不对，先整理一下看看
转贴自 http://hi.baidu.com/piao_live/blog/item/c1edb1fb0605ef136c22ebe2.html

要理解这个，就要知道string类的工作原理。
你知道在java中除了8中基本类型外，其他的都是类对象以及其引用。所以 "xyz "在java中它是一个String对象.对于string类对象来说他的对象值是不能修改的，也就是具有不变性。
看：
String s= "Hello ";
s= "Java ";
String s1= "Hello ";
String s2=new String( "Hello ");
啊，s所引用的string对象不是被修改了吗？之前所说的不变性，去那里了啊？
你别着急，让我告诉你说发生了什么事情：
在jvm的工作过程中，会创建一片的内存空间专门存入string对象。我们把这片内存空间叫做string池。
String s= "Hello ";当jvm看到 "Hello "，在string池创建string对象存储它，并将他的引用返回给s。
s= "Java "，当jvm看到 "Java "，在string池创建新的string对象存储它，再把新建的string对象的引用返回给s。而原先的 "Hello "仍然在string池内。没有消失，他是不能被修改的。
所以我们仅仅是改变了s的引用，而没有改变他所引用的对象，因为string对象的值是不能被修改的。
String s1= "Hello ";jvm首先在string池内里面看找不找到字符串 "Hello ",找到,返回他的引用给s1，否则,创建新的string对象，放到string池里。这里由于s= "Hello "了,对象已经被引用，所以依据规则s和s1都是引用同一个对象。所以 s==s1将返回true。(==,对于非基本类型，是比较两引用是否引用内存中的同一个对象)
String s2=String( "Hello ");jvm首先在string池内里面看找不找到字符串 "Hello ",找到,不做任何事情，否则,创建新的string对象，放到string池里面。由于遇到了new，还会在内存上（不是string池里面）创建 string对象存储 "Hello "，并将内存上的（不是string池内的）string对象返回给s2。所以s==s2将返回false，不是引用同一个对象。
好现在我们看题目：
String s = new String( "xyz ");
首先在string池内找，找到？不创建string对象，否则创建， 这样就一个string对象
遇到new运算符号了，在内存上创建string对象（此处内存用堆来理解，比较好，应该是从字符串池中复制一份相同的对象放到堆中，要是理解不对，请多多指教！！），并将其返回给s，又一个对象
所以总共是2个对象 －－－一个是string池中的对象，一个是堆中的对象，并把堆中的对象交给S持有

##################################################################################

转贴自 http://wyz191.javaeye.com/blog/139171

1、"abc"与new String("abc");
    经常会问到的面试题：String s = new String("abc");创建了几个String Object?【如这里创建了多少对象? 和一道小小的面试题 】

    这个问题比较简单，涉及的知识点包括：

引用变量与对象的区别； 
字符串文字"abc"是一个String对象； 
文字池[pool of literal strings]和堆[heap]中的字符串对象。
    一、 引用变量与对象：除了一些早期的Java书籍和现在的垃圾书籍，人们都可以从中比较清楚地学习到两者的区别。A aa;语句声明一个类A的引用变量 aa[我常常称之为句柄]，而对象一般通过new创建。所以题目中s仅仅是一个引用变量，它不是对象。[ref 句柄、引用与对象]

    二、Java中所有的字符串文字[字符串常量]都是一个String的对象。有人[特别是C程序员]在一些场合喜欢把字符串"当作/看成"字符数组，这也没有办法，因为字符串与字符数组存在一些内在的联系。事实上，它与字符数组是两种完全不同的对象。

        System.out.println("Hello".length());
        char[] cc={'H','i'};
        System.out.println(cc.length);

    三、 字符串对象的创建:由于字符串对象的大量使用[它是一个对象，一般而言对象总是在heap分配内存]，Java中为了节省内存空间和运行时间[如比较字符 串时，==比equals()快]，在编译阶段就把所有的字符串文字放到一个文字池[pool of literal strings]中，而运行时文字 池成为常量池的一部分。文字池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。我们知道，对两个引用变量，使用==判断它们的值[引用] 是否相等，即指向同一个对象：

String s1 = "abc" ;
String s2 = "abc" ;
if( s1 == s2 )
     System.out.println("s1,s2 refer to the same object");
else
     System.out.println("trouble");

    这里的输出显示，两个字符串文字保存为一个对象。就是说，上面的代码只在pool中创建了一个String对象。

    现 在看String s = new String("abc");语句，这里"abc"本身就是pool中的一个对象，而在运行时执行 new String()时，将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。ok，这条语句就创建了2个 String对象。

String s1 = new String("abc") ;String s2 = new String("abc") ;if( s1 == s2 ){ //不会执行的语句}

    这时用==判断就可知，虽然两个对象的"内容"相同[equals()判断]，但两个引用变量所持有的引用不同，

    BTW：上面的代码创建了几个String Object? [三个，pool中一个，heap中2个。]
    [Java2 认证考试学习指南 (第4版)( 英文版)p197-199有图解。]


2、字符串的+运算和字符串转换
    字符串转换和串接是很基础的内容，因此我以为这个问题简直就是送分题。事实上，我自己就答错了。

String str = new String("jf"); // jf是接分
str = 1+2+str+3+4;
一共创建了多少String的对象？[我开始的答案：5个。jf、new、3jf、3jf3、3jf34]

    首先看JLS的有关论述：

    一、字符串转换的环境[JLS 5.4 String Conversion]

    字符串转换环境仅仅指使用双元的+运算符的情况，其中一个操作数是一个String对象。在这一特定情形下，另一操作数转换成String，表达式的结果是这两个String的串接。

    二、串接运算符[JLS 15.18.1 String Concatenation Operator + ]

    如果一个操作数/表达式是String类型，则另一个操作数在运行时转换成一个String对象，并两者串接。此时，任何类型都可以转换成String。[这里，我漏掉了"3"和"4"]

如果是基本数据类型，则如同首先转换成其包装类对象，如int x视为转换成Integer(x)。 
现 在就全部统一到引用类型向String的转换了。这种转换如同[as if]调用该对象的无参数toString方法。[如果是null则转换 成"null"]。因为toString方法在Object中定义，故所有的类都有该方法，而且 Boolean, Character, Integer, Long, Float, Double, and String改写了该方法。 
关于+是串接还是加法，由操作数决定。1+2+str+3+4 就很容易知道是"3jf34"。[BTW :在JLS的15.18.1.3中举的一个jocular little example，真的很无趣。]
    下面的例子测试了改写toString方法的情况.。

class A{
    int i = 10;
    public static void main(String []args)
    {
            String str = new String("jf");
            str += new A();
            System.out.print(str);
    }
        public String toString()
           {
                return " a.i ="+i+"/n";
           }
}

三、字符串转换的优化

按照上述说法，str = 1+2+str+3+4;语句似乎应该就应该生成5个String对象：

1+2 ＝3，then 3→Integer(3)→"3" in pool? [假设如此] 
"3"+str(in heap) = "3jf"     (in heap) 
"3jf" +3 ,first 3→Integer(3)→"3" in pool? [则不创建] then "3jf3" 
"3jf3"+4 create "4"  in pool 
then "3jf34"

    这里我并不清楚3、4转换成字符串后是否在池中，所以上述结果仍然是猜测。

    为了减少创建中间过渡性的字符串对象，提高反复进行串接运算时的性能，a Java compiler可以使用StringBuffer或者类似的技术，或者把转换与串接合并成一步。例如：对于 a + b + c ，Java编译器就可以将它视为[as if]

    new StringBuffer().append(a).append(b).append(c).toString();

    注意，对于基本类型和引用类型，在append(a)过程中仍然要先将参数转换，从这个观点看，str = 1+2+str+3+4;创建的字符串可能是"3"、"4"和"3jf34"[以及一个StringBuffer对象]。

    现在我仍然不知道怎么回答str = 1+2+str+3+4;创建了多少String的对象，。或许，这个问题不需要过于研究，至少SCJP不会考它。

3、这又不同：str = "3"+"jf"+"3"+"4";
    如果是一个完全由字符串文字组成的表达式，则在编译时，已经被优化而不会在运行时创建中间字符串。测试代码如下：

String str1 ="3jf34";
String str2 ="3"+"jf"+"3"+"4"; 
  if(str1 == str2) {
              System.out.println("str1 == str2");
                }
  else {
              System.out.println("think again");
       } 
if(str2.equals(str1)) 
System.out.println("yet str2.equals(str1)");

    可 见，str1与str2指向同一个对象，这个对象在pool中。所有遵循Java Language Spec的编译器都必须在编译时对 constant expressions 进行简化。JLS规 定：Strings computed by constant expressions (ý15.28) are computed at compile time and then treated as if they were literals. 

    对于String str2 ="3"+"jf"+"3"+"4";我们说仅仅创建一个对象。注意，“创建多少对象”的讨论是说运行时创建多少对象。

    BTW：编译时优化

    String x = "aaa " + "bbb "; 
       if (false) {        x = x + "ccc ";    }
           x +=  "ddd ";    等价于：    String x = "aaa bbb ";    x = x + "ddd ";

4、不变类
    String 对象是不可改变的(immutable)。有人对str = 1+2+str+3+4;语句提出疑问,怎么str的内容可以改变？其实仍然是因为不清楚： 引用变量与对象的区别。str仅仅是引用变量，它的值??它持有的引用可以改变。你不停地创建新对象，我就不断地改变指向。[参考TIJ的Read- only classes。]

    不变类的关键是，对于对象的所有操作都不可能改变原来的对象[只要需要，就返回一个改变了的新对象]。这就保证了对象不可改变。为什么要将一个类设计成不变类？有一个OOD设计的原则：Law of Demeter。其广义解读是：

    使用不变类。只要有可能，类应当设计为不变类

##################################################################################

转贴自  http://galaxystar.javaeye.com/blog/48178

要理解 java中String的运作方式，必须明确一点：String是一个非可变类（immutable）。什么是非可变类呢？简单说来，非可变类的实例是不 能被修改的，每个实例中包含的信息都必须在该实例创建的时候就提供出来，并且在对象的整个生存周期内固定不变。java为什么要把String设计为非可 变类呢？你可以问问 james Gosling ：）。但是非可变类确实有着自身的优势，如状态单一，对象简单，便于维护。其次，该类对象对象本质上是线程安全的，不要求同步。此外用户可以共享非可变对 象，甚至可以共享它们的内部信息。（详见 《Effective java》item 13）。String类在java中被大量运用，甚至在class文件中都有其身影，因此将其设计为简单轻便的非可变类是比较合适的。

一、创建。
    好了，知道String是非可变类以后，我们可以进一步了解String的构造方式了。创建一个Stirng对象，主要就有以下两种方式：

java 代码

1. String str1 = new String("abc");    
2. Stirng str2 = "abc";  

     虽然两个语句都是返回一个String对象的引用，但是jvm对两者的处理方式是不一样的。对于第一种，jvm会马上在heap中创建一个String对 象，然后将该对象的引用返回给用户。对于第二种，jvm首先会在内部维护的strings pool中通过String的 equels 方法查找是对象池中是否存放有该String对象，如果有，则返回已有的String对象给用户，而不会在heap中重新创建一个新的String对象； 如果对象池中没有该String对象，jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings pool中。注意：使用第一种方法创建对象时，jvm是不会主动把该对象放到strings pool里面的，除非程序调用 String的intern方法。看下面的例子：

java 代码

1. String str1 = new String("abc"); //jvm 在堆上创建一个String对象   
2.   
3.  //jvm 在strings pool中找不到值为“abc”的字符串，因此   
4.  //在堆上创建一个String对象，并将该对象的引用加入至strings pool中   
5.  //此时堆上有两个String对象   
6. Stirng str2 = "abc";   
7.   
8.  if(str1 == str2){   
9.          System.out.println("str1 == str2");   
10.  }else{   
11.          System.out.println("str1 != str2");   
12.  }   
13.   //打印结果是 str1 != str2,因为它们是堆上两个不同的对象   
14.   
15.   String str3 = "abc";   
16.  //此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equels “abc”   
17.  //因此直接返回str2指向的对象给str3，也就是说str2和str3是指向同一个对象的引用   
18.   if(str2 == str3){   
19.          System.out.println("str2 == str3");   
20.   }else{   
21.          System.out.println("str2 != str3");   
22.   }   
23.  //打印结果为 str2 == str3  

   再看下面的例子：

java 代码

1. String str1 = new String("abc"); //jvm 在堆上创建一个String对象   
2.   
3. str1 = str1.intern();   
4. //程序显式将str1放到strings pool中，intern运行过程是这样的：首先查看strings pool   
5. //有没“abc”对象的引用，没有，则在堆中新建一个对象，然后将新对象的引用加入至   
6. //strings pool中。执行完该语句后，str1原来指向的String对象已经成为垃圾对象了，随时会   
7. //被GC收集。   
8.   
9. //此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equels “abc”   
10. //因此直接返回str1指向的对象给str2，也就是说str2和str1引用着同一个对象，   
11. //此时，堆上的有效对象只有一个。   
12. Stirng str2 = "abc";   
13.   
14.  if(str1 == str2){   
15.          System.out.println("str1 == str2");   
16.  }else{   
17.          System.out.println("str1 != str2");   
18.  }   
19.   //打印结果是 str1 == str2   
20.   

    为什么jvm可以这样处理String对象呢？就是因为String的非可变性。既然所引用的对象一旦创建就永不更改，那么多个引用共用一个对象时互不影响。

二、串接（Concatenation）。
     java程序员应该都知道滥用String的串接操作符是会影响程序的性能的。性能问题从何而来呢？归根结底就是String类的非可变性。既然 String对象都是非可变的，也就是对象一旦创建了就不能够改变其内在状态了，但是串接操作明显是要增长字符串的，也就是要改变String的内部状 态，两者出现了矛盾。怎么办呢？要维护String的非可变性，只好在串接完成后新建一个String 对象来表示新产生的字符串了。也就是说，每一次执行串接操作都会导致新对象的产生，如果串接操作执行很频繁，就会导致大量对象的创建，性能问题也就随之而 来了。
    为了解决这个问题，jdk为String类提供了一个可变的配套类，StringBuffer。使用StringBuffer对象，由于该类是可变的，串 接时仅仅时改变了内部数据结构，而不会创建新的对象，因此性能上有很大的提高。针对单线程，jdk 5.0还提供了StringBuilder类，在单线程环境下，由于不用考虑同步问题，使用该类使性能得到进一步的提高。

三、String的长度
   我们可以使用串接操作符得到一个长度更长的字符串，那么，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字符，那么双引号中字符的数量会更少（一个中文字符占用三个字节）。 如果超出这个数量，在编译的时候编译器会报错。