(完整版)java练习题(含答案).pdf

《(完整版)java练习题(含答案).pdf》由会员分享，可在线阅读，更多相关《(完整版)java练习题(含答案).pdf（20页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、1.编写程序，用数组实现乘法小九九的存储和输出。【提示：采用多个一维数组。】publicpublic classclass Multipation publicpublic staticstatic voidvoid main(String args)/TODOTODO Auto-generated method stubintint x=newnew intint99;forfor(intint i=0;i9;i+)forfor(intint j=0;j=j)intint m=i+1;intint n=j+1;xij=m*n;System.out.print(m+*+n+=+xij);Sys

2、tem.out.println();2.定义一个类 Student，属性为学号、姓名和成绩；方法为增加记录 SetRecord 和得到记录GetRecord。SetRecord 给出学号、姓名和成绩的赋值，GetRecord 通过学号得到考生的成绩。publicpublic classclass Student/*paramparam args*/privateprivate intint ID;privateprivate String name;privateprivate floatfloat score;publicpublic voidvoid SetRecord(intint ID

3、,String name,floatfloat score)publicpublic floatfloat getRecord(intint ID)ifif(ID=thisthis.ID)returnreturn thisthis.score;elseelsereturnreturn-1;/TODOTODO Auto-generated method stubStudent s=newnew Student();s.SetRecord(0,alex,100);floatfloat Sco=s.getRecord(0);System.out.print(Sco);thisthis.ID=ID;t

4、histhis.name=name;thisthis.score=score;publicpublic staticstatic voidvoid main(String args)3.给出上题中设计类的构造函数，要求初始化一条记录(学号、姓名、成绩)。4.publicpublic classclass Student 5.6./*7.*paramparam args8.*/9.privateprivate intint ID;10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.

5、publicpublic staticstatic voidvoid main(String args)/TODOTODO Auto-generated method stubStudent s=newnew Student(0,sdfs,12);/s.SetRecord(0,alex,100);floatfloat Sco=s.getRecord(0);System.out.print(Sco);privateprivate String name;privateprivate floatfloat score;Student(intint ID,String name,floatfloat

6、 score)publicpublic voidvoid SetRecord(intint ID,String name,floatfloat score)publicpublic floatfloat getRecord(intint ID)ifif(ID=thisthis.ID)returnreturn thisthis.score;elseelsereturnreturn-1;thisthis.ID=ID;thisthis.name=name;thisthis.score=score;thisthis.ID=0;thisthis.name=666;thisthis.score=65;4.

7、编写程序，测试字符串“你好，欢迎来到 Java 世界”的长度，将字符串的长度转换成字符串进行输出，并对其中的“Java”四个字母进行截取，输出截取字母以及它在字符串中的位置。publicpublic classclass StringTest/*paramparam args*/publicpublic staticstatic voidvoid main(String args)/TODOTODO Auto-generated method stubString str=你好，欢迎来到Java世界;intint length=str.length();charchar stringArr=s

8、tr.toCharArray();/System.out.print(stringArr);forfor(intint i=0;ilength;i+)/System.out.print(stringArri);/System.out.print(stringArr0);ifif(J=stringArri)System.out.print(i);1.自己设计一个坐标类，能提供以下方法如求当前坐标和其他坐标之间的距离等方法，要求所有变量为私有变量，并提供两个构造函数。publicpublic classclass XYdistance publicpublic intint getY()publi

9、cpublic staticstatic voidvoid main(String args)/TODOTODO Auto-generated method stubXYdistance m_1=newnew XYdistance();m_1.setX(10);m_1.setY(10);XYdistance m_2=newnew XYdistance();doubledoublereturnreturn y;publicpublic voidvoid setY(intint y)thisthis.y=y;publicpublic intint getX()returnreturn x;priv

10、ateprivate intint x;privateprivate intint y;XYdistance()publicpublic voidvoid setX(intint x)thisthis.x=x;setX(0);setY(0);distance=(m_1.getX()-m_2.getX()*(m_1.getX()-m_2.getX()+(m_1.getY()-m_2.getY()*(m_1.getY()-m_2.getY();doubledouble result=Math.sqrt(distance);System.out.println(result);编写使用静态变量统计一

11、个类产生的实例对象的个数的程序？publicpublic classclass Static privateprivate staticstatic intint number;publicpublic Static()/number=number+1;+number;/System.out.println(+number);publicpublic staticstatic voidvoid main(String args)/TODOTODO Auto-generated method stubnewnew Static();/m_1.Static();System.out.println

12、(Static.number);创建 string 对象过程的内存分配：常量池常量池（ConstantConstant PoolPool）：指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。JVM 虚拟机为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（String,Integer 和Floating point 常量）和对其他类型，字段和方法的符号引用。对于 String 常量，它的值是在常量池中的。而 JVM 中的常量池在内存当中是以表的形式存在的，对于 String 类型，有一张固定长度的 CONSTANT_String_inf

13、o 表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。1 1、String s=abc;String s=abc;创建过程分析创建过程分析：在 class 文件被 JVM 装载到内存中，JVM 会创建一块 String Pool（String 缓冲池）。当执行 String s=“abc”;时，JVM 首先在 String Pool中查看是否存在字符串对象“abc”（如何查看呢？用 equals()方法判断），如果已存在该对象，则不用创建新的字符串对象“abc”，而直接使用 String Pool中已存在的对象“abc”，然后将引用 s 指向该对象；如果不存在该对象，则先在

14、 String Pool 中创建一个新的字符串对象“abc”，然后将引用 s 指向 StringPool 中创建的新对象。注意：使用“字符串常量”引号创建的字符串对象时，在编译期就已经确定将注意：使用“字符串常量”引号创建的字符串对象时，在编译期就已经确定将该对象存储到该对象存储到 String PoolString Pool 中了。因此，String s=“abc”只会在编译期，中了。因此，String s=“abc”只会在编译期，在在 String PoolString Pool 中创建一个对象。中创建一个对象。例如：Java 代码1.Strings1=abc;2.Strings2=abc

15、;3.System.out.println(s1=s2);/true结果说明结果说明：JVM 创建了两个引用 str1 和 str2，但在 String Pool 中只创建了一个对象，而且两个引用都指向了同一个对象。2 2、String s=new String(abc);String s=new String(abc);创建过程分析创建过程分析：当执行String s=new String(“abc”);时，JVM 首先在 StringPool 中查看是否存在字符串对象“abc”，如果不存在该对象，则先在 StringPool 中创建一个新的字符串对象“abc”，然后执行 new Strin

16、g(“abc”)构造方法，在Heap里又创建一个新的字符串对象“abc”（new出来的对象都放在Heap里面），并将引用 s 指向 Heap 中创建的新对象；如果已存在该对象，则不用创建新的字符串对象“abc”，而直接使用 String Pool 中已存在的对象“abc”，然后执行 new String(“abc”)构造方法，在 Heap 里又创建一个新的字符串对象“abc”，并将引用 s 指向 Heap 中创建的新对象。注意：使用注意：使用 new Stringnew String（“”）创建的字符串对象时，会在运行期创建新对象（“”）创建的字符串对象时，会在运行期创建新对象存储到存储到 H

17、eapHeap 中。因此，中。因此，new Stringnew String（“abc”）创建字符串对象时，会创建（“abc”）创建字符串对象时，会创建 2 2个对象，编译期在个对象，编译期在 String PoolString Pool 中创建一个，运行时中创建一个，运行时 HeapHeap 中创建一个。中创建一个。这里使用了Java 代码1.publicString(Stringoriginal)这个构造方法，作用：初始化一个新创建的作用：初始化一个新创建的 StringString 对象，使其表示一个与参数对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副

18、本。相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。由于 Sring 类是不可变的，因而不必使用该构造方法，除非需要 original 的显式副本。例如：Java 代码1.Strings1=newString(abc);2.Strings2=newString(abc);3.System.out.println(s1=s2);/false结果说明结果说明：只要是用 new()来新建对象的，都会在堆（Heap）中创建，而且其字符串是单独存值的，即使与 String Pool中的数据相同，也不会与 String Pool中的数据共享。例程 1：Java 代码1.Strings1=ab

19、cdef;2.Strings2=abcdef;3.Strings3=abc+def;/编译期自动优化为Strings3=abcdef;4.System.out.println(s1=s2);5.System.out.println(s1=s3);6.System.out.println(s2=s3);运行结果：truetruetrue结果说明结果说明：字符串常量生成的字符串对象在String Pool 中只有一个拷贝，且它是在编译期就被确定了，所以“s1=s2”；“abc”和“def”都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己也肯定是字符串常量（它在编译期就被解析为一个字符

20、串对象了，即 class 文件中就已经存在“abcdef”），所以在字符串生成字符串对象时，s3 也是 String Pool 中“abcdef”的一个引用。故 JVM 对于字符串常量的+号连接，在程序编译期，JVM 就将常量字符串的+连接优化为连接后的值。例程 2：Java 代码1.Strings1=abc;2.Strings2=def;3.Strings3=abcdef;4.Strings4=abc+def;5.Strings5=s1+def;6.Strings6=abc+s2;7.Strings7=s1+s2;8.System.out.println(s3=s4);9.System.ou

21、t.println(s3=s5);10.System.out.println(s3=s6);11.System.out.println(s3=s7);运行结果如下：truefalsefalsefalse结果说明：JVM 对于有字符串引用存在的字符串+连接中，而引用的值在程序编译期是无法确定的，即 s1+“def”无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给 s5。例程 3：Java 代码1.finalStrings1=abc;2.Strings2=def;3.Strings3=abcdef;4.Strings4=abc+def;5.Strings5=s1+def;6.St

22、rings6=abc+s2;7.Strings7=s1+s2;8.System.out.println(s3=s4);9.System.out.println(s3=s5);10.System.out.println(s3=s6);11.System.out.println(s3=s7);运行结果如下：truetruefalsefalse例程 4：Java 代码1.finalStrings1=abc;2.finalStrings2=def;3.Strings3=abcdef;4.Strings4=abc+def;5.Strings5=s1+def;6.Strings6=abc+s2;7.Str

23、ings7=s1+s2;8.System.out.println(s3=s4);9.System.out.println(s3=s5);10.System.out.println(s3=s6);11.System.out.println(s3=s7);运行结果如下：truetruetruetrue结果说明：例程 3 和例程 4 与例程 2 的区别是，例程 3 在字符串 s1 前加了 final修饰，例程 4 在字符串 s1 和 s2 前都加了 final 修饰。对于 final 修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的 s1+“d

24、ef”和abc+def效果是一样的。接着后面两个含引用的字符串连接，JVM 会进行相同的处理。故上面程序后面三个的结果为 true。例程 5：Java 代码1.public2.3.4.5.staticvoidmain(Stringargs)Strings1=abc;finalStrings2=getDef();Strings3=abcdef;Strings4=abc+s2;6.Strings5=s1+s2;7.System.out.println(s3=s4);8.System.out.println(s3=s5);9.Java 代码1.privatestaticStringgetDef()2

25、.returndef;3.程序运行结果如下：falsefalse结果说明：JVM 对于方法调用给字符串引用赋值的情况，引用指向字符串的值在编译期是无法确定的，只有在程序运行调用方法后，将方法的返回值“def”和“abc”动态连接并分配新地址赋值给 s4，所以上述程序的结果都为 false。通过以上的例子可知：Java 代码1.Strings=a+b+c;等价于：Java 代码1.Strings=abc;编译期，直接优化，进行常量连接。对于：Java 代码1.String2.String3.String4.Stringabcs=a;b;c;a+b+c;就不等价于：等价于：Java 代码1.Str

26、ings=abc;最终结果等于：Java 代码1.StringBuilderbuilder=newStringBuilder();2.builder.append(a);3.builder.append(b);4.builder.append(c);5.Strings=builder.toString();去看 StringBuilder 的 toString()方法：Java 代码1.publicStringtoString()2./Createacopy,dontsharethearray3.returnnewString(value,0,count);4.可以发现是通过 new Stri

27、ng(.)返回了一个 String 对象，也就是说在堆中创建了对象。这时候会不会在池中出现abc这个对象呢？（question 还没解决）生成 String s 的过程中，编译器使用 sb 执行的过程：创建一个 StringBuffer对象，使用append()向此 StringBuffer 对象直接添加新的字符串（而不是每次制作一个新的副本）。对于对于 String c=c;String s=a+b+c;String c=c;String s=a+b+c;，编译器将会先将，编译器将会先将a+ba+b作为编译时常量，优化生成成字面常量作为编译时常量，优化生成成字面常量abab，然后生成一个，然

28、后生成一个 StringBuilderStringBuilder 对对象，接着调用两次象，接着调用两次 append()append()方法，即方法，即:String s=new Builder().append(ab).append(c).toString();String s=new Builder().append(ab).append(c).toString();对于对于 String a=a;String s=a+b+c;String a=a;String s=a+b+c;，编译器分析，编译器分析 a a 为引用变量，为引用变量，后面的后面的b+cb+c就不会作为编译时常量来运算了。

29、相当于执行：就不会作为编译时常量来运算了。相当于执行：StringString s s=newnew Builder().append(a).append(b)Builder().append(a).append(b).append(c).append(c).toString();.toString();对于对于 String b=b;String s=a+b+c;String b=b;String s=a+b+c;，这种形式的就没办法优化，这种形式的就没办法优化了，直接生成了，直接生成 StringBuilderStringBuilder 对象，然后调用三次对象，然后调用三次 append(

30、)append()方法，即：方法，即：StringString s s=newnew Builder().append(a).append(b)Builder().append(a).append(b).append(c).append(c).toString();.toString();接着，我们再看以下代码：Java 代码1.Stringstr1=abc;/是字符串常量，它在编译期被确定，放在常量池中（共享内容值）2./newString()创建的字符串不放入常量池中3.Stringstr2=newString(abc);/不是字符串常量，不在编译期确定（不共享内容值）Java 代码1.S

31、tringstr1=newString(abc);2.Stringstr2=abc;3.System.out.println(str1=str2);/false创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。Java 代码1.Stringstr1=abc;2.Stringstr2=newString(abc);3.System.out.println(str1=str2);/false创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。接下

32、来我们再来看看 intern()方法，它的定义如下：Java 代码1.publicnativeStringintern();这是一个本地方法。在调用这个方法时，这是一个本地方法。在调用这个方法时，JAVAJAVA 虚拟机首先检查虚拟机首先检查 String PoolString Pool 中中是否已经存在与该对象值相等对象存在，如果有则返回字符串池中对象的引用；是否已经存在与该对象值相等对象存在，如果有则返回字符串池中对象的引用；如果没有，则先在如果没有，则先在 String PoolString Pool 中创建一个相同值的中创建一个相同值的 StringString 对象，然后再将它对象，

33、然后再将它的引用返回。的引用返回。例程 6：Java 代码1.public2.3.4.5.6.classTestStringpublicstaticvoidmain(Stringargs)Strings1=newString(abc);/语句 1Strings2=abc;/语句 2Strings3=newString(abc);/语句 37.8.System.out.println(s1=s2);/语句 49.System.out.println(s1=s3);/语句 510.System.out.println(s2=s3);/语句 611.12.System.out.println(s1=

34、s1.intern();/语句713.System.out.println(s2=s2.intern();/语句814.System.out.println(s1.intern()=s2.intern();/语句 915.16.Stringhello=hello;/语句 1017.Stringhel=hel;/语句 1118.Stringlo=lo;/语句 1219.20.System.out.println(hello=hello);/语句1321.System.out.println(hello=hel+lo);/语句 1422.System.out.println(hello=hel+l

35、o);/语句 1523.System.out.println(hello=hel+lo);/语句 1624.25.问题问题 1 1：当执行完语句：当执行完语句(1)(1)时，在内存里面生成几个对象时，在内存里面生成几个对象?它们是什么它们是什么?在什么地在什么地方方?当执行完语句(1)时，在内存里面创建了两个对象，它们的内容分别都是 abc，分别在 String Pool(常量池)和 Heap(堆)里。其字符串的创建过程如下：首先在String Pool 里面查找查找是否有 abc，如果有就直接使用，但这是本程序的第一条语句，故不存在一个对象abc，所以要在 String Pool 中生成一个

36、对象abc，接下来，执行 new String(abc)构造方法，new 出来的对象都放在 Heap里面。在 Heap 里又创建了一个abc的对象。这时内存里就有两个对象了，一个在 String Pool 里面，一个在 Heap 里面。问题问题 2 2：当执行完语句：当执行完语句(2)(2)时，在内存里面一共有几个对象时，在内存里面一共有几个对象?它们是什么它们是什么?在什么在什么地方地方?当执行完语句(2)时，在内存里面一个对象也没有创建。当我们定义语句(2)的时候，如果我们用字符串的常量值(字面值)给 s2 赋值的话，那么首先 JVM 还是从String Pool 里面去查找有没有内容为

37、abc 的这样一个对象存在，我们发现当我们执行完语句(1)的时候，StringPool 里面已经存在了内容为 abc 的对象，那么就不会再在 String Pool 里面去生成内容为 abc 的字符串对象了。而是会使用已经存在 String Pool 里面的内容为 abc 的字符串对象，并且会将 s2 这个引用指向 String Pool 里面的内容为 abc 的字符串对象，s2 存放的是 String Pool 里面的内容为 abc 的字符串对像的地址。也就是说当你使用 String s2=abc，即使用字符串常量(abc)给定义的引用(str2)赋值的话，那么它首先是在String Poo

38、l 里面去找有没有内容为 abc 的字符串对象存在，如果有的话，就不用创建新的对象，直接引用 String Pool 里面已经存在的对象；如果没有的话，就在 String Pool 里面去创建一个新的对象，接着将引用指向这个新创建的对象。所以，当执行完语句(2)时内存里面一共有 2 个对象，它们的内容分别都是abc，在 String Pool 里面一个内容 abc 的对象，在 Heap 里面有一个内容为 abc的对象。问题问题 3 3：当执行完语句：当执行完语句(3)(3)时，在内存里面一共有几个对象时，在内存里面一共有几个对象?它们是什么它们是什么?在什么在什么地方地方?当执行完语句(3)时

39、，其执行过程是这样的：它首先在 String Pool 里面去查找有没有内容为 abc 的字符串对象存在，发现有这个对象存在，它就不去创建 一个新的对象。接着执行 new.，只要在java 里面有关键字 new 存在，不管内容是否相同，都表示它将生成一个新的对象，new 多少次，就生成多少个对象，而且新生成的对象都是在 Heap 里面，所以它会在 Heap 里面生成一个内容为 abc的对象，并且将它的地址赋给了引用 s3，s3 就指向刚在 Heap 里面生成的内容为abc 的对象。所以，当执行完语句(3)时，内存里面一共有 3 个对象，其中包含了在 String Pool 里面一个内容为 ab

40、c 的字符串对象和在 Heap 里面包含了两个内容为 abc 的字符串对象。问题问题 4 4：当执行完语句：当执行完语句(4)(5)(6)(4)(5)(6)后，它们的结果分别是什么后，它们的结果分别是什么?在 java 里面，对象用=永远比较的是两个对象的内存地址，换句话说，是比较=左右两边的两个引用是否指向同一个对象。对于 java 里面的 8 种原生数据类型来说，=比较的是它们的字面值是不是一样的；对应用类型来说，比较的是它们的内存地址是不是一样的。在语句(1)(2)(3)中，由于s1、s2、s3 指向不同的对象，它们的内存地址就不一样，因此可以说当执行完语句(4)(5)(6),它们返回的

41、结果都是 false。问题问题 5 5：当执行完语句：当执行完语句(7)(8)(9)(7)(8)(9)后，它们的结果分别是什么后，它们的结果分别是什么?首先，s1 这个对象指向的是堆中第一次 new.生成的对象，当调用 intern 方法时，如果 String Pool 已经包含一个等于此 String 对象的字符串(该对象由equals(Object)方法确定），则返回指向 String Pool 中的字符串对象的引用。因为 String Pool 中有内容为 abc 的对象，所以 s1.intern()返回的是 StringPool 中的内容为 abc 的字符串对象的内存地址，而 s1 却

42、是指向 Heap 上内容为abc 的字符串对象的引用。因而，两个引用指向的对象不同，所以，s1=s1.intern()为 false，即语句(7)结果为 false。对于 s2.intern()，它还是会首先检查 String Pool 中是否有内容为 abc 的对象，发现有，则将 String Pool 中内容为 abc 的对象的地址赋给 s2.intern()方法的返回值。因为 s2 和 s2.intern()方法的返回值指向的是同一个对象，所以，s2=s2.intern()的结果为 true,，即语句(8)结果为 true。对于 s1.intern()，它首先检查 String Pool

43、 中是否有内容为 abc 的对象，发现有，则将 String Pool 中内容为 abc 的对象的赋给 s1.intern()方法的返回值。对于 s2.intern(),首先检查 String Pool 中是否有内容为 abc 的对象，发现有，则将 String Pool 中内容为 abc 的对象的地址赋给 s2.intern()方法的返回值。因为两者返回的地址都指向同一个对象，所以，s1.intern()=s2.intern()的结果为 true,，即是语句(9)结果为 true。因此，当执行完语句(7)(8)(9)后，它们的结果分别是 false、true、true。问题问题 6 6：当执

44、行完语句：当执行完语句(13)(14)(15)(16)(13)(14)(15)(16)后，它们的结果分别是什么后，它们的结果分别是什么?hello=hello引用 hello 指向的对象就是 String Pool 中的“hello”，即语句(13)的结果为 true。hello=hel+lo当加号两边都是常量值时，就会组成一个新的常量值hello在 String Pool 里面，如果 String Pool 已经有相同内容的就不会再创建，则直接返回 String Pool 里面的内容为hello的字符串对象的内存地址，所以，hello=hel+lo结果为 true。hello=hel+lo

45、当加号两边有一个不是常量值，会在堆里面创建一个新的hello对象，一个在 String Pool 中，一个在 Heap 中，故输出 false。hel+lo 同上，输出 false。因此，当执行完语句(7)(8)(9)后，它们的结果分别是 true、true、false、false。例程 7：Java 代码1.Strings1=abc;2.Strings2=newString(abc);3.Strings3=newString(abc);4.s2.intern();/虽然执行了 s2.intern(),但它的返回值没有赋给s25.s3=s3.intern();/把 StringPool 中“a

46、bc”的引用赋给 s36.System.out.println(s1=s2);7.System.out.println(s1=s2.intern();8.System.out.println(s1=s3);运行结果如下：falsetruetrue结果说明结果说明：因为 s2.intern()只是执行了，而没有把 String Pool 中的“abc”的地址赋给 s2，所以 s1 还是指向 String Pool 中的“abc”，s2 则指向 Heap中的“abc”，对于 s1=s2，返回值为 false；对于 s1=s2.intern()，其中 s2.intern()的返回值为指向 Strin

47、g Pool 中“abc”的地址，故 s2.intern()与 s1 指向同一个对象，因而返回 true；因为 s3=s3.intern()把 String Pool中的“abc”的地址赋给了 s3，此时 s1 和 s3 指向的是同一对象，即 String Pool中的“abc“，因而返回 true。例程 8：Java 代码1.Strings1=abc;2.Strings2=newString(abc);3.Strings3=a+newString(bc);4.System.out.println(s1=s2);5.System.out.println(s1=s3);6.System.out.

48、println(s2=s3);运行结果如下：falsefalsefalse结果说明结果说明：s1 指向 String Pool 中的字符串对象“abc”，编译期确定；s2 指向 Heap 中的字符串对象“abc”，运行期确定；s3 指向 Heap 中的另一个字符串对象“abc”，运行期确定。注意：String s3=a+new String(bc);等价于String s3=new StringBuilder().append(a).append(newString(bc).toString();思考思考：String s=a+new String(b)+c;产生了那几个对象？解：等价于 St

49、ring s=new StringBuilder().append(a).append(newString(b).append(c).toString()，会在 String Pool 中产生a、b、c三个对象，在 Heap 中产生b、abc两个个对象。一共 5 个字符串对象。例程 9：Java 代码1.Strings1=Hello;2.s1=Java;3.Strings2=Hello;4.Strings3=newString(Hello);5.System.out.println(s1=s2);6.System.out.println(s2=s3);运行结果如下：falsefalse分析这段

50、程序的执行过程分析这段程序的执行过程：首先在加载 Java 程序时，JVM 会创建一片的内存空间（String Pool）专门存入string 对象。String s1=Hello，现在栈中创建一个字符串引用 s1，然后 JVM 会在 StringPool 中查找是否存在Hello，如果存在，则直接使用它，将其地址赋给s1，如果不存在（这时 String Pool 中显然不存在Hello），则在 String Pool 中创建Hello，并将其地址赋给 s1。s1=Java，JVM 会在 String Pool 中查找是否存在Java，如果存在，则直接使用它，将其地址赋给 s1，如果不存在（这