创建String对象的问题

Question

String s = new String("xyz");
问创建了几个String Object?
用程序来证明.

Answer 1

String s = new String("abc");创建了几个String Object?
引用变量与对象的区别； 
字符串文字"abc"是一个String对象； 
文字池(pool of literal strings)和堆(heap)中的字符串对象。    一、引用变量与对象：除了一些早期的Java书籍和现在的垃圾书籍，人们都可以从中比较清楚地学习到两者的区别。
        A aa;
        这个语句声明一个类A的引用变量aa[我们常常称之为句柄]，而对象一般通过new创建。所以题目中s仅仅是一个引用变量，它不是对象。    二、Java中所有的字符串文字[字符串常量]都是一个String的对象。有人[特别是C程序员]在一些场合喜欢把字符串"当作/看成"字符数组，
        这也没有办法，因为字符串与字符数组存在一些内在的联系。事实上，它与字符数组是两种完全不同的对象。        System.out.println("Hello".length());
        char[] cc={'H','i'};
        System.out.println(cc.length);    三、字符串对象的创建:
        由于字符串对象的大量使用(它是一个对象，一般而言对象总是在heap分配内存)，Java中为了节省内存空间和运行时间
        (如比较字符串时，==比equals()快)，在编译阶段就把所有的字符串文字放到一个文字池(pool of literal strings0中，
        而运行时文字池成为常量池的一部分。文字池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。
        我们知道，对两个引用变量，使用==判断它们的值(引用)是否相等，即指向同一个对象：  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有图解。)

Answer 2

楼上的解释很清楚，不过答案比不完善，
String s = new String("xyz");
这个语句创建了几个对象?
可能是一个，因为常量池中可能已经存在“xyz”这个对象了，所以这个语句不会再在常量池中创建了，只在堆里创建一个对象。如果常量池中不存在“xyz”，则会创建两个。

Answer 3

175cm(hanhui)   的解释超清晰，MARK

Answer 4

yin_slin(一生找北) 说的也不错

Answer 5

感谢175cm(hanhui)作出的详细解答.

Answer 6

楼上的解释很清楚，不过答案比不完善，
String s = new String("xyz");
这个语句创建了几个对象?
可能是一个，因为常量池中可能已经存在“xyz”这个对象了，所以这个语句不会再在常量池中创建了，只在堆里创建一个对象。如果常量池中不存在“xyz”，则会创建两个。——————————————————————————————————————————
我觉得String s = new String("xyz");这样是直接创建一个新的，不会再string池中查找是否有旧的。而string s="xyz";才会在池中查找是否有旧的，没有就创建新的。如果new还会查找，那还new个什么劲儿？

Answer 7

肯定是2个，首先"XXX"肯定就是一个String了，另外new String会创建另外一个，但他们不会是String pool中相同的String，所以是两个

Answer 8

一个
String str=new String();肯定是创建一个对象,它描述了一个空的字符序列
那么String str=new String("xyz");是初始化新建的Sting对象.

Answer 9

JDK1.5 src.jar中有关String类的构造方法的实现:(部分) 
    /** The value is used for character storage. */
    private final char value[];    /** The offset is the first index of the storage that is used. */
    private final int offset;    /** The count is the number of characters in the String. */
    private final int count;public String(String original) {
int size = original.count;
char[] originalValue = original.value;   
char[] v;
   if (originalValue.length > size) {
      // The array representing the String is bigger than the new
      // String itself.  Perhaps this constructor is being called
      // in order to trim the baggage, so make a copy of the array.
    v = new char[size];         
             System.arraycopy(originalValue, original.offset, v, 0, size); 
  } else {
      // The array representing the String is the same
      // size as the String, so no point in making a copy.
    v = originalValue;
  }
this.offset = 0;
this.count = size;
this.value = v;
    }由以上的原代码定义来看,String实际上是通过字符数组来实现的,每个字符串对象其实就是一个字符数组,所以String s = new String("xyz");其中的"xyz"由以上定义可以看出,它是一个由一个隐式的字符串对象变量(实际上不存在,我是这么理解的)所引用的字符串对象,它的实例域value[]数组中存的值是'x','y','z';故应该是2个对象.

Answer 10

只有一个,当String s="xyz";的时候才会去池里找,new就直接new个新的,用程序证明嘛,我也不知道

Answer 11

三、字符串对象的创建:
        由于字符串对象的大量使用(它是一个对象，一般而言对象总是在heap分配内存)，Java中为了节省内存空间和运行时间
——————————————————————————————————————————我想问一下楼上的意思是不是说字符串对象不是在heap中分配内存？
也就是说  "abc"本身就是pool中的一个对象，但它不像其它的对象那样是在heap中创建的？
也就是说  文字池成为常量池的一部分，而不属于heap？

Answer 12

1.由于字符串对象的大量使用(它是一个对象，一般而言对象总是在heap分配内存)，Java中为了节省内存空间和运行时间
2.现在看String s = new String("abc");语句，这里"abc"本身就是pool中的一个对象，而在运行时执行new String()时，
    将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。ok，这条语句就创建了2个String对象。
-----------------------------
我觉得这两句有矛盾, 为了节省内存, 为什么 new String 不直接指向pool, 而要在复制一个到head中?   反之, 既然要在head中创建一个, 为什么要去查pool中有没有, 再去复制? 有没有又有啥关系

Answer 13

我们老师是这样讲的：两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s

Answer 14

up一下！
在字符比较中，==与equals是一样的。用在别的类型判断中，＝＝是对象间的比较，equals是值之间的比较。

Answer 15

一个  因为new是新开辟一个内存空间  也就是新建立了一个对象  而后面括号里的是传给这个对象的数值  所以 只有一个    不会用程序说

Answer 16

2个
String s 一个 new String("xyz")一个

Answer 17

2个
new String("xyz")一个
String s 一个 

Answer 18

我同意 yin_slin(一生找北) 的看法，new的那一个肯定是要创建的，但是new里面的那个字符串参数xyz就会判断是不是已经存在了，所以有可能创建一个或者两个对象。

Answer 19

只有看了JVM的实现才有答案,现在说的都是各位的想象

Answer 20

我觉得String s = new String("xyz");这样是直接创建一个新的，不会再string池中查找是否有旧的。而string s="xyz";才会在池中查找是否有旧的，没有就创建新的。如果new还会查找，那还new个什么劲儿？
---------------------------------------------------------------------------------
严重同意 一生找北的解释！
对于上面的回答：new是要产生一个新的对象！至于xyz这个字符串，如果是使用该new语句之前没用高xyz这个串的话，那么这个语句将产生两的对象，一个是xyz，一个是s；如果在使用之前已使用过xyz这个串的话，那这个语句就产生了一个对象s。
不论怎么样，s 与“xyz”都不是一个对象。
String s = "xyz"；这里，s是个常量；跟ring s = new String("xyz");这个语句是不同的。

Answer 21

看了175cm(hanhui) 的回答之后，对字符串有了新的认识。
非常感谢。

Answer 22

说一个的，回去好好看看java书，有时间再看看StringBuffer这个对象的用法，对比下String

Answer 23

175cm(hanhui) 的解释很好。
楼主可以结贴了。

Answer 24

public class Test{
public static void main(String[] args){
String a=new String("ss");
String b="ss";
/**证明"ss"和a占用不同的内存空间*/
if(a=="ss"){
System.out.println("ss");
}else{
System.out.println("nn");/*会输出*/
}
/**证明"ss"和b占用了同一内存空间*/
if(b=="ss"){
System.out.println("ss");/*会输出*/
}else{
System.out.println("nn");
}
/**证明b是对象*/
if(b instanceof String){
System.out.println("ss");/**会输出*/
}else{
System.out.println("nn");
}
/**证明ss是对象*/
if("ss" instanceof String){
System.out.println("ss");/*会输出*/
}else{
System.out.println("nn");
}
}
}

Answer 25

yin_slin(一生找北)
楼上的解释很清楚，不过答案比不完善，
String s = new String("xyz");
这个语句创建了几个对象?
可能是一个，因为常量池中可能已经存在“xyz”这个对象了，所以这个语句不会再在常量池中创建了，只在堆里创建一个对象。如果常量池中不存在“xyz”，则会创建两个。
------------------------------------------------------------
new String("xyz");不论常量池里有否“xyz”对象，都是新建一个对象的。
如果String s = "xyz".intern();则需要根据常量池里有无该对象作判断是否新建一个对象。