一个被问过千变万变的基础问题！但每次都有不同答案!
String s=new String( "aaaaaaaaaaaaaaaaa ");
创建了几个String Object？哪几个？
只说数字的就别留言了！
分就这么多。这问题在CSDN上有N多答案！郁闷 ，越看越糊涂
[解决办法]
http://community.csdn.net/Expert/topic/4802/4802083.xml?temp=.2654993
[解决办法]
个人认为
只1个对象，使用new String( " ")只能建立一个对象.
只大虾斧正.
[解决办法]
2
[解决办法]
2个
String s是一个对象
new String( "aaaaaaaaaaaaaaaaa ");是一个对象
String s=new String( "aaaaaaaaaaaaaaaaa ");是把对象二赋值给对象1
[解决办法]
一个是 "aaaaaaaaaaaaa "，
另外一个是new出来的，这个new出来的被s引用。
[解决办法]
1个 new String( "aaaaaaaaaaaaaaaaa ");
2个 String s指向( "aaaaaaaaaaaaaaaaa ");的
我的理解
[解决办法]
两个对象，一个变量。
一个对象是String类型的字符串常量 "aaaaaaaaaaaaaaaaa "，放在常量池中
一个对象是new String生成的对象，存储于heap中，对象的内容是上面生成的字符串常量
还有一个变量是s，是引用，存储于栈中，指向heap中new String生成的对象
[解决办法]
两个对象被，一个是存放在栈内存中的基本数据aaaaaaa,一个在存放在堆内存中它的引用对象，这不是java必问32道题中的一道吗？！
[解决办法]
String s=new String( "aaaaaaaaaaaaaaaaa ");
两个:
"aaaaaaaaaaaaaaaaa "显然是对象,而构造函数根据传进的参数又构造了一个对象.
这个可以说是java的API的一个bug,因为String是个不可变类,完全没有必要提供这样的一个构造函数.effective java里有说到.
[解决办法]
我个人的意见：
先说这个“new”。因为String是java.lang.Object类型，所以，生成String对象是能用“new”关键字。用new的时候，JVM在“堆”里面分配了一块内存用于存储“aaaaaaaaa”，这就是一个对象了。然后是“String s”，这里创建的其实就只有一个String对象指针而已（忘记是占几个B了），不过现在是none值。那么“=”呢，唯一的作用是把那个String对象的地址填到s里，所以以后才能用“s”来引用“aaaaaaaa”。所以，创建了一个String对象，同时还包含一个对象指针，但是指针似乎不算对象。
[解决办法]
我没那么多话说。
就一句：2个。
[解决办法]
1.
class Test
{
public static void main(String[] args)
{
String s = "123 ";
}
}
Runtime Heap Summary: Test
==========================
Runtime Instance List
---------------------
Package Class Count Cumulative Count Memory Cumulative Memory
------- ----- ----- ---------------- ------ -----------------
Total 2 (100.0%) 2 (100.0%) 48 (100.0%) 48 (100.0%)
java.lang String 1 (50.0%) 1 (50.0%) 24 (50.0%) 24 (50.0%)
char[ ] 1 (50.0%) 1 (50.0%) 24 (50.0%) 24 (50.0%)
Report Date: 2007-4-26 15:27:49
结论：String s = "123 "，会创建一个 "123 "字符数组和一个String对象。
2.
class Test
{
public static void main(String[] args)
{
String s = new String( "123 ");
}
}
Runtime Heap Summary: Test
==========================
Runtime Instance List
---------------------
Package Class Count Cumulative Count Memory Cumulative Memory
------- ----- ----- ---------------- ------ -----------------
Total 3 (100.0%) 3 (100.0%) 72 (100.0%) 72 (100.0%)
java.lang String 2 (66.7%) 2 (66.7%) 48 (66.7%) 48 (66.7%)
char[ ] 1 (33.3%) 1 (33.3%) 24 (33.3%) 24 (33.3%)
Report Date: 2007-4-26 15:29:07
结论：String s = new String( "123 ");根据上面的测试可以看出， "123 "创建了一个数组，一个String对象
，而new String()又根据 "123 "对象作为参数，重新生成了一个新的String对象，此对象被s变量引用。
3.
class Test
{
public static void main(String[] args)
{
String s1 = "123 ";
String s2 = "123 ";
if (s1 == s2) {
System.out.println( "s1==s2 ");
} else {
System.out.println( "s1!=s2 ");
}
}
}
输出结果：s1==s2
4.
class Test
{
public static void main(String[] args)
{
String s1 = new String( "123 ");
String s2 = new String( "123 ");
if (s1 == s2) {
System.out.println( "s1==s2 ");
} else {
System.out.println( "s1!=s2 ");
}
}
}
结果：s1!=s2
5.
class Test
{
public static void main(String[] args)
{
String s1 = new String( "123 ");
String s2 = new String( "123 ");
}
}
Runtime Heap Summary: Test
==========================
Runtime Instance List
---------------------
Package Class Count Cumulative Count Memory Cumulative Memory
------- ----- ----- ---------------- ------ -----------------
Total 4 (100.0%) 4 (100.0%) 96 (100.0%) 96 (100.0%)
java.lang String 3 (75.0%) 3 (75.0%) 72 (75.0%) 72 (75.0%)
char[ ] 1 (25.0%) 1 (25.0%) 24 (25.0%) 24 (25.0%)
Report Date: 2007-4-26 15:41:50
结论：相同字符串常量，即使在不同语句中被引用，其内存是共用的， "123 "只生成一个字符数据和一个
String对象，两个new String()分别生成了一个对象。
6.
class Test
{
public static void main(String[] args)
{
String s1 = new String( "123 ");
String s2 = new String( "1234 ");
}
}
Runtime Heap Summary: Test
==========================
Runtime Instance List
---------------------
Package Class Count Cumulative Count Memory Cumulative Memory
------- ----- ----- ---------------- ------ -----------------
Total 6 (100.0%) 6 (100.0%) 144 (100.0%) 144 (100.0%)
java.lang String 4 (66.7%) 4 (66.7%) 96 (66.7%) 96 (66.7%)
char[ ] 2 (33.3%) 2 (33.3%) 48 (33.3%) 48 (33.3%)
Report Date: 2007-4-26 15:43:45
结论： "123 "和 "1234 "分别生成了各自的字符数组和String对象。两个new String()分别创建一个String对
象。
[解决办法]
String s;
首先 new 的话肯定是有一个对象的。
证明 String s;
创建了一个对象
（个人见解）
只有对象才可以调用方法，这个应该没有人有疑问把
因为 String s; 可以用s直接调用方法，所以String s; 创建了一个对象
[解决办法]
qiang!!!
[解决办法]
skystar99047(天星)
你那个测试的数据怎么得到的？ 什么方式啊 ？学习一下
一会回来结帖
－－－－－－－－－－－－－－－－－－－－－－－－－－－
那个应该是JProfiler
[解决办法]
2个
一个在常量区
一个在堆区
[解决办法]
而下面则不同：
String s3 = new String( "hello ");
String s4 = new String( "hello ");
由于使用了new操作符，在heap中首先创建了两个string对象，然后分别被stack中的s3、s4引用。
(s3 == s4)
这肯定false啊！！
[解决办法]
net中也有类似的 字符串驻留 技术
[解决办法]
其实也是蛮有用的,比如面试的人不知道问什么的时候,就会考这个
[解决办法]
看明白问题再回答,人家是问几个String Object对象：答案就是1个。
首先在内存中产生一个字符串，内容为 "aaaaaaaaaaaaaaaa "，注意不是String Object；
再产生一个指向String类型的指针，注意，这是指针，也不是String Object；
new出来的才是真正的String Object，将它的首地址赋给了指针，内容吗，就用字符串进行赋值了。
[解决办法]
我认为是3个对象, 2个string对象
"aaaaaaaaaaaaa "是一个临时对象,
new string( " ")是一个string对象,
s = new... 是拷贝到另一个string s对象.
[解决办法]
学习～～～～～～～
[解决办法]
呵呵，开始以为是两个对象，那知道发现这是一个JAVA社区，呵呵，如果是JAVA的话，那么对象当然只有一个了。
因为是JAVA中是不存在一个直接建立栈变量的方法。所以new之后一个堆变量产生，然后将返回的引用赋值给s（栈引用变量）.
[解决办法]
2个
[解决办法]
废话不多说
2个
[解决办法]
2个呗，地球人都知道。
[解决办法]
结论已经有啦就是2个, 你的blob上的测试结果也是这样呀，测试结果与上面一些高人的分析不同, 花太多时间研究这个没什么意义吧,编译器是人家写的，随时都会有可能改变.
[解决办法]
不知道
[解决办法]
看那么多干嘛啊！！两个
前些日子这csdn下过java面试题 第一题好像就是这个东西
答案是2 讲的挺清楚的！！！！自己下载看看去
[解决办法]
一个对象 强烈呼吁
String s;创建一个对象，不分配内存空间new String( "XXXXXXXXXXXXXXX ")将其初始化
就像你自己写的一个类，用一个构造方法将其初始化
public String String(String s);
[解决办法]
... 弄清楚了就好了 搞这么多噱头
[解决办法]
个人认为
对象只有一个
但对象的引用有两个，其中一个很快被回收
或者用C的思路来看
产生了一个数组和两个指针，其中一个指针很快被销毁
[解决办法]
2个
String s是一个对象
new String( "aaaaaaaaaaaaaaaaa ");是一个对象
[解决办法]
mark
[解决办法]
学习引用的概念，s创建的时候是一个指针，指向一个地址；new一个对象，然后把指针指向它；
[解决办法]
指针是对象么？
[解决办法]
一个对象！！！！！！！！！另一个只能算是指针。
[解决办法]
Initializes a newly created String object so that it represents the same sequence of characters as the argument; in other words, the newly created string is a copy of the argument string. Unless an explicit copy of original is needed, use of this constructor is unnecessary since Strings are immutable.
[解决办法]
我也被搞晕了
[解决办法]
群雄聚会 搞晕鄙人
[解决办法]
明显就一个对象嘛
"aaaaaaaaaaaaaaaaa "是对象 s是指针 new 只是一个动作，将 "aaaaaaaaaaaaaaaaa "的地址给s
[解决办法]
不错.多多学习!
[解决办法]
String s = new String( "aaaaaaa ")
先生成字符串对象 "aaaaaaa "
new String( "aaaaaaaa ")又生成一个对象
s只是对象的引用
[解决办法]
String s = "aaaaaaa " ; //创建一个对象
String s = new String ( "aaaaaa "); //创建两个对象
[解决办法]
我是这么理解的。题目有些不严谨，这句代码创建的对象个数依赖于串池里有没有
"aaaaaaaaaaaaaaaaa "
这个对象，如果先前就有代码创建了，那么
String s = new String( "aaaaaaaaaaaaaaaaa ");
只在堆中以串池中的那个对象为模板建了一个对象！！！
如果串池中没有这个对象，
那么这句代码会创建两个对象，一个在串池，一个在堆。
串池可能就是在栈中，具体实现我不了解，我把它看成单例的对象池，里面没有重复的对象。
[解决办法]
这样研究的话，java对汇编语言的优势全没了。
[解决办法]
肯定是两个,没错了,一个是new出来的,另一个是先创建但没有初始化的(String s),然后会给s赋值,即把new出来的对象内容拷贝到s中,new出来的对象是无名对象,但的确存在
[解决办法]
我觉得 （--KOFMYLOVE ）
不全对
这里说得比较详细：
http://www.blogcn.com/u/47/61/guiguzi629/blog/44733219.html
[解决办法]
两个对象，一个变量。
一个对象是String类型的字符串常量 "aaaaaaaaaaaaaaaaa "，放在常量池中
一个对象是new String生成的对象，存储于heap中，对象的内容是上面生成的字符串常量
还有一个变量是s，是引用，存储于栈中，指向heap中new String生成的对象
[解决办法]
呵呵，当然是一个了。
new语句在内存中分配了一段内存。也就是一个对象吧。把这个对象的地址给了s.就这么简单。现在只有通过s才能够访问到这个对象。本身就只有一个对象。这个对象的名字叫s.
[解决办法]
这怎么又浮出来了呀？真是无奈了。
[解决办法]
应该是1个把
s不是对象 只是一个句柄
关于这个讨论的还真是多阿 。。。。。
[解决办法]
2个
堆栈
[解决办法]
String s=new String( "aaaaaaaaaaaaaaaaa ");
创建了几个String Object？哪几个？
________________________________
2个对象,一个是String aaaaaaaaaaaaaaaaa= "aaaaaaaaaaaaaaaaa " 另一个是
String s=new String( "aaaaaaaaaaaaaaaaa ")和String s=new String(aaaaaaaaaaaaaaaaa)是一样的