String s1 = new String("abc");String s2 = new String("abc");产生了几个对象

zzu_sun 2011-11-29 11:40:19

String s1 = new String("abc");
String s2 = new String("abc");
这中间产生了几个对象？

...全文

1287 41 打赏收藏转发到动态举报

写回复

用AI写文章

41 条回复

切换为时间正序

请发表友善的回复…

发表回复

hclovehf 2013-09-13

打赏
举报

产生了3个对象.

逍遥jc 2013-09-13

打赏
举报

引用 19 楼 mengxiangyue 的回复:

两个 String s1 = "abc"; String s2 = "abc"; 这样实际的对象就有一个只是产生了两个变量都指向同一个对象

String s1 = "abc"; String s2 = "abc"; 这个和new String("abc") 不一样啊。

whos2002110 2013-09-13

打赏
举报

引用 30 楼 open4u 的回复:

[Quote=引用 17 楼 xierong2011 的回复:] java中String s = new String("abc")创建了几个对象？！答案是两个，现在我们具体的说一下： String s = new String("abc"); 首先我们要明白两个概念，引用变量和对象，对象一般通过new在堆中创建，s只是一个引用变量。所有的字符串都是String对象，由于字符串文字的大量使用，java中为了节省时间，在编译阶段，会把字符串文字放在文字…… [/Quote] 17楼的第二点说法有些问题，首先，并不是所有字符串都会放在常量池中，能放在常量池中的字符串，必须是以字符串常量的身份进入的。如： String str = "abc"; 此时，常量池中自然会有“abc”，而且是在编译阶段进行的。而String s1 = new String("abc"); 这里的“abc”和常量池并没有什么关系。因为此时的"abc",存在于堆中，并不是常量池里的那个。更不会是从常量池复制过来的。

任何位置双引号表示出的字符串都会在编译器放到常量池中

失忆的鱼 2013-09-13

打赏
举报

引用 17 楼 xierong2011 的回复:

java中String s = new String("abc")创建了几个对象？！答案是两个，现在我们具体的说一下： String s = new String("abc"); 首先我们要明白两个概念，引用变量和对象，对象一般通过new在堆中创建，s只是一个引用变量。所有的字符串都是String对象，由于字符串文字的大量使用，java中为了节省时间，在编译阶段，会把字符串文字放在文字池中，文字池的一个好处就是可以把相同的字符串合并，占用一个空间，我们可以用==判断一下两个引用变量是否指向了一个地址即一个对象
public class Demo02 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1 ="abc";
        String s2 = "abc" ;
        if( s1 == s2 ) System.out.println("s1,s2 refer to the same object");
        else System.out.println("trouble");
    }
}
输出结果为：可以看出指向了一个对象，即文字池中保存了一个对象。二、String s = new String("abc")实际上是"abc"本身就是文字池中的一个对象，在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，所以创建了两个String对象，一个在pool中，一个在堆中。下面看这个程序，创建了几个对象。
public class Demo03 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1 = new String("abc") ;
        String s2 = new String("abc") ;
        if( s1 == s2 ){ //不会执行的语句}
       System.out.println("在堆中创建了一个对象");

    }
        else{
        System.out.println("在堆中创建了两个对象");    
        }
        }
}
输出结果为：可知在堆中创建了两个对象，但是在文字池中有一个对象，所以共创建了三个对象。三、再看下一个例子：
public class Demo04 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s = new String("abc");
        s = "cba";
        System.out.println(s); 
    }

}
输出结果为： String s = new String("abc")并不是给s赋值，而是把字符串"abc"的引用交给s持有，现在把s指向字符串"cba"，"cba"的引用地址把"abc"的引用地址覆盖，所以输出结果为cba 这方面的问题，终结了！呵呵

涨姿势了！

换个响亮的名字 2013-09-12

打赏
举报

引用 17 楼 xierong2011 的回复:

java中String s = new String("abc")创建了几个对象？！答案是两个，现在我们具体的说一下： String s = new String("abc"); 首先我们要明白两个概念，引用变量和对象，对象一般通过new在堆中创建，s只是一个引用变量。所有的字符串都是String对象，由于字符串文字的大量使用，java中为了节省时间，在编译阶段，会把字符串文字放在文字池中，文字池的一个好处就是可以把相同的字符串合并，占用一个空间，我们可以用==判断一下两个引用变量是否指向了一个地址即一个对象
public class Demo02 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1 ="abc";
        String s2 = "abc" ;
        if( s1 == s2 ) System.out.println("s1,s2 refer to the same object");
        else System.out.println("trouble");
    }
}
输出结果为：可以看出指向了一个对象，即文字池中保存了一个对象。二、String s = new String("abc")实际上是"abc"本身就是文字池中的一个对象，在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，所以创建了两个String对象，一个在pool中，一个在堆中。下面看这个程序，创建了几个对象。
public class Demo03 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1 = new String("abc") ;
        String s2 = new String("abc") ;
        if( s1 == s2 ){ //不会执行的语句}
       System.out.println("在堆中创建了一个对象");

    }
        else{
        System.out.println("在堆中创建了两个对象");    
        }
        }
}
输出结果为：可知在堆中创建了两个对象，但是在文字池中有一个对象，所以共创建了三个对象。三、再看下一个例子：
public class Demo04 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s = new String("abc");
        s = "cba";
        System.out.println(s); 
    }

}
输出结果为： String s = new String("abc")并不是给s赋值，而是把字符串"abc"的引用交给s持有，现在把s指向字符串"cba"，"cba"的引用地址把"abc"的引用地址覆盖，所以输出结果为cba 这方面的问题，终结了！呵呵

xiexie!

使劲没想出一个名字 2011-12-01

打赏
举报

String s1="abc";
String s2="abc";
s1与s2是同一个对象的两个引用。
String s11="a"+"b"+"c";
String s22="a"+"b"+"c";
S11与S22也是只创建了一个一个对象，因为在字符串初始化时，会进行编译优化---》
S11="abc"，S22=“abc”；
所以s1=s2=s3=s4实际上他们都是一个对象。也只有一个对象
String s3=new String();
String s4=new String();
S3!=S4,当明确用了一个new关键字时，就会创建一个新的对象。
S3与S4是两个不同的对象了。
string s5=new string("abc");
string s6=new string("abc");
s5 与s6 是两个不同的对象，“abc”这样的常量字符串相当于返回了一个这个字符串对象的一个引用，
所以相同的字符串常量实际上都是一个相同的对象。

用了一个new关键字必定产生一个新的对象，看String类的源码发现，只要字符串的内容发生了变化，
那么在这个方法返回的时候必定用了一个new关键字。