一道java面面试题，迷糊了

好像是说三个吧,"abc"是pool里边的好像,然后再new 一个String object,再就是一个object refrence到这个String object

两
一个是s
一个是字符串abc
哈哈

前提是在栈中先前没有"abc"这个对象.会是两个.

那也不能说是对象啊，因为JAVA里面除了8中基本的数据类型是对象外，那么剩下的就是引用了啊

显然是开辟那一段“abc”的内存，给S这个地址的引用

简单问题，2个
String s = new String("abc"); // creates two objects, and one
// reference variable

简单问题？2个？
String s1 = new String("abc");
String s2 = new String("abc");
上面两行代码创建了几个对象？4个？那就错了。得批评一下版主，不要以个人的看法来判断某个问题是否有讨论的必要。如果大家都不感兴趣的话，它自然会沉下去。

to : taolei(实在无聊) ( ) 信誉：100 二楼的不是斑竹...

String a1=new String("abc");
String a2=new String("abc");
.
.
.
String an=new String("abc");
这样就是n+1个对象,一个"abc"对象和n个new出来的对象

两个对象，一个是“abc”,一个是指向“abc”的引用对象s。
JAVA常见的面试题.

别在这里空说,写个程序测试一下就知道了.3个.
public class Test{
      public static void main(String args[]){
             String a1 = new String("abc");
             String a2 = new String("abc");
             System.out.println(a1 == a2);  //false
             System.out.println(a1 == "abc"); //false
             System.out.println(a2 == "abc");  //false

      }
}
测试后是3个对象.
这种问题CSDN上已经有很多了.

晕了，真不知道为什么这么多人坚持是两个，答案是靠背的？
象"abc"这样的字符串常量只在第一次引用的时候创建一个对象，以后使用的时候将引用同一个对象。
例如：
s1 = "abc";
s2 = "abc";
那么 (s1==s2)就是true,s1和s2引用同一个对象。
String s = new String ("abc");
这里 s和"abc" 是不同的对象。s是新创建的对象，但是，"abc"这个对象是不是在这里创建的呢？这要看"abc"是不是第一次被引用了，从给出的问题上无法判断，所以不一定是创建了两个对象。

真无聊,创建了几个对象就数一下有一个new操作符就可以了很明显就一个new当然是一个对象了,大家都过敏了呀!

一个对像（abc），一个指向对像对像的引用
其实这样的问题以前有好多了，

这个问题没必要讨论,那个公司出这种面试题呀?
String s = new String ("abc");这个过程中出现过几个对象只有sun公司才去关心,我们只管用好s就行了,也许现在是三个,或者两个.可能以后sun公司把它优化了一下,就只有一个了.也就是说做编译器(或者在VM里?)的最后目标就是把它优化成只出现一个对象.

java中的＝号在使用过程中会产生内存的分配吗？

和编译器没有关系,和sun也没有关系
一个就是一个,根本没有什么不确定因素

String s = new String ("abc");
当然是创建了2个对象。

晕了，真不知道为什么这么多人坚持是两个，答案是靠背的？
象"abc"这样的字符串常量只在第一次引用的时候创建一个对象，以后使用的时候将引用同一个对象。
例如：
s1 = "abc";
s2 = "abc";
那么 (s1==s2)就是true,s1和s2引用同一个对象。
String s = new String ("abc");
这里 s和"abc" 是不同的对象。s是新创建的对象，但是，"abc"这个对象是不是在这里创建的呢？这要看"abc"是不是第一次被引用了，从给出的问题上无法判断，所以不一定是创建了两个对象。

是三个对象!!!!因为String是个特殊的类型，也就是说String对象之间的赋值是传值而不是通常意义上的传址或引用。首先："abc"被compiler放到一个临时的对象中，我们设为obj1；
然后：new String("abc")将一个新String对象，设定为obj2;
再后：用obj2对s对象进行赋值，由于String的特殊性，它是将obj2进行copy到的字串放到s对象中；所以：三个对象。

再一下Java原代码吧：1. 构造方法：    public String(String original) {
this.count = original.count;
if (original.value.length > this.count) {
    // 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.
    this.value = new char[this.count];
    System.arraycopy(original.value, original.offset,
     this.value, 0, this.count);
} else {
    // The array representing the String is the same
    // size as the String, so no point in making a copy.
    this.value = original.value;
}
    }===================
上面说明"abc"与new String("abc")不是同一个对象，是两个不同的String对象；-------2个;2. 另外，再看看Java相关的教材就知道了string对象是值copy对象，所以=会再产生一个string 对象.--------1个；所以共3个对象。

String s=new String("abc");
"abc"如果在string pool里面有，则不创建，如果没有，则在String pool里创建一个String类型的对象实例。
new String("abc");会在heap中创建一个String对象实例，并将String pool里的"abc"的内容复制到heap中。
而s是指向heap的一个指针，s本身是在栈中，其本身是指针结构而不是String对象结构所以，上题正确的答案应该是，若"abc"不在string pool中，则该语句会创建两个String结构的对象。不知道这样解释清楚了么？
另外，String的值copy特性只在其做为参数传值时体现。
所以
String a="abc";
String b=a;
System.out.println(a==b);
是true，这证明了a和b都是指针，并且指向了相同的地址，所以相等。
而如果此时真的是值copy，则String b=a;应该是将a所指向的String 对象结构复制到b指向的另一空间的String对象结构，则a不应该等于b，因为它们应指向不同的地址。

3个对象。一般都把pool里边的忘了

明显一个对象"abc".还有一个是引用,类似c++的指针，在栈上。

比较赞同下述观点 liuganquan() ( ) 信誉：100  2006-3-15 23:37:10  得分: 0
简单问题，2个
String s = new String("abc"); // creates two objects, and one
// reference variable
taolei(实在无聊) ( ) 信誉：100  2006-03-16 16:14:00  得分: 0
   晕了，真不知道为什么这么多人坚持是两个，答案是靠背的？
象"abc"这样的字符串常量只在第一次引用的时候创建一个对象，以后使用的时候将引用同一个对象。
例如：
s1 = "abc";
s2 = "abc";
那么 (s1==s2)就是true,s1和s2引用同一个对象。String s = new String ("abc");
这里 s和"abc" 是不同的对象。s是新创建的对象，但是，"abc"这个对象是不是在这里创建的呢？这要看"abc"是不是第一次被引用了，从给出的问题上无法判断，所以不一定是创建了两个对象。

taolei(实在无聊) ( ) 信誉：100 2006-03-16 16:14:00 得分: 0
比较支持这种观点。
但是我还是认为是2个
因为这里面考的不是我们abc创建的对象。而是new的那句话创建的对象。
鄙人从出题者的观点看待这个问题

String s= new String("haha");
s--->是个引用,在栈里
haha---->是创建出来得对象,放在堆里

晕不懂JAVA也敢参加JAVA面试啊？

这里有很多人把
String a = "abc";
跟
String a = new string("abc");
搞混了~

应该是一个哦
那就是s哦
那个abc是s的初使值百！
看看new不就知道是一个的哦
怎么回有两个呢

我刚才看了上面的
现在有个程序枫叶的
public class hu{
      public static void main(String args[]){

            String a1=new String("abc");

             System.out.println(a1 == "abc"); //false
                   }
}
而
public class hu{
      public static void main(String args[]){

            String a1="abc";

             System.out.println(a1 == "abc"); //true
                    }
}
所以说应该是两对象呢

使用new是新建了一个对象s是肯定的，主要是考虑string所起的作用．在给定类中定义了一个构造函数（注意本例只定义了一个），该构造函数初始化了一个新的对象及其变量，创建了该对象所需的任何其他对象，
也就是说构造函数定义了一个对象，（上句可参考java2　２１天自学通６３页）
故此程序应该是创建了两个对象

对象不要去在意了，知道==，equal的比较，返回！这些功能就可以了
当然，字符串的东西还是要搞清楚的，可以去查查String的源代码，你应该会更清楚点

说了好几遍了~~string a = new string("abc");跟string a = "abc";原理不一样string a = new string("abc");
一定是创建了一个string对象(堆),一个是string对象的引用(栈)string a = "abc";
这要看情况,如果之前有 string X="abc";,这样子不会新创建string对象,而只是创建了一个对象引用.如果没有string x="abc";之类的存在,则会创建一个新的string对象abc,并且还会创建一个string对象的引用

晕死了,结贴了.不过希望有人能把arraycopy解释的清楚一点.我问了275考试中这题的标准答案是2个.谢谢大家.

简直就是误人子弟！
作为字符串常量池是编译器处理的，不能当作创建的对象之说
所谓创建的对象就是指在堆中分配的，使用new才作为创建的，是一种动态行为。
常量池是静态行为，不作为创建的对象。
在栈里的引用更不能作为对象处理，其实和c语言是一样的，只有malloc才算真正的非配内存，
其他的定义都是静态分配的。

都让你们给搞晕了，到底几个啊？、
另外我记得判断是否相等是用的：equals（）方法吧？？？
同志们！

嗯，如果按照treeroot的说法，我也觉得有一定道理。我理解，按照treeroot所说，所谓静态行为，即在编译时将这些字符串事先编译到了代码段里。也就是说，并非是程序运行到String s="abc";才去池中查找，才知道要在池里建个abc，而是在编译时，早就将本程序所有的静态字符串扫描过了，都编在了代码里，包括这个"abc"。那么当然，“运行这句时，在池中查找，如果没有就建立”的说法是不成立的了。下面我还有个问题就是，池中的"abc"的内存结构是不是和堆上建立的那些String 一样的？即包括完整的toString()方法等的定义？

2个,一个Class对象,一个String对象

调试易

一道java面面试题，迷糊了

解决方案 »