String a="1"; 和 String a=new String(); 以及 String a=new String("1")到底有啥区别？谢谢

去看这个!
http://community.csdn.net/Expert/topic/3364/3364544.xml?temp=8.037966E-02

String a="1"; 和String a=new String("1")；
在使用上没什么区别;
后者创建一个新的对象;

String a="1"; 和 String a=new String("1");一样，都是声明一个String引用，然后指向“1”字符串对象。String a=new String(); 是声明一个String引用，指向“”空的字符串对象

晕,是没看懂吗? String a="1"; 并没对a分配内存空间,只是建立一个句柄(指针)指向"a"String a=new String(); 分配内存空间但a没有指向String a=new String("1") 分配内存空间,将其指向俯给a

区别还是有的       String s="1";
       String ss=new String("1"); //创建新对象
       String sss="1";            //使用已有的缓冲池中对象
       System.out.println(s==ss);
       System.out.println(s==sss);

String a = "1" ;和String a = new String("1");没有区别
String s = "";和String s = new String("");和String s = new String();没有区别

有区别的
1.String a="1"; 是在堆中构建一个String对象"1"，a为其引用。
2.String a=new String(); 同样构建了一个String对象，只不过其中没有任何值。
3.String a=new String("1"); 这里共创建了两个对象，第一个当然是"1"，第二个是由new创建的，a为其引用。

String a="1"; 原理是如果现在heap中已经有值为“1”的String对象，则不会再创建一个对象，而是把a这个引用指向那个对象；
String a=new String("1");则一定会去创建一个String 对象，它的值为"1";
所以当然第一种方法更好；
test:
String a="1";
String b="1";
System.out.println(a==b);//true ,指向同一个对象
String c=new String("1");//重新创建了一个对象
System.out.println(a==c);//false,指向不同的对象String a=new String();创建一个空的String 对象;

String a="1"; 以及 String a=new String("1");
不同.
String a=new String("1");创建了两个String Object .一个是"1",一个是 a.明白?这是SCJP的知识.相信我.

String a="1"; 这个语句声明的是一个指向对象的引用，名为“a”，可以指向类型为String的任何对象，目前指向"1"这个String类型的对象。这里并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。

呵呵，我觉得没有必要搞明白
String和StringBuffer搞明白了就行了

都是对a初始化，用String a="1";看的清楚些

String a="1"; 并没对a分配内存空间,只是建立一个句柄(指针)指向"a"String a=new String(); 分配内存空间但a没有指向String a=new String("1") 分配内存空间,并且指向ａ

应该是
String(String)
分配一个新 String ，它和字符串参数中有相同的字符序列。

String a=new String("gg")不只是在堆中创建
准确的说是在堆中创建“gg”，然后复制到栈中的a对象中，这就是复制过程
而String str="abc";是直接在栈中创建所以，无论是String str="abc";中的str
还是String a=new String("gg")中的a
都是在创建它们的类或者线程的私有栈中生存，其生存周期同创建它们类或线程
当创建它们的类或线程死掉，它们也从栈中弹出，私有变量栈消失关于这个问题可以看看java rules里面有涉及，但翻译的太烂，所以也不是很详细
最简单的做法运用IDE跟踪
Optimizeit配合JBuilder可以看到
在Optimizeit可以跟踪堆变量
在JBuilder中可以跟踪栈变量，跑一个程序看看就知道了另外，只有String是在堆中创建，然后复制到栈中的
其他的基本类型都是在堆中创建然后传引用到栈中的
也就是说栈中都是引用，只有String要复制过来关于栈变量，参看《java Rules中文版》325页
String部分就不用看了，它讲的也不是很清楚

to flyingbug(迫切需要锻炼...)
依你说的，那String a=new String("asdjha");中的a中存的值不是String对象的引用，而是字符串"asdjha"了哦

呵呵，按c＋＋的思路（不会被打死吧^_^）string a= "1"；调用了string的operator＝，里面调用copy constructor，也就是string a ＝ new string("1"）的效果。string a = new string()调用default constructor

呵呵，十一郎又来了
回答你的问题前能不能先回答我一个？
String a=new String("asdjha");创建了几个String对象？我确认我的说法没错，如果你不相信我说的
可以参考《java rules中文版》p230页
或者参考jdk中String源码中的带参构造函数public String(String original)

String a="1"; 和String a=new String("1")；没有什么区别.

to flyingbug(迫切需要锻炼...)
String a=new String("asdjha");
这一句首先声明了一个String类的对象的引用a,然后有用new操作符产生了一个"asdjha"字符串，并返回它的一个对象引用赋给a,
你觉得呢？
以上只是个人看法，有什么问题请大家给小弟指出！！！！

to flyingbug(迫切需要锻炼...)
《java rules中文版》多少钱一本啊？

to：十一郎
《java Rules中文版》定价46元，好不值啊，买了后悔ing....T_T这个问题我最早是在一个《java面试题》的帖子中看到的
那个问题就是我问的问题
我跟几个人讨论，并试验后认为是生成2个对象
就是前面我解释的
当然，这也不一定正确我很奇怪
所有java的书中没有把java对象在内存中的生存过程进行详细说明的
像C++这样的语言，连薄薄的一本《Essencial C++》都讲的很清楚
不知道谁有这方面的资料，拿出来给大伙看看

to flyingbug(迫切需要锻炼...)的确，对于这方面的问题是不好说清楚，
读了许多的贴子之后开始产生了一个很小的问题，也在前面提到过，
就是对象和对象的变量是一个概念还是有什么区别？

to flyingbug(迫切需要锻炼...)你怎么觉得《java Rules中文版》不值啊
我还打算买一本呢？

to：jacktom2004(萧十一郎) 兄弟真把我问住了
一直以来我以为我明白了，其实我根本没明白对于这个问题，参看java虚拟机实现后，现在可给你答复
（顺便回复你关于对象和对象的变量的问题）对于String类型，在java中是个及其特殊的类型
在虚拟机的实现上
在一个类装载的时候，不管是明确还是隐含（主动的初始化过程）
虚拟机首先在堆中为对象的实例变量分配内存
所有对象中和它超类中的变量都要分配内存并在类的变量池中对栈中的符号引用进行解析
解析成堆内存中实际地址的指针（也就是把内存地址和符号名称一一对上号）
解析阶段是类连接的最后阶段，也是最重要的连接阶段
目的就是为了把符号引用替换成直接引用
而这些符号引用就是在栈中的变量地址下面说到重点了：
对于String变量
也和其他变量一样进行这样的初始化过程
然后在常量池中进行转换
但不同的是java虚拟机针对String类型在内存中单独有一个符号引用到直接引用（指针）的对应表，这个表是全局的
这个表对所有在虚拟机中出现过的String对象保留他们的引用转换
以后，再生成一个与表中已经保留过的String对象值相同的String实例
那么用String a = "asdf";方法生成的话，栈中的符号引用a指向的是这个全局String表，在这里进行符号引用到指针的转换
如果使用String a = new String("asdf");方法生成的话，那么栈中的符号引用指向的是调用该方法的对象的常量池，在那里进行符号引用到指针的转换而使用String.intern()方法则可以将一个String类的保存到这个全局String表中
如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址
如果在表中没有相同值的字符串，则将自己的地址注册到表中下面的程序解释了我上面所说的话： String a = new String("asdf");
String b = new String("asdf");
String f = "asdf";
System.out.println(b == a);
System.out.println(f == a);
a = a.intern();
System.out.println(b == a);
System.out.println(f == a);
b = b.intern();
System.out.println(b == a);返回为：
false
false
false
true
true

to：jacktom2004(萧十一郎) 对于《java Rules中文版》这本书
作者是个很有技术功底的人，但是他在说jdk作者的不足之处的时候
（严格的说，他那是讽刺）
自己也在不停的犯错误，译者已经替他做了不少注释
可是还是能看到很多逻辑上和代码上的前后不搭
看起来挺搞笑的而内容嘛，看《深入java虚拟机》和《java编程思想》也可以了
主要是我先买的这两本书，所以觉得买它不值

我上面说的内容，可参看《深入java虚拟机》第5、6、7、8章

★
★
★
★
★
★
★
呵呵，有些人真是废物
区别自己都不清楚就来胡言。String a=new String(); 以及 String a=new String("1")到底有啥区别？：：：：：
这二个的区别比较小，首先编译器搞定一个String类型对象的引用，这个引用指向哪是个未知（类似指针），然后编译器再在堆中搞定一个String类型的对象，这时候，如果为这种形式：String a=new String(); 就将a这个对象的引用指向一个在堆中内容为空的String类型对象，而这种形式：String a=new String("1")就好理解了，就将a这个对象的引用指向一个在堆中内容为"1"的String类型对象。String a="1"; 和 String a=new String(); 以及 String a=new String("1")到底有啥区别？谢谢
第一个和二，三的区别可大了，在think in java第二版中，72页明确指出:String a="1"这种形式是一种“automatic”变量，不再是reference的形式，意思即在栈中分配空间，这样做的目的为效率的问题，以a这个变量直接存放数据值。★
★
★
★
★
★
★

to:ghyghost(爱国人士--N年后,是否还残存一条▼~~~~) 回帖就回帖，还搞人身攻击？真让人鄙视
而且最牛鼻的是两点都说错，真佩服～！！第一点：“首先编译器搞定一个String类型对象的引用，这个引用指向哪是个未知”
我考，你的笑话真好笑啊～！“这个引用指向哪是个未知”？？？
我建议你回学校再好好学学吧第二点：“意思即在栈中分配空间”
你以为你说的对吗？String a="1"在栈中分配空间？
知道java的栈一个位置字长是多少吗？知道一个对象占用多少空间吗？
知道一个对象从哪里开始创建吗？
如果String在栈中分配空间，它的超类在哪初始化的？如果在栈中分配空间，我想问问你堆中如何获得栈中该对象的引用呢？

越来越糊涂了，啥是“automatic”变量
引用和对象是两个意思么
String s = new String();
是既生成了一个对象叫“s”，又生成了一个引用叫 “s”是吧？

另外：
to:ghyghost(爱国人士--N年后,是否还残存一条▼~~~~) 在嘲笑别人之前拜托你先仔细看看书
在think in java第二版中，72页中根本没有指出String a="1";这种变量的分配方式
所谓“automatic”变量指的是基本型别我劝你好好复习一下java的类体系结构
搞清楚什么是基础型别，什么是wrapper类

那String s = "abc"; 就是基本类型啊？
谁能给俺指一条明路啊，
郁闷～～～

String a="1"; 将a指向String常量池中的"1"对象(如果不存在，创建它）
String a=new String();创建一个空的String对象 a为null
String a=new String("1") 创建一个新的String对象(不从常量池中取),a获得该对象的引用

上面回复了那么多咋还不明白。String s = "abc";s是object，class是String。^_^

String不是基本数据类型
无论在java中还是C++中都不是

TO flyingbug(Effective Refactoring) 关于第一个问题：
　　第一点：“首先编译器搞定一个String类型对象的引用，这个引用指向哪是个未知”
　　建议你学习一下编译原理，关于编译器的内部编译情况我还是有了解的，建议你看一下清华大学的编译原理，为研二的课程。关于未知？？为什么是未知？？你知道不？？告诉你：调用此过程时就会调整栈指针，编译器先搞定引用，然后再搞定对象，你明白我的话不？在对象没有创建时，引用就是一个未知。真是不知道你反驳的理由在哪里!!~~~~~~~~~~~~~!!!
　　第二点解答各有所好，拿出底层东西再讨论

to:ghyghost(爱国人士--N年后,是否还残存一条▼~~~~) 呵呵,你又来了
不但没回答我的问题,连自己说的话都前后矛盾
我很想知道你看过编译原理的书没有
清华的那本我承认我没看过，我不知道那上面是不是这么说的
我在北大考研那会儿用的是Alfred V. Aho等人的那本厚书，机工翻译出版的
不知道你看过没有？？呵呵，我劝你不要总说那本书上说过什么来唬人了
不要以为别人都没看过，这些底层的东西，我看过的怕比你见过的都多
上次《java编程思想》2e已经露过怯如果你有具体的理论根据，就把它阐述明白
否则还是回家补补知识吧另外：第二个问题不是各有所好的问题
它能直接指出在栈中空间无法压入String对象
你真的看懂了吗？？我回答你的问题
是因为看不惯你上来说些错误的知识还叫别人废物
没想到你越说越离谱

to：xylll(逍遥鸟)呵呵，抱歉让一个很好的技术帖子变成了磨牙贴
我只是看不惯ghyghost宣扬错误的东西还人身攻击关于String的问题，如果你愿意搞清楚
我愿另开帖子请大伙讨论

TO flyingbug(Effective Refactoring)
呵呵，第一个问题你搞清楚了吧，记住，以后涉及细节方面的东西不肯定时不要反驳，搞得让我笑话，，哈哈　第二个问题，我是看了think in java了解到的，至于你的“说服”的理由真是不知道哪本书的理论，我喜欢讨论问题直指书名，而不是搞了N年的程序在脑子里把自己认为的东西拿出来给大家玩玩，哈哈，经验，这时拿出来就是错误的。　另外，你提的那本书我没有看，翻译的理论书籍我从来不看，哈哈，如果你对第二个问题有什么书籍做参考的话，给我一个详细的理论，我才信服，不然别说我对你的印象是：哗众取宠。
　
　哈哈哈哈。

-------------------------------------------------------
这个在Java里是有根本的区别的，学Java的一定要搞清楚，要不然以
后麻烦大了
String int char等是Java的primitive(原始类型) 会自动分配内存空间
会自动初始化(initiazation)
如你定义了
int a;
那么a会自动initiazation为0
所以String a="1"; 和 String a=new String(); 以及 String a=new String("1")
在结果上是一样的但是如果不是primitive类型，而是Wrapper类型，如你自己定义的类MyClass
那你写MyClass a="ssssss"时就错了，会得到错误
应该是Myclass a;a = new Myclass;
或
Myclass a=new Myclass();

调试易

String a="1"; 和 String a=new String(); 以及 String a=new String("1")到底有啥区别？谢谢

解决方案 »