new String()+"abc"生成"abc"对象，但是由于之前已经生成了"abc"对象，因此这里共享"abc"对象，没有产生新的对象这里说错了，应该是产生一个StringBuffer对象，但是不产生"abc"字符串对象了。 所以最终是产生new String()、"abc"和StringBuffer 3个对象。
引用对象？？ 这是什么感觉应该是3个吧 new String() & "abc" concatenated to a new object str
一个不知道重复了多少次的问题了。每过一段时间，就会重复出现一次。楼主若搜索一下CSDN，会找到许多的。几个String对象？ 当然是3个String对象了。因为：String str=new String()+"abc"；编译时是按如下代码进行的： String s = (new StringBuilder()).append(new String()).append("abc").toString();上边三个红色的部分，就是三个String对象。注意：不要把String对象与String的引用相混淆。
"abc" --> 1个对象
两者相加 --> 1个对象
“abc”--> 1个对象
两者相加 --> 1个对象和String str = new String（）相比，多了一个abc字符串。
一共创建4个字符串：
1."abc"为一个字符串
2.new String()创建了一个字符串
3.new String+"abc"创建了一个字符串(String类型连接是新建一个新的字符串，不同于StringBuffer)
4.str为指向新生成的字符串的引用，本身会在内存中创建一个String类型的引用对象
如果是结果，很明显，1个，也就是堆中的"abc"
如果是过程，则是堆中一个""和"abc",然后new出一个"abc"(2者相加),原来的2者变成垃圾对象，随时gc
这句话是没错但是 new String+"abc"创建了一个字符串(String类型连接是新建一个新的字符串，不同于StringBuffer) 他们其实指的是一个字符串，因为后面是给前面的付初值，你不能把
String str=new String()+"abc" 拆开来看所以是3个
如果你是这样写的String str=null；str=new String()+"abc" 那就是4个
这句话是没错但是 new String+"abc"创建了一个字符串(String类型连接是新建一个新的字符串，不同于StringBuffer) 他们其实指的是一个字符串，因为后面是给前面的付初值，你不能把
String str=new String()+"abc" 拆开来看所以是3个
如果你是这样写的String str=null；str=new String()+"abc" 那就是4个
"abc" --> 1个对象
str --> 1个对象三个对象 什么时候给个正确答案
new String()创建一个
"abc"创建一个
new String() + "abc"创建一个StringBuffer对象
String str = "abc";
等效于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。字符串串联是通过 StringBuilder（或 StringBuffer）类及其 append 方法实现的。字符串转换是通过 toString 方法实现的，该方法由 Object 类定义，并可被 Java 中的所有类继承。
所以，
new String()初始化一个新创建的 String 对象，使其表示一个空字符序列——产生的第一个对象
"abc"初始化"abc"对象——产生第二个对象
new String()+"abc"生成"abc"对象，但是由于之前已经生成了"abc"对象，因此这里共享"abc"对象，没有产生新的对象。
最终产生的对象是2个对象而已。
所以最终是产生new String()、"abc"和StringBuffer 3个对象。
引用对象？？ 这是什么感觉应该是3个吧 new String() & "abc" concatenated to a new object str
问这种问题有什么意义呢，就像问回字几种写法，了解原理不就可以了，一天到晚刻意的追着这个无聊的问题探讨以此来显示自己博学的可笑心里。
"abc" 这玩意即是一个对象，也是一个常量，人才。
3个
"abc" 创建一个
String str 创建一个
public class HowManyString {
public static void main(String args[]){
String str1 = new String();
String str2 = "";
System.out.println(str1 == str2);
System.out.println(str1.equals(str2)); //str1与str2（也就是""）不是同一个对象
String str3 = new String() + "abc";
String str4 = "" + "abc";
String str5 = "abc";
System.out.println(str3 == str4);
System.out.println(str3 == str5);
System.out.println(str4 == str5);//str3与str4和str5不是同一个对象，str4与str5是同一个对象，因为编译优化
}
}
应该和34楼说的一样，str指向的就是new String(）所在的空间。
具体是这样的
String str=new String()+"abc"
1 编译期
1） 无法确定new String()
2） 检测"abc"在string中是否存在equals("abc")返回true的字符串（string pool中没有对象），
因为返回false，所以在string pool中放入"abc"
3） 因为1，所以new String()+"abc"无法确定
2 运行期
1）查找string pool中有无"",没有，则将""放入string pool,并且由于new关键字，所以在堆中创
建"abc"对象，返回引用
2）查找string pool中有无"abc"，有（编译期放入），所以不在堆中创建新的"abc"对象
3）new String()+"abc"，查找string pool,存在"abc",由于new，在堆中创建新的"abc"对象最后剩下的是引用str指向"abc"这个对象，其余对象随时被gc
之前我说错了，一共创建2个对象，留下一个，另个为垃圾对象，随时被回收
运行期中第一条“所以在堆中创建"abc"对象打错了”，是创建""对象
new >>>>>>>>>>>>>>>一个对象
"abc">>>>>>>>>>>>>>>一个对象
new String()+"abc">>>>>>>>>一个月的对象4个对象
17楼大侠你的说法有点问题吧。
顺便看看段代码：
package zxr;/**
*
* @author Java-Demon
*
*/
public class StringTest { /**
* @param args
*/
public static void main(String[] args) {
String s=new String()+"abc";
String s2="abc";
if(s==s2){
System.out.println("s==s2");
}else{
System.out.println("s!=s2");
}
String s3=new String("abc");
if(s==s3){
System.out.println("s==s3");
}else{
System.out.println("s!=s3");
}
if(s2==s3){
System.out.println("s2==s3");
}else{
System.out.println("s2!=s3");
} }}结果：
s!=s2
s!=s3
s2!=s3
我想大家应该明白了。
"abc"----->1个
new String()--->1个
new String()+"abc" ---->1个
那好，现在我们假设有2个String对象引用
String str1 = new String()+"abc";
String str2 = str1;
str1 = "a";
System.out.println(str1);
System.out.println(str2);
那么按照你的想法既然str1和new String()+"abc"是同一个对象，那么在接下来我让str2指向str1，然后改变str1的指向,既然你说str1和new String()+"abc"是同一个对象，那么请你来解释一下既然我改变了同一个对象的值(引用)，为什么str2的指向依然为str1指向改变之前的对象，按你说的改变了同一个对象那么应该对象被改变了才是
str2指向str1是将之前str1指向对象的地址给了str2
str1="a";是将str1指向了常量池中的"a",只是改变了str1引用的值，而不是改变了原有的对象内容，此时str2并没有被改变
String str1 = "abc";
String str2 = str1;
str1 = "a";
System.out.println(str1);
System.out.println(str2);
StringBuffer sb1 = new StringBuffer(str2);
StringBuffer sb2 = sb1;
sb2.append("d");
System.out.println(sb1.toString());
System.out.println(sb2.toString());
输出：
a
abc
abcd
abcd
所以说str1和那个new String()+"abc"是不是一个对象不能由你的那段代码来否定，呵呵~~事实上，这道题如果说清楚：那段代码到底在内存中生成多少个String的对象，我想就不会有这么多答案了。就是3个。new String()+"abc"是在内存中新产生了一个“abc”，这个abc不在常量池中，是在对象存储区：堆（heap）里。然后str1引用了这个对象。就是这么一回事儿。反证法，如果str1和那个不是一个对象，我问你：String str = "abc"；这有几个对象呢？如果是1个的话，那和上面的有什么区别？abc当然就是str了！
就好比String a ="abc"
这句话根本没有创建对象，只是在编译的时候往string pool中放入"abc"
然后运行期间，返回引用，而引用a也不是对象
"abc"产生1个对象 在字符串池中
new String() + "abc" 产生1个String对象 在heap中
关键是这个str的引用是不是一个对象，这里是我搞错了 （也是我一开始搞对的，然后被人问了一句就又搞错了），回答是str和new String()+"abc"是2个对象，都在heap中。两者唯一相同的地方是它们的字符数组是一样的。所以47#不好意思，是我错了，但是你的例子是无法说明你的论点的。因此一共4个String对象在内存中。
String str --1
new String --2
String+“abc”--3
string str---1
new string ----1
“abc”--1
楼主答案是多少啊
这么多的意见！
到底哪个是对的？
看来是对对象的理解不同了，我认为str这个引用不是java对象，还有在string pool中的"abc"也不是对象，原因就是在与string pool的机制
整个创建过程在37~38#我说得很清楚了至于58#的疑问，我认为这个纯属个人兴趣，就好比一个卖菜的，突然问这个菜怎么生长的，他就去问种菜的了
不爱种菜的就可以无视了
2：new String()+"abc"
3：String str=new String()+"abc"
三个对像麻
1 abc
2 ""
3 str
建议你好好学习一下JAVA基础吧
就是4个，一旦String str,就会在内存中生成一个String类型的对象，和他所指向的String对象不是同一个。
当然是3个String对象了。因为：String str=new String()+"abc"；编译时是按如下代码进行的： String s = (new StringBuilder()).append(new String()).append("abc").toString();上边三个红色的部分，就是三个String对象。注意：不要把String对象与String的引用相混淆。