帮忙看看简单的JAVA问题！

Question

下面代码的输出是什么？一共在内存中生成了几个String对象？为什么？
String s1 = “aaa”;
String s2 = “aaa”;
String s3 = new String(“aaa”);
String s4 = new String(“AAA”);
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s3));

Answer 1

true
false
true
3个String对象
看看下面这篇文章，相信对你理解该问题会有所帮助。
http://www.pcbbs.cn/Article/BC/JAVA/200601/18349.html

Answer 2

代码输出当然是二楼说的正确的,一共是四个String对象

Answer 3

true
false
true
生成2个对象
------------------
对象在内存中的存储地址由他的hashCode决定，对于String对象，他覆写了Object中的hashCode()：   
public int hashCode() {
int h = hash;
if (h == 0) {
    int off = offset;
    char val[] = value;
    int len = count;            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
    }
所以String 对象比较特殊，只要是值一样，其对应的地址就相同，也就是不生成新的对象。得出结论：s1,s2,s3对应的是同一个对象，s4对应第二个对象。关于String.euqals()方法，代入得是s3的reference复制，也不生成新对象。你可以用
System.out.println(s1.hashCode()+
                  +"\t"+s2.hashCode()+
                       +"\t"+s3.hashCode()+
                        +"\t"+s4.hashCode());测试

Answer 4

true
false
true
3个对象

Answer 5

true ,false , true前两个是同一个对象的引用，后面生成俩个对象

Answer 6

true
false
true
4个
s1和s2指向同一个对象aaa
s3是一个指向堆中aaa的String对象
String s4 = new String(“AAA”);
生成2个对象，一个AAA String常量，一个String对象s4

Answer 7

true
false
true
生成n个对象

Answer 8

运行结果:true
         false
         true
对象个数:4原因:
String s1 = “aaa”;  <=>  String s1=new String("aaa");//JAVA中new即创建新对象
所以共四个新对象 
如果语句为
String s1 = “aaa”; 
String s2=s1;那么这两句只创建了一个对象，第二句只是声明了一个新的String引用，并指向s1所指向的那个对象。而并没有给s2分配实际的内存空间。
不知道我这样说楼主听的懂吗？

Answer 9

同意：dogod 他将“本质”说的很清楚了
只有2个对像运算符==只是比较  两个对像的"内容 "是否相等
方法equals()比较的是两个引用是否相等
public class HelloWorld
{
public static void main(String[] args)
{
String s1 = "aaa";
String s2 = "aaa";
String s3 = new String("aaa");
String s4 = new String("AAA");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s3));
System.out.println(s2.equals(s3));//这句是我加上的结果为true;
}
}

Answer 10

生成了4个对象的引用，分配了3个对象的内存，s1和s2同时指向字符串池里的“aaa“字面量；

Answer 11

共有四个对象是对的.
String(String original) 
          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.
上面是Java API Doc的定义,是字符串变量的拷贝.
public class Test{
public static void main(String args[]){
String s1 = "aaa";
String s2 = "aaa";
String s3 = new String(s1);
String s4 = new String("AAA");
System.out.println(s1 == s2);  //true
System.out.println(s1.equals(s2)); //true
System.out.println(s1 == s3);    //false
System.out.println(s1.equals(s3)); //true
System.out.println(s4 == "AAA");   //false
System.out.println(s4.equals("AAA"));  //true
}
}
就是说生成了四个对象,所以内存中也应该是有四个对象.
dogod(那天,正喝着汤,猛然间....睡着了!) 你的内存地址问题可否说得再清楚点.谢谢!!

Answer 12

String str=”kvill”；String str=new String (“kvill”);的区别：在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。 　　常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。 　　看例1： String s0=”kvill”; String s1=”kvill”; String s2=”kv” + “ill”; System.out.println( s0==s1 ); System.out.println( s0==s2 ); 　　结果为： true true 　　首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。 　　因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。 　　所以我们得出s0==s1==s2; 用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。 　　看例2： String s0=”kvill”; String s1=new String(”kvill”); String s2=”kv” + new String(“ill”); System.out.println( s0==s1 ); System.out.println( s0==s2 ); System.out.println( s1==s2 ); 　　结果为： false false false　　例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。 

Answer 13

true
false
true
3个对象
java语言对于字符串的操作有点特殊像String a="a"这样实在一个字符串池（不知道是不是这么叫）里面生成了一个"a"的对象，如果再声明String b="a",这样的话其实b指向和a一样的
但是new String就不一样了，他只是生成一个普通对象

Answer 14

3个对象
String a="a";
String b="a";
这2个用同一个内存地址