java练习题(含答案)

1、精选文档1. 编写程序，用数组实现乘法小九九的存储和输出。【提示：接受多个一维数组。】 public class Multipation public static void main(String args) / TODO Auto-generated method stubint x=new int99;for(int i=0;i<9;i+)for(int j=0;j<9;j+)if(i>=j)int m=i+1;int n=j+1; xij=m*n;System.out.print(m+"*"+n+"="+xij);System.

2、out.println();2. 定义一个类Student，属性为学号、姓名和成果；方法为增加记录SetRecord和得到记录GetRecord。SetRecord给出学号、姓名和成果的赋值，GetRecord通过学号得到考生的成果。public class Student /* * param args */private int ID;private String name;private float score;public void SetRecord(int ID,String name,float score)this.ID=ID;=name;this.score

3、=score;public float getRecord(int ID)if(ID=this.ID)return this.score;elsereturn -1;public static void main(String args) / TODO Auto-generated method stubStudent s=new Student();s.SetRecord(0,"alex",100);float Sco=s.getRecord(0);System.out.print(Sco);3. 给出上题中设计类的构造函数，要求初始化一条记录(学号、姓名、成果)。4.

4、public class Student 5.6. /*7. * param args8. */9. private int ID;10. private String name;11. private float score;12. 13. Student(int ID,String name,float score)14. this.ID=0;15. ="666"16. this.score=65;17. 18. public void SetRecord(int ID,String name,float score)19. this.ID=ID;20

5、. =name;21. this.score=score;22. 23. public float getRecord(int ID)24. if(ID=this.ID)25. return this.score;26. else27. return -1;28. 29.30. public static void main(String args) 31. / TODO Auto-generated method stub32. Student s=new Student(0,"sdfs",12);33. /s.SetRecord(0,"ale

6、x",100);34. float Sco=s.getRecord(0);35. System.out.print(Sco);36. 37. 4. 编写程序，测试字符串“你好，欢迎来到Java世界”的长度，将字符串的长度转换成字符串进行输出，并对其中的“Java”四个字母进行截取，输出截取字母以及它在字符串中的位置。public class StringTest /* * param args */public static void main(String args) / TODO Auto-generated method stubString str="你好，欢迎来到

7、Java世界"int length=str.length();char stringArr = str.toCharArray(); /System.out.print(stringArr);for(int i=0;i<length;i+)/System.out.print(stringArri);/System.out.print(stringArr0);if('J'=stringArri)System.out.print(i);1. 自己设计一个坐标类，能供应以下方法如求当前坐标和其他坐标之间的距离等方法，要求全部变量为私有变量，并供应两个构造函数。publ

8、ic class XYdistance private int x;private int y;XYdistance()setX(0);setY(0);public void setX(int x) this.x = x;public int getX() return x;public void setY(int y) this.y = y;public int getY() return y;public static void main(String args) / TODO Auto-generated method stubXYdistance m_1= new XYdistance

9、();m_1.setX(10);m_1.setY(10);XYdistance m_2= new XYdistance();double 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();double result=Math.sqrt(distance);System.out.println(result); 编写使用静态变量统计一个类产生的实例对象的个数的程序？public class Static private static int nu

10、mber;public Static()/number=number+1;+number;/System.out.println(+number);public static void main(String args) / TODO Auto-generated method stubnew Static();/m_1.Static();System.out.println(Static.number);创建string对象过程的内存安排：常量池（Constant Pool）：指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。JVM虚拟机为每个被装载的类型维护一个常量池。

11、常量池就是该类型所用到常量的一个有序集和，包括直接常量（String,Integer和 Floating point常量）和对其他类型，字段和方法的符号引用。对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，留意：该表只存储文字字符串值，不存储符号引用。 1、String s = "abc" 创建过程分析：在class文件被JVM装载到内存中，JVM会创建一块String Pool（String缓冲池）。当执行String s =

12、 “abc”;时，JVM首先在String Pool中查看是否存在字符串对象“abc”（如何查看呢？用equals()方法推断），假如已存在该对象，则不用创建新的字符串对象“abc”，而直接使用String Pool中已存在的对象“abc”，然后将引用s指向该对象；假如不存在该对象，则先在String Pool中创建一个新的字符串对象“abc”，然后将引用s指向String Pool中创建的新对象。 留意：使用“字符串常量”引号创建的字符串对象时，在编译期就已经确定将该对象存储到String Pool中了。因此，String s = “abc”只会在编译期，在String Pool中创建一个对

13、象。 例如： Java代码  1. String s1 = "abc"   2. String s2 = "abc"   3. System.out.println(s1 = s2);/true  String s1 = "abc"String s2 = "abc"System.out.println(s1 = s2);/true结果说明：JVM创建了两个引用str1

14、和str2，但在String Pool中只创建了一个对象，而且两个引用都指向了同一个对象。 2、String s = new String("abc"); 创建过程分析：当执行String s = new String(“abc”);时，JVM首先在String Pool中查看是否存在字符串对象“abc”，假如不存在该对象，则先在String Pool中创建一个新的字符串对象“abc”，然后执行new String(“abc”)构造方法，在Heap里又创建一个新的字符串对象“abc”（new出来的对象都放在Heap里面），并将引用s指向Heap中创建的新对象；假如已存在该对

15、象，则不用创建新的字符串对象“abc”，而直接使用String Pool中已存在的对象“abc”， 然后执行new String(“abc”)构造方法，在Heap里又创建一个新的字符串对象“abc”，并将引用s指向Heap中创建的新对象。 留意：使用new String（“”）创建的字符串对象时，会在运行期创建新对象存储到Heap中。因此，new String（“abc”）创建字符串对象时，会创建2个对象，编译期在String Pool中创建一个，运行时Heap中创建一个。 这里使用了 Java代码  1. public String(String origina

16、l)  public String(String original)这个构造方法，作用：初始化一个新创建的String对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 由于Sring类是不行变的，因而不必使用该构造方法，除非需要original的显式副本。 例如： Java代码  1. String s1 = new String("abc");   2. String s2 = new String(&qu

17、ot;abc");   3. System.out.println(s1 = s2);/false  String s1 = new String("abc");String s2 = new String("abc");System.out.println(s1 = s2);/false结果说明：只要是用new()来新建对象的，都会在堆（Heap）中创建，而且其字符串是单独存值的，即使与String Pool中的数据相同，也不会与String Pool中的数据共享。 例程1： Jav

18、a代码  1. String s1 = "abcdef"   2. String s2 = "abcdef"   3. String s3 = "abc"+"def"/编译期自动优化为String s3 = "abcdef"   4. System.out.println(s1 = s2)

19、;   5. System.out.println(s1 = s3);   6. System.out.println(s2 = s3);  String s1 = "abcdef"String s2 = "abcdef"String s3 = "abc"+"def"/编译期自动优化为String s3 = "abcdef"System.out.println(s1 = s2);System.ou

20、t.println(s1 = s3);System.out.println(s2 = s3);运行结果： true true true 结果说明：字符串常量生成的字符串对象在String Pool中只有一个拷贝，且它是在编译期就被确定了，所以“s1 = s2”；“abc”和“def”都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己也确定是字符串常量（它在编译期就被解析为一个字符串对象了，即class文件中就已经存在“abcdef”），所以在字符串生成字符串对象时，s3也是String Pool中“abcdef”的一个引用。故JVM对于字符串常量的"+"号连接，

21、在程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值。 例程2： Java代码  1. String s1 = "abc"   2. String s2 = "def"   3. String s3 = "abcdef"   4. String s4 = "abc"+"def"

22、  5. String s5 = s1 + "def"   6. String s6 = "abc"+s2;   7. String s7 = s1 + s2;   8. System.out.println(s3 = s4);   9. System.out.println(s3 = s

23、5);   10. System.out.println(s3 = s6);   11. System.out.println(s3 = s7);  String s1 = "abc"String s2 = "def"String s3 = "abcdef"String s4 = "abc"+"def"String s5 = s1 + "def"String s6 = &quo

24、t;abc"+s2;String s7 = s1 + s2;System.out.println(s3 = s4);System.out.println(s3 = s5);System.out.println(s3 = s6);System.out.println(s3 = s7);运行结果如下： true false false false 结果说明：JVM对于有字符串引用存在的字符串"+"连接中，而引用的值在程序编译期是无法确定的，即s1 + “def”无法被编译器优化，只有在程序运行期来动态安排并将连接后的新地址赋给s5。 例程3： Java代码  

25、;1. final String s1 = "abc"   2. String s2 = "def"   3. String s3 = "abcdef"   4. String s4 = "abc"+"def"   5. String s5 = s1 

26、;+ "def"   6. String s6 = "abc"+s2;   7. String s7 = s1 + s2;   8. System.out.println(s3 = s4);   9. System.out.println(s3 = s5);   10. System.out.println(s3 =&

27、#160;s6);   11. System.out.println(s3 = s7);  final String s1 = "abc"String s2 = "def"String s3 = "abcdef"String s4 = "abc"+"def"String s5 = s1 + "def"String s6 = "abc"+s2;String s7 = s1 + s2;System.o

28、ut.println(s3 = s4);System.out.println(s3 = s5);System.out.println(s3 = s6);System.out.println(s3 = s7);运行结果如下： true true false false 例程4： Java代码  1. final String s1 = "abc"   2. final String s2 = "def"   3. String&

29、#160;s3 = "abcdef"   4. String s4 = "abc"+"def"   5. String s5 = s1 + "def"   6. String s6 = "abc"+s2;   7. String s7 = s1 +&

30、#160;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);  final String s1 = "abc"final String s2 = "def&q

31、uot;String s3 = "abcdef"String s4 = "abc"+"def"String s5 = s1 + "def"String s6 = "abc"+s2;String s7 = s1 + s2;System.out.println(s3 = s4);System.out.println(s3 = s5);System.out.println(s3 = s6);System.out.println(s3 = s7);运行结果如下： true true true true

32、结果说明：例程3和例程4与例程2的区分是，例程3在字符串s1前加了final修饰，例程4在字符串s1和s2前都加了final修饰。对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的s1 + “def”和"abc" + "def"效果是一样的。接着后面两个含引用的字符串连接，JVM会进行相同的处理。故上面程序后面三个的结果为true。 例程5： Java代码  1. public static void main(String args)

33、  2.     String s1 = "abc"   3.     final String s2 = getDef();   4.     String s3 = "abcdef"   5.     String&

34、#160;s4 = "abc"+s2;   6.     String s5 = s1 + s2;   7.     System.out.println(s3 = s4);   8.     System.out.println(s3 = s5);   9. 

35、0; public static void main(String args)String s1 = "abc"final String s2 = getDef();String s3 = "abcdef"String s4 = "abc"+s2;String s5 = s1 + s2;System.out.println(s3 = s4);System.out.println(s3 = s5);Java代码  1. private static String getDef()

36、60; 2.     return "def"   3.   private static String getDef()return "def"程序运行结果如下： false false 结果说明：JVM对于方法调用给字符串引用赋值的状况，引用指向字符串的值在编译期是无法确定的，只有在程序运行调用方法后，将方法的返回值“def”和“abc”动态连接并安排新地址赋值给s4，所以上述程序的结果都为false。 通过以上的例子可知： Java代码  

37、1. String s = "a" + "b" + "c"  String s = "a" + "b" + "c"等价于： Java代码  1. String s = "abc"  String s = "abc"编译期，直接优化，进行常量连接。 对于： Java代码  1. S

38、tring a = "a"   2. String b = "b"   3. String c = "c"   4. String s = a + b + c;  String a = "a"String b = "b"String c = "c&q

39、uot;String s = a + b + c;就不等价于：等价于： Java代码  1. String s = "abc"  String s = "abc"最终结果等于： Java代码  1. StringBuilder builder = new StringBuilder ();   2. builder.append(a);   3. builder.append(b);  

40、 4. builder.append(c);   5. String s = builder.toString();  StringBuilder builder = new StringBuilder ();builder.append(a);builder.append(b);builder.append(c);String s = builder.toString();去看StringBuilder的toString()方法： Java代码  1. public String t

41、oString()    2. / Create a copy, don't share the array   3. return new String(value, 0, count);   4.   public String toString() / Create a copy, don't share the arrayreturn new String(value, 0

42、, count);可以发觉是通过new String(.)返回了一个String对象，也就是说在堆中创建了对象。这时候会不会在池中消灭"abc"这个对象呢？（question还没解决） 生成String s的过程中，编译器使用sb执行的过程：创建一个StringBuffer对象，使用append()向此StringBuffer对象直接添加新的字符串（而不是每次制作一个新的副本）。 对于String c = "c"String s = "a" + "b" + c;，编译器将会先将"a" + &qu

43、ot;b"作为编译时常量，优化生成成字面常量"ab" ，然后生成一个StringBuilder对象，接着调用两次 append()方法，即: String s = new Builder().append("ab").append(c) .toString(); 对于String a = "a"String s = a + "b" + "c"，编译器分析a为引用变量，后面的"b" + "c"就不会作为编译时常量来运算了。相当于执行： String

44、 s = new Builder().append(a).append("b") .append("c") .toString(); 对于String b = "b"String s = "a" + b + "c"，这种形式的就没方法优化了，直接生成StringBuilder对象，然后调用三次 append()方法，即： String s = new Builder().append("a").append(b) .append("c") .toStrin

45、g(); 接着，我们再看以下代码： Java代码  1. String str1 = "abc"/是字符串常量，它在编译期被确定，放在常量池中（共享内容值）   2. /new String()创建的字符串不放入常量池中   3. String str2 =new String("abc");/不是字符串常量，不在编译期确定（不共享内容值）  String str1 = "abc"/是字符串常量，

46、它在编译期被确定，放在常量池中（共享内容值）/new String()创建的字符串不放入常量池中String str2 =new String("abc");/不是字符串常量，不在编译期确定（不共享内容值）Java代码  1. String str1 = new String("abc");   2. String str2 = "abc"   3. System.out.println(str1=str2);

47、60; /false  String str1 = new String("abc");String str2 = "abc"System.out.println(str1=str2); /false创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。 Java代码  1. String str1 = "abc"   2. String str2 = new String("abc&q

48、uot;);   3. System.out.println(str1=str2);  /false  String str1 = "abc"String str2 = new String("abc");System.out.println(str1=str2); /false创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。 接下来我们再来看看intern()方法，它的定义如下： Java代码  1. public native String

49、60;intern();   public native String intern(); 这是一个本地方法。在调用这个方法时，JAVA虚拟机首先检查String Pool中是否已经存在与该对象值相等对象存在，假如有则返回字符串池中对象的引用；假如没有，则先在String Pool中创建一个相同值的String对象，然后再将它的引用返回。 例程6： Java代码  1. public class TestString   2.     public static&#

50、160;void main(String args)   3.   4.         String s1 = new String("abc");/语句1   5.         String s2 = "abc"/语句2  

51、0;6.         String s3 = new String("abc");/语句3   7.   8.         System.out.println(s1 = s2);/语句4   9.        

52、0;System.out.println(s1 = s3);/语句5   10.         System.out.println(s2 = s3);/语句6   11.   12.         System.out.println(s1 = ern();/语句7   13. &

53、#160;       System.out.println(s2 = ern();/语句8   14.         System.out.println(ern() = ern();/语句9   15.   16.        

54、0;String hello = "hello"/语句10   17.         String hel = "hel"/语句11   18.         String lo = "lo"/语句12   19.  

55、; 20.         System.out.println(hello = "hello");/语句13   21.         System.out.println(hello = "hel" + "lo");/语句14   22.   

56、      System.out.println(hello = "hel" + lo);/语句15   23.         System.out.println(hello = hel + lo);/语句16   24.        25.  

57、; public class TestStringpublic static void main(String args)String s1 = new String("abc");/语句1String s2 = "abc"/语句2String s3 = new String("abc");/语句3System.out.println(s1 = s2);/语句4System.out.println(s1 = s3);/语句5System.out.println(s2 = s3);/语句6System.out.println(

58、s1 = ern();/语句7System.out.println(s2 = ern();/语句8System.out.println(ern() = ern();/语句9String hello = "hello"/语句10String hel = "hel"/语句11String lo = "lo"/语句12System.out.println(hello = "hello");/语句13System.out.println(hello = "hel&q

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

60、条语句，故不存在一个对象"abc"，所以要在String Pool中生成一个对象"abc"，接下来，执行new String("abc")构造方法，new出来的对象都放在Heap里面。在Heap里又创建了一个"abc"的对象。这时内存里就有两个对象了，一个在String Pool 里面，一个在Heap里面。 问题2：当执行完语句(2)时，在内存里面一共有几个对象?它们是什么?在什么地方? 当执行完语句(2)时，在内存里面一个对象也没有创建。当我们定义语句(2)的时候，假如我们用字符串的常量值(字面值)给s2赋值的话

61、，那么首先JVM还是从String Pool里面去查找有没有内容为abc的这样一个对象存在，我们发觉当我们执行完语句(1)的时候，StringPool里面已经存在了内容为abc的对象，那么就不会再在String Pool里面去生成内容为abc的字符串对象了。而是会使用已经存在String Pool里面的内容为abc的字符串对象，并且会将s2这个引用指向String Pool里面的内容为abc的字符串对象，s2存放的是String Pool里面的内容为abc的字符串对像的地址。也就是说当你使用String s2 = "abc"，即使用字符串常量("abc"

62、)给定义的引用(str2)赋值的话，那么它首先是在String Pool里面去找有没有内容为abc的字符串对象存在，假如有的话，就不用创建新的对象，直接引用String Pool里面已经存在的对象；假如没有的话，就在 String Pool里面去创建一个新的对象，接着将引用指向这个新创建的对象。所以，当执行完语句(2)时内存里面一共有2个对象，它们的内容分别都是abc，在String Pool里面一个内容abc的对象，在Heap里面有一个内容为abc的对象。 问题3：当执行完语句(3)时，在内存里面一共有几个对象?它们是什么?在什么地方? 当执行完语句(3)时，其执行过程是这样的：它首先在St

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

64、完语句(4)(5)(6)后，它们的结果分别是什么? 在java里面，对象用"="永久比较的是两个对象的内存地址，换句话说，是比较"="左右两边的两个引用是否指向同一个对象。对于java里面的8种原生数据类型来说，"="比较的是它们的字面值是不是一样的；对应用类型来说，比较的是它们的内存地址是不是一样的。在语句(1)(2)(3)中，由于s1、s2、s3指向不同的对象，它们的内存地址就不一样，因此可以说当执行完语句(4)(5)(6),它们返回的结果都是false。 问题5：当执行完语句(7)(8)(9)后，它们的结果分别是什么? 首先，s

65、1这个对象指向的是堆中第一次new.生成的对象，当调用 intern 方法时，假如String Pool已经包含一个等于此 String 对象的字符串(该对象由equals(Object)方法确定），则返回指向String Pool中的字符串对象的引用。由于String Pool中有内容为abc的对象，所以ern()返回的是String Pool中的内容为abc的字符串对象的内存地址，而s1却是指向Heap上内容为abc的字符串对象的引用。因而，两个引用指向的对象不同，所以，s1 = ern() 为false，即语句(7)结果为false。 对于ern()，

66、它还是会首先检查String Pool中是否有内容为abc的对象，发觉有，则将String Pool中内容为abc的对象的地址赋给ern()方法的返回值。由于s2和ern()方法的返回值指向的是同一个对象，所以，s2 = ern()的结果为true,，即语句(8)结果为true。 对于ern()，它首先检查String Pool中是否有内容为abc的对象，发觉有，则将String Pool中内容为abc的对象的赋给ern()方法的返回值。对于ern(),首先检查String Pool中是否有内容为abc的对象，发觉有，则将

67、String Pool中内容为abc的对象的地址赋给ern()方法的返回值。由于两者返回的地址都指向同一个对象，所以，ern() = ern()的结果为true,，即是语句(9)结果为true。 因此，当执行完语句(7)(8)(9)后，它们的结果分别是false、true、true。 问题6：当执行完语句(13)(14) (15)(16)后，它们的结果分别是什么? hello = "hello"引用hello指向的对象就是String Pool中的“hello”，即语句(13)的结果为true。 hello = "hel&quo

68、t; + "lo"当加号两边都是常量值时，就会组成一个新的常量值"hello"在String Pool里面，假如String Pool已经有相同内容的就不会再创建，则直接返回String Pool里面的内容为"hello"的字符串对象的内存地址，所以，hello = "hel" + "lo"结果为true。 hello ="hel" + lo 当加号两边有一个不是常量值，会在堆里面创建一个新的"hello"对象，一个在String Pool中，一个在Hea

69、p中，故输出false 。 hel + lo 同上，输出false。 因此，当执行完语句(7)(8)(9)后，它们的结果分别是true、true、false、false。 例程7： Java代码  1. String s1 = "abc"   2. String s2 = new String("abc");   3. String s3 = new String("abc")

70、;   4. ern();/虽然执行了ern(),但它的返回值没有赋给s2   5. s3 = ern();/把String Pool中“abc”的引用赋给s3   6. System.out.println(s1 = s2);   7. System.out.println(s1 = ern();     8. System.out.println(s1&#

71、160;= s3);  String s1 = "abc"String s2 = new String("abc");String s3 = new String("abc");ern();/虽然执行了ern(),但它的返回值没有赋给s2s3 = ern();/把String Pool中“abc”的引用赋给s3System.out.println(s1 = s2);System.out.println(s1 = ern();System.out.printl

72、n(s1 = s3);运行结果如下： false true true 结果说明：由于ern()只是执行了，而没有把String Pool中的“abc”的地址赋给s2，所以s1还是指向String Pool中的“abc”，s2则指向Heap中的“abc”，对于s1 = s2，返回值为false；对于s1 = ern()，其中ern()的返回值为指向String Pool中“abc”的地址，故ern()与s1指向同一个对象，因而返回true；由于s3 = ern()把String Pool中的“abc”的地址赋给了s3，此时s1和s3指向的是同一对象，即String Pool中的“abc“，因而返回true。 例程8： Java代码  1. String s1 = "abc"   2. S