String str1="abc";和String str2=new String("abc");的区别

Java把内存划分成两种：一种是栈内存，一种是堆内存。 在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 m! _: \7 w2 o" V- v 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。 堆内存用来存放由new创建的对象和数组。 # }- F: d* l5 G' R4 u$ R- _4 m7 G 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。 * g8 J6 n4 d8 C+ Z 4 P) j' y4 \1 M) w 在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。 , W* `: o0 T$ d% M+ w6 o- @6 ]9 Z " S7 ]; ^5 i- C5 z& d; a5 X" K 引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。* c. u. Y* u9 Z ) ]4 z- |) L8 f" W5 M! X5 C 5 \7 c+ K0 ~5 N ( z6 l9 C6 K. Z' k2 Q' c具体的说： 0 B7 _; I/ O. h& N, ^% H栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。 # [9 @5 S1 b+ ]& s1 J* \5 k" h$ s Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 : W1 c \& `& S0 s) y: l* |, Z1 c 栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。 , @0 o9 W% y# ^0 @( B 栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义： # w: U3 b; e* m2 Q" C/ y6 ?& Cint a = 3; ; {/ u: A( i) Lint b = 3； * A# E( y+ [6 v1 n2 A/ A- E8 _编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。 ! c( z5 G2 c# U , P" T3 z: c c3 c9 E3 mString是一个特殊的包装类数据。可以用： 8 w& ~5 f! K+ bString str = new String("abc"); $ [: u/ j! [& z5 String str = "abc"; - S$ C0 H z% E' v! h1 i2 j, m 两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。 ) o1 S, O, t$ @ 而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。 ; L% J7 c7 O% C. \* r# C- F8 j- X) q% j6 m & E4 D, [3 p2 F. G' \9 l 比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。 $ h) [( ^5 T3 {. Z; D String str1 = "abc"; 1 q( l2 Q' {7 H) Y String str2 = "abc"; ! B+ u) U4 t- fSystem.out.println(str1==str2); //true ' t' h/ H' X6 r$ G2 u 可以看出str1和str2是指向同一个对象的。 2 o; U& O0 N4 L$ J N* L0 k' C3 t( l" i2 f1 x, @( U String str1 =new String ("abc"); I2 c( s' S r% |) b# p8 RString str2 =new String ("abc"); Z( w) ~2 c9 r* v g$ q! P$ ] System.out.println(str1==str2); // false 0 w: i. u; _ R5 q: E6 O; ?用new的方式是生成不同的对象。每一次生成一个。 ' a8 Q; p; t' Y2 c4 b5 e 因此用第二种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。 1 ]9 ~9 U. O5 ]( q8 [9 r% ^+ G 另一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象。由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。 / g/ X) Q1 T `% D8 h/ a7 p: i7 R====================================================== 4 o( Q* p6 W, i% y练习题：3 k! l- K3 r3 y2 C 以下code生成几个String对象 0 B( @ ]; ^4 h! k$ i! _, h String a="abc";- K0 L ~; P' O. ^ String b="abc"; + f0 P# k9 U0 A. A String c=new String("abc");4 H# f7 [3 E' Y( x h( m G; b$ @* | String d=c.intern();+ {7 G# k9 f g# v- d + u, p4 }$ H q d; q String a="abc"; yes ( W0 K% ]5 O4 _3 d String b="abc"; no& h) M. S+ K6 W String c=new String("abc"); yes 0 t" K. _4 ^- O+ K- T7 } String d=c.intern(); 这句是关键！！ 1 P2 b2 u5 C& R6 b, N* j ; ?& d; O, j6 N" g4 \4 Z) l String c=new String("abc"); & P* p. v" d' Q4 P$ E& g String d=c.intern(); 3 r8 f( ~" q( l3 W; K 如果仅仅是这样 ; R$ l0 O* ^# P; t4 V! V c == d ？ 结果是 false； ; t- Y H# K. N( Y7 ?' w 因为引用变量c指向堆内存的地址；但是intern(); 却在栈中开辟了一块内存。 1 d; ~. A: |! |. N! _ 3 ]& u* a6 u3 ?& _4 a( ~ 对于本题来讲： / ?: O/ E# | b1 f( G( I c.intern(); 执行时，在栈内存中发现存在对象“abc”，所以直接将指针指向“abc”* u# s/ t" h8 ` D 这样 a == d, b==d 结果为true; % ~( M0 [2 d. O - x8 e# R* K% z0 K3 l; T! m 所以这条的答案是2