行业知识
《Java黑皮书基础篇第10版》 第10章【习题】
2026-10-25 19:05:00
来源：互联网转载
Java语言程序设计 习题第十章
10.2章节习题
10.1 如果重新定义程序清单102中的Loan类，去掉其中的设置方法，这个类是不可改变的吗?
这个类依然是可以改变的，因为每一笔贷款作为一个对象，都是可以改变的
10.3章节习题
10.2 程序清单10-4中的BMI类是不可改变的吗？
是的
10.4章节习题
10.3 类之间的常用关系是什么?
关联、聚集和组合
10.4 什么是关联?什么是聚集?什么是组合?
关联是一种表述两个类关系的特性，聚集和组合都是特殊的关联
10.5 聚集和组合的 UML 图标识是什么?
聚集是空心棱形，组合是实心棱形
10.6 为什么聚集和组合都一起被称为组合?
在类中，聚集类和组合类都可以有被聚集类和被组合类的数据域
10.7章节习题
10.7 描述基本类型的包装类。
基本类型的包装类可以将基本类型数据作为对象使用，除了Integer和Character类代表int和char外，大部分的数值包装类都和对应的基本类型数据的名称一致
10.8 下面的每个语句可以编译成功么?
//可以通过编译，调用了Integer类的+Integer(s: String)方法Integer a = new Integer("23");//可以通过编译，调用了Integer类的+Integer(value: int)方法Integer b = new Integer(23);//可以通过编译，调用了Integer类的+valueOf(s: String): Integer方法Integer c = Integer.valueOf("23");//可以通过编译，调用了Integer类的+parseInt(s: String, radix: int): int方法Integer d = Integer.parseInt("23", 8);//无法通过编译，Double类（所有包装类）没有无参构造方法Double e = new Double();//可以通过编译，调用了Double类的+Doub1e(s: String)Double f = Double.valueOf("23.45");//可以通过编译，调用了Integer类的+valueOf(s: String): Integer和+intValue(): int方法int g = (Integer.valueOf("23")).intValue();//可以通过编译，调用了Double类的+valueOf(s: String): Double和+DoubleValue(): double方法double h = (Double.valueOf("23.4")).doubleValue();//可以通过编译，调用了Double类的+valueOf(s: String): Double和+intValue(): int方法int i = (Double.valueOf("23.4")).intValue();可以通过编译，调用了Double类的+valueOf(s: String): Double和+toString() : String方法String j = (Double.valueOf("23.4")).toString(); 10.9 如何将一个整数转换为一个字符串? 如何将一个数值字符串转换为一个整数? 如何将一个double值转换为字符串? 如何将一个数值型字符串转换为double值?
可以用toString方法将int/double转化为字符串
可以用parselnt方法将字符串转化为int/double
10.10 给出下面代码的输出。
public class Test {public static void main(String[]args) {Integer x = new Integer(3);System.out.println(x.intValue());System.out.println(x.compareTo(new Integer(4))); }} 输出结果：
3-1
10.11 下面代码的输出是什么?
public class Test {public static void mai(n String[] args) {System.out.println(Integer.parseInt("10"));System.out.println(Integer.parseInt("10", 10));System.outprintl(nInteg「e parseInt("10", 16));System.out.printl(n Integer.parseInt("11")); System.out.printl(n Integer parseInt("ll", 10));System.out.printl(nInteger.parseInt("ll", 16));}} 101016111117
10.8章节习题
10.12 什么是自动装箱和自动开箱? 下面的语句正确吗?
将基本类型值转换为包装类对象称为装箱（boxing），将包装类对象转化为基本类型值称为开箱（unboxing）。编译器会在没有相关命令的情况下，进行自动装箱和自动开箱。
//可以通过编译，3用了自动装箱，5完成了利用Integer类的装箱Integer a = 3 + new Integer(5); //可以通过编译，3用了自动装箱Integer b = 3;//无法通过编译，自动装箱应该输入一个double值Double c = 3;//可以通过编译，3.0用了自动装箱Double d = 3.0;//可以通过编译，3用了装箱int e = new Integer(3);//可以通过编译，3和4用了装箱int f = new Integer(3) + new Integer(4);
10.13 给出下面代码的输出结果。
public class Test {public static void main(String[]args) {Double x = 3.5;System.out.println(x.intValue());System.out.println(x.compareTo(4.5));}} 输出结果：
3-1
10.9章节习题
10.14 下面代码的输出是什么?
public class Test {public static void main(String[] args) {java.math.BigInteger x = new java.math.BigInteger("3");java.math.BigInteger y = new java.math.BigInteger("7");java.math.BigInteger z = x.add(y);System.out.println("x is " + x); System.out.println("y is " + y); System.out.println("z is " + z); } } 输出结果：
x is 3y is 7z is 10
10.10章节习题
10.15 假设 s1、s2、S3、s4 是四个字符串，给定如下语句:
String s1 = "Welcome to Java";String s2 = s1;String s3 = new String("Welcome to Java");String s4 = "Welcome to Java"; 下面表达式的结果是什么?
String s1 = "Welcome to Java";String s2 = s1;String s3 = new String("Welcome to Java");String s4 = "Welcome to Java";//等号匹配储存地址，equals匹配内容//trueSystem.out.println(s1==s2);//falseSystem.out.println(s1==s3);//trueSystem.out.println(s1==s4);//trueSystem.out.println(s1.equals(s3));//trueSystem.out.println(s1.equals(s4));//Welcome to HTMLSystem.out.println("Welcome to Java".replace("Java","HTML"));//WelcTme tT JavaSystem.out.println(s1.replace('o', 'T'));//WelcTme tT JavaSystem.out.println(s1.replaceAll("o", "T"));//WelcTme to JavaSystem.out.println(s1.replaceFirst("o","T"));//'W', 'e', 'l', 'c', 'o', 'm', 'e', ' ', 't', 'o', ' ', 'j', 'a', 'v', 'a'System.out.println(s1.toCharArray());//注：replace只可以替换单个字符或字符串，但是replaceAll可以使用正则表达式，更加灵活强大,例如：String str = "aBcd";//输出结果aBcd，没有变化，因为replace没法匹配正则表达式String newStr = str.replace("[a-z]", "*");System.out.println(newStr);//输出结果*B**，没有变化，因为replaceAll匹配了正则表达式，将所有小写字母全部换成了*String newStr2 = str.replaceAll("[a-z]", "*");System.out.println(newStr2); 10.16 为了创建一个字符串Welcome to java, 可能采用下面的语句:
String s = "Welcome to Java”;
或者
String s = new String("Welcome to Java"); 哪个更好? 为什么?
这道题的答案是chatGPT生成的，比标准答案写的还好。。。。。。
在这种情况下，采用第一种方式String s = "Welcome to Java";更好。
原因如下：
- 简洁性：直接使用字符串字面量创建字符串对象更加简洁，不需要调用构造函数。
- 效率：使用字符串字面量创建的字符串对象会被放入字符串常量池中，可以被JVM缓存，从而在内存使用和运行效率方面更加优化。而使用new String方式创建的字符串对象不会被放入常量池中，每次都会创建一个新的对象，从而在内存使用和运行效率方面相对较差。
- 可读性：使用字符串字面量创建的字符串对象更加易于理解和阅读，也更加符合Java编码习惯和规范。
总之，对于这种情况，建议优先使用字符串字面量创建字符串对象。只有在必须使用构造函数创建字符串对象的情况下，才使用new String方式。
10.17 下面代码的输出是什么?
String s1 = "Welcome to Java"; String s2 = s1.replace("o", "abc"); System.out.println(sl); System.out.println(s2); 输出结果：
Welcome to JavaWelcabcme tabc Java
10.18
假设s1是"Welcome"而s2是"welcome" , 为下面的陈述编写代码:
a. 用E替换s1中所有出现字符e的地方，然后将新字符串赋值给s2
b. 将"Welcome to Java and HTML"按空格分隔为一个数组tokens, 将前面两个标识赋值给s1和s2
public class Test {public static void main(String[] args) {String s1 = "Welcome";String s2 = "welcome";System.out.println(s2.replace('e', 'E'));String[] tokens = "Welcome to Java and HTML".split(" ");System.out.println(s1 = tokens[0]);System.out.println(s2 = tokens[1]);} } 输出结果：
wElcomEWelcometo
10.19 String类中是否有可以改变字符串内容的方法？
没有
10.20 假设字符串s是用new String()创建的，那么s.length()是多少？
0
10.21 如何将一个char值、一个字符数组或一个数值转换为一个字符串？
使用valueOf方法
10.22 为什么下面的代码会造成Nul1 PointerException异常？
public class Test { private String text; public Test(String s) { String text = s; } public static void main(String[] args) { Test test = new Test("ABC"); System.out.println(test.text.toLowerCase()); } } 出现了NullPointerException是因为在程序运行时，尝试调用一个空对象的属性或方法。
在这个程序中，text一共出现了3次。
其中，Test类中出现了2次。在Test类中，首先声明了私有数据域text，然后声明了局部变量text，这两个text虽然是同名的，但是其实完全不同。
其次，main方法中1次，main方法中，text尝试调用toLowerCase()方法，这里的text，其实是作为空的私有数据域的text，并不是作为局部变量的text，所以在程序运行时，调用了一个空对象的方法，导致空指针异常。
10.23 下面程序的错误是什么?
public class Test { String text; public void Test(String s) { text = s; } public static void main(String[] args) { Test test = new Test("ABC"); System.out.println(test); } } 在Test类中，有一个普通方法Test，这里注意，这个Test方法并不是构造方法，只是一个普通的方法（构造方法不应该有void关键字）
所以，这个Test类其实有一个普通方法Test，和一个系统自动生成的无参构造方法Test（只不过重名了）
接下来运行到main方法，尝试使用参数“ABC”调用Test的构造方法，但是，Test类并没有带参数的构造方法，自然也就匹配不到对应的构造方法，所以报错，这个构造方法没有被定义
10.24 给出下面代码的输出结果。
public class Test { public static void main(String[] args) {//matches方法的参数应该是一个正则表达式，不能是一个普通字符串//false System.out.println("Hi, ABC, good".matches("ABC ")); //true System.out.println("Hi, ABC, good".matches(".*ABC.*")); //如果replaceAll的参数是一个字符串，那么只能匹配100%精确的内容，如果参数是正则表达式，则可以根据正则表达式去匹配所有符合规则的字符串 //A,B;C System.out.println("A,B;C".replaceAll(",;", "#")); //A#B#C System.out.println("A,B;C".replaceAll("[,;]", "#")); String[] tokens = "A,B;C".split("[,;]"); for (int i = 0; i 10.25 给出下面代码的输出结果。
public class Test { public static void main(String[] args) { String s = "Hi, Good Morning"; //这里m方法的功能是检测大写字母的数量 //3 System.out.println(m(s)); } public static int m(String s) { int count = 0; for (int i = 0; i 10.11章节习题
10.26 StringBuilder和StringBuffer之间的区别是什么?
StringBuffer是同步的
10.27 如何为一个字符串创建字符串构建器? 如何从一个宇符串构建器获取字符串?
使用stringBuilder的构造方法
使用toString方法
10.28 使用StringBuilder类中的reverse方法编写三条语句，倒置字符串s
StringBuilder sb = new StringBuilder(s); sb.reverse();s = sb.toString();
10.29 编写三条语句，从包含20个字符的字符串s中删除下标从4到10的子串。使用StringBuilder类中的delete方法。
StringBuilder sb = new StringBuilder(s); sb.delete(4, 10);s = sb.toString();
10.30 字符串和字符串构建器内部用什么存储字符?
数组
10.31 假设给出如下所示的s1和s2，显示执行下列每条语句之后s1的结果。假定这些表达式都是相互独立的。
public class Test { public static void main(String[] args) { StringBuilder s1 = new StringBuilder("Java"); StringBuilder s2 = new StringBuilder("HTML"); //Java is fun s1.append(" is fun"); //JavaHTML s1.append(s2); //Jais funva s1.insert(2,"is fun"); //JHTMLava s1.insert(1,s2); //要注意这个方法只是查找，并不会更改字符串 //java s1.charAt(2); //要注意这个方法只是求长度，并不会更改字符串 //java s1.length(); //Jav s1.deleteCharAt(3); //左闭右开，即实际删除1和2位置的字符，省下0和4位置的字符 //ja s1.delete(1,3); //avaJ s1.reverse(); //JComputera s1.replace(1,3,"Computer"); //要注意这个方法只是查找，并不会更改字符串 //java s1.substring(1,3); //要注意这个方法只是查找，并不会更改字符串 //java s1.substring(2); }} 10.32 给出下面程序的输出结果:
public class Test { public static void main(String[] args) {String s = "Java";StringBuilder builder = new StringBuilder(s);change(s, builder); //JavaSystem.out.println(s); //Java and HTMLSystem.out.println(builder);}private static void change(String s, StringBuilder builder) { //要注意字符串不可变，下面的s只是局部变量，并不是原字符串s = s + " and HTML";builder.append(" and HTML");}} 编程练习题
*10.1 (时间类 Time)
设计一个名为 Time 的类。这个类包含:
• 表示时间的数据域hour、minute和second。
• 一个以当前时间创建Time对象的无参构造方法（数据域的值表示当前时间）
• 一个构造Time对象的构造方法，这个对象有一个特定的时间值，这个值是以毫秒表示的、从 1970年1月1日午夜开始到现在流逝的时间段（数据域的值表示这个时间）。
• 一个构造带特定的小时、分钟和秒的Time对象的构造方法。
• 三个数据域hour、minute和second各自的get方法。
• 一个名为setTime(long elapseTime)的方法使用流逝的时间给对象设置一个新时间。例如，如果流逝的时间为555550000毫秒，则转换为10小时、10分钟、10秒。
画出该类的UML图并实现这个类。编写一个测试程序，创建两个Time对象（使用newTime()和new Time(555550000)，然后显示它们的小时、分钟和秒。
public class Test { public static void main(String[] args) {Time test1 = new Time(); Time test2 = new Time(555550000); Time test3 = new Time(5, 23, 55); System.out.println("The result for the no argument Time object is " + test1.getHour() + ":" + test1.getMin() + ":" + test1.getSec() + "."); System.out.println("The result for the single argument Time object is " + test2.getHour() + ":" + test2.getMin() + ":" + test2.getSec() + "."); System.out.println("The result for the three argument Time object is " + test3.getHour() + ":" + test3.getMin() + ":" + test3.getSec() + ".");}} //_________________________UML DIAGRAM______________________________*/*| * Time | *------------------------------------------------------------------| * -hour : long| * | * -minute : long| * | * -second : long| *------------------------------------------------------------------| * -Time(): | * | * -Time(newTime: long): | * | * -Time(hour:long, min:long, second:long)| * | * getHour() : long| * | * getMinute() : long| * | * getSecond() : long| * | * setTime(): void| *__________________________________________________________________| */class Time {private long hour;private long minute;private long second;public Time() { long theTime = System.currentTimeMillis(); this.setTime(theTime); } public Time(long newTime) { this.setTime(newTime); } public Time(long newHour, long newMin, long newSec) { second = newSec; minute = newMin; hour = newHour; } public long getHour() { return hour; } public long getMin() { return minute; } public long getSec() { return second; } public void setTime(long elapsedTime) { hour = (((elapsedTime / 1000) / 60) / 60) % 24; second = (elapsedTime / 1000) % 60; minute = ((elapsedTime / 1000) / 60) % 60; }} 输出结果：
The result for the no argument Time object is 9:31:44.The result for the single argument Time object is 10:19:10.The result for the three argument Time object is 5:23:55.
10.2 (BMI 类)
将下面的新构造方法加人到 BMI 类中:
//直接复制进去就行public BMI(String name,int age,double weight,double feet, double inches)
10.3 (Mylnteger 类)
设计一个名为Mylnteger的类。这个类包括:
• 一个名为value的int型数据域，存储这个对象表示的int值。
• 一个为指定的int值创建MyInteger对象的构造方法。
• 一个返回int值的get方法。
• 如果值分别为偶数、奇数或素数,那么isEven()、isOdd()和isPrime()方法都会返回true
• 如果指定值分别为偶数、奇数或素数，那么相应的静态方法isEven(int)、is0dd(int)和 isPrime(int)会返回true
• 如果指定值分别为偶数、奇数或素数，那么相应的静态方法isEven(MyInteger)、 isOdd(MyInteger)和isPrime(MyInteger)会返回true
• 如果该对象的值与指定的值相等，那么equals(int)和equals(MyInteger)方法返回true
• 静态方法parseInt(char[])将数字字符构成的数组转换为一个int值
• 静态方法parseInt(String)将一个字符串转换为一个int值
画出该类的UML图并实现这个类。编写客户程序测试这个类中的所有方法。
public class Test { public static void main(String[] args) {MyInteger test = new MyInteger(5);System.out.println("Try 'getValue()': " + test.getValue());System.out.println("\nTry 'isEven()': " + test.isEven());System.out.println("Try 'isOdd()': " + test.isOdd());System.out.println("Try 'isPrime()': " + test.isPrime());System.out.println("\nTry 'isEven(int a)': " + MyInteger.isEven(6));System.out.println("Try 'isOdd(int a)': " + MyInteger.isOdd(6));System.out.println("Try 'isPrime(int a)': " + MyInteger.isPrime(6));System.out.println("\nTry 'isEven(MyInteger a)': " + MyInteger.isEven(test));System.out.println("Try 'isOdd(MyInteger a)': " + MyInteger.isOdd(test));System.out.println("Try 'isPrime(MyInteger a)': " + MyInteger.isPrime(test));System.out.println("\nTry 'equals(int a)': " + test.equals(5));System.out.println("Try 'equals(MyInteger a)': " + test.equals(test));char[] testArray = {'1', '2', '3', '4', '5'};System.out.println(MyInteger.parseInt(testArray));System.out.println(MyInteger.parseInt("12345"));}} //__________________________UML DIAGRAM_____________________________*/*| * MyInteger| *------------------------------------------------------------------| * -value: int| *------------------------------------------------------------------| * +MyInteger(newValue: int)| * | * +getValue() : int| * | * +isEven(): boolean | * | * +isOdd(): boolean| * | * +isPrime():boolean | * | * ___+isEven(a: int): boolean___| * | * ___+isOdd(a: int): boolean___| * | * ___+isPrime(a: int): boolean___| * | * ___+isEven(a: MyInteger): boolean___ | * | * ___+isOdd(a: MyInteger): boolean___ | * | * ___+isPrime(a: MyInteger): boolean___ | * | * +equals(a: int): boolean| * | * +equals(a: MyInteger): boolean| * | * ___+parseInt(arr: Char[]): int___| * | * ___+parseInt(a: String):int___ | * _________________________________________________________________| */public class MyInteger { private int value; public MyInteger(int newValue) { this.value = newValue; } public int getValue() { return value; } public boolean isEven() { if (value % 2 == 0) return true; else return false; } public boolean isOdd() { if (value % 2 != 0) return true; else return false; } public boolean isPrime() { boolean prime = false; for (int i = 3; i 输出结果：
Try 'getValue()': 5Try 'isEven()': falseTry 'isOdd()': trueTry 'isPrime()': falseTry 'isEven(int a)': trueTry 'isOdd(int a)': falseTry 'isPrime(int a)': falseTry 'isEven(MyInteger a)': falseTry 'isOdd(MyInteger a)': trueTry 'isPrime(MyInteger a)': falseTry 'equals(int a)': trueTry 'equals(MyInteger a)': true1234512345
10.4 (MyPoint类)
设计一个名为MyPoint的类，表示一个带x坐标和y坐标的点。该类包括:
• 两个带get方法的数据域x和y分别表示它们的坐标
• 一个创建点(0, 0)的无参构造方法
• 一个创建特定坐标点的构造方法
• 一个名为distance的方法，返回从该点到MyPoint类型的指定点之间的距离。
• 一个名为distance的方法，返回从该点到指定x和y坐标的指定点之间的距离。
画出该类的UML图并实现这个类。编写一个测试程序，创建两个点(0, 0)和(10, 30.5)，并显示它们之间的距离。
public class Test { public static void main(String[] args) {MyPoint p1 = new MyPoint();MyPoint p2 = new MyPoint(10, 30.5);System.out.println(p1.distance(10, 30.5));System.out.println(p1.distance(p2));}} //__________________________UML DIAGRAM_____________________________*/*| * MyPoint| *------------------------------------------------------------------| * -x: double| * | * -y: double| *------------------------------------------------------------------| * +MyPoint() (default: (0, 0)) | * | * +MyPoint(x: double, y: double) | * | * +getX(): double| * | * +getY(): double| * | * +distance(x: double, y: double): double| * | +distance(MyPoint: p): double| * _________________________________________________________________| */class MyPoint {private double x;private double y;public MyPoint() {x = 0;y = 0;}public MyPoint(double x, double y) {this.x = x;this.y = y;}public double getX() {return x;}public double getY() {return y;}public double distance(double x, double y) {return Math.sqrt(Math.pow(this.x - x, 2) + Math.pow(this.y - y, 2));}public double distance(MyPoint a) {return distance(a.x, a.y);}} 输出结果：
32.0975076914080732.09750769140807
10.5 (显示素教因子)
编写一个程序，提示用户输入一个正整数，然后以降序显示它的所有最小因子。
例如: 如果整数为120, 那么显示的最小因子为5、3、2、2、2。使用StackOflntegers类存储因子(例如:2、2、2、3、5), 获取之后按倒序显示这些因子。
public class Test { public static void main(String[] args) {StackOfIntegers test = new StackOfIntegers();//输入一个数字去判断他的因子int a = 20;//判断因子for (int b = 1; b if (a % b == 0)test.push(b);}//数字本身一定是因子，所以先输出出来System.out.print(a + " ");//循环打印剩下的因子while (test.empty() == false)System.out.print(test.pop() + " ");}} private int[] elements; private int size; public static final int DEFAULT_CAPACITY = 16; /** * Construct a stack with the default capacity 16 */ public StackOfIntegers() { this(DEFAULT_CAPACITY); } /** * Construct a stack with the specified maximum capacity */ public StackOfIntegers(int capacity) { elements = new int[capacity]; } /** * Push a new integer to the top of the stack */ public void push(int value) { if (size = elements.length) { int[] temp = new int[elements.length * 2]; System.arraycopy(elements, 0, temp, 0, elements.length); elements = temp; } elements[size++] = value; } /** * Return and remove the top element from the stack */ public int pop() { return elements[--size]; } /** * Return the top element from the stack */ public int peek() { return elements[size - 1]; } /** * Test whether the stack is empty */ public boolean empty() { return size == 0; } /** * Return the number of elements in the stack */ public int getSize() { return size; }} 输出结果：
20 10 5 4 2 1
*10.6 (显示素教)
编写一个程序，然后按降序显示小于120的所有素数。使用StackOflntegers 类存储这些素数(例如:2、3、5、…)，获取之后按倒序显示它们。
public class Test { public static void main(String[] args) {StackOfIntegers test = new StackOfIntegers();for (int i = 2; i if (isPrime(i)) {test.push(i);}} //循环打印素数 while (test.empty() == false) System.out.print(test.pop() + " ");}public static boolean isPrime(int n) { if (n return false; } for (int i = 2; i if (n % i == 0) { return false; } } return true;}} private int[] elements; private int size; public static final int DEFAULT_CAPACITY = 16; /** * Construct a stack with the default capacity 16 */ public StackOfIntegers() { this(DEFAULT_CAPACITY); } /** * Construct a stack with the specified maximum capacity */ public StackOfIntegers(int capacity) { elements = new int[capacity]; } /** * Push a new integer to the top of the stack */ public void push(int value) { if (size = elements.length) { int[] temp = new int[elements.length * 2]; System.arraycopy(elements, 0, temp, 0, elements.length); elements = temp; } elements[size++] = value; } /** * Return and remove the top element from the stack */ public int pop() { return elements[--size]; } /** * Return the top element from the stack */ public int peek() { return elements[size - 1]; } /** * Test whether the stack is empty */ public boolean empty() { return size == 0; } /** * Return the number of elements in the stack */ public int getSize() { return size; }}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);Account[] atmAccounts = new Account[10];for (int i = 0; i rec2BottomRight.getY() && rec2TopLeft.getY() > rec1BottomRight.getY()); } } //__________________________UML DIAGRAM_____________________________*/*| * MyPoint| *------------------------------------------------------------------| * -x: double| * | * -y: double| *------------------------------------------------------------------| * +MyPoint() (default: (0, 0)) | * | * +MyPoint(x: double, y: double) | * | * +getX(): double| * | * +getY(): double| * | * +distance(x: double, y: double): double| * | +distance(MyPoint: p): double| * _________________________________________________________________| */class MyPoint {private double x;private double y;public MyPoint() {x = 0;y = 0;}public MyPoint(double x, double y) {this.x = x;this.y = y;}public double getX() {return x;}public double getY() {return y;}public double distance(double x, double y) {return Math.sqrt(Math.pow(this.x - x, 2) + Math.pow(this.y - y, 2));}public double distance(MyPoint a) {return distance(a.x, a.y);}} 输出结果：
26.95000000000000320.8truefalsetrue
*10.14 (MyDate 类)
设计一个名为MyDate的类，该类包含:
• 表示日期的数据域year、month和day。月份是从0开始的，即0表示一月份。
• 一个无参构造方法，该方法创建当前日期的MyDate对象。
• 一个构造方法，创建以从1970年1月1日午夜开始流逝的毫秒数为时间的MyDate对象。
• 一个构造方法，创建一个带指定年、月、日的MyDate对象。
• 三个数据域year、month和day的get方法。
• 一个名为setDate(long elapsedTime)使用流逝的时间为对象设置新数据的方法。
画出该类的UML图并实现这个类。编写测试程序，创建一个测试程序，创建两个Date对象(使用new Date()和new Date(34355555133101L),然后显示它们的小时、分钟和秒。
public class Test {public static void main(String[] args) { MyDate myDate1 = new MyDate(); MyDate myDate2 = new MyDate(34355555133101L); System.out.println("MyDate1:\n year=" + myDate1.getYear() + "\n month=" + myDate1.getMonth() + "\n day=" + myDate1.getDay()); System.out.println("MyDate2:\n year=" + myDate2.getYear() + "\n month=" + myDate2.getMonth() + "\n day=" + myDate2.getDay());}} import java.util.GregorianCalendar;//____________________________________UML DIAGRAM_______________________________________*/*| * MyDate| *--------------------------------------------------------------------------------------| * -year: int| * | * -month: int| * | * -day: int| || *--------------------------------------------------------------------------------------| * +MyDate() | * | * +MyDate(elapsedTime: long) | * | * +MyDate(year: int, month: int, day: int)| * | * +setDate(elapsedTime: long): void| * | * +getYear(): int| * | * +getMonth(): int| * | * +getDay(): int| * | * _____________________________________________________________________________________| */public class MyDate { GregorianCalendar gregorianCalendar = new GregorianCalendar(); private int year; private int month; private int day; public MyDate() { this(System.currentTimeMillis()); } public MyDate(long elapsedTime) { setDate(elapsedTime); } public MyDate(int year, int month, int day) { this.year = year; this.month = month; this.day = day; } public void setDate(long elapsedTime) { gregorianCalendar.setTimeInMillis(elapsedTime); this.year = gregorianCalendar.get(GregorianCalendar.YEAR); this.month = gregorianCalendar.get(GregorianCalendar.MONTH); this.day = gregorianCalendar.get(GregorianCalendar.DAY_OF_MONTH); } public int getYear() { return year; } public int getMonth() { return month; } public int getDay() { return day; }} 输出结果：
MyDate1: year=2023 month=3 day=22MyDate2: year=3058 month=8 day=7
*10.15 (几何:边界鉅形)
边界矩形是指包围一个二维平面上一系列点的矩形，如图10-24d所示。编写一个方法，为二维平面上一系列点返回一个边界矩形，如下所示:
public static MyRectangle2D getRectangle(double[][] points)
Rectangle2D类在编程练习题10.13 中定义。编写一个测试程序，提示用户输人5个点， 然后显示边界矩形的中心、宽度以及髙度。
public class Test {public static void main(String[] args) {double[][] points = {{1.0, 2.5}, {3, 4}, {5, 6}, {7, 8}, {9, 10}};BdRectangle2D test1 = new BdRectangle2D(points);System.out.print("The bounding rectangle's center (" + test1.getCentralX() + ", " + test1.getCentralY() + "), width " + test1.getWidth() + ", height " + test1.getHeight() + ".");}} public class BdRectangle2D {//边界矩形的四条边一定平行于xy轴 private double[][] points = new double[4][1]; public BdRectangle2D(double[][] points) { this.points = points; } public double getMaxX() { double maxX = points[0][0]; for (int i = 0; i points[i][0]) { maxX = points[i + 1][0]; } } return maxX; } public double getMinX() { double minX = points[0][0]; for (int i = 0; i points[i][1]) { maxY = points[i + 1][1]; } } return maxY; } public double getMinY() { double minY = points[0][1]; for (int i = 0; i The bounding rectangle's center (5.0, 6.25), width 8.0, height 7.5.
*10.16 (被2或3整除)
找出能被2或3整除的前10个数字，这些数字有50个十进制位数。
import java.math.BigDecimal;public class Test {public static void main (String[] args) {BigDecimal a = new BigDecimal("10000000000000000000000000000000000000000000000000");BigDecimal b = BigDecimal.valueOf(2);BigDecimal c = BigDecimal.valueOf(3);for (int i = 0; i 10000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000021000000000000000000000000000000000000000000000000410000000000000000000000000000000000000000000000005100000000000000000000000000000000000000000000000061000000000000000000000000000000000000000000000000810000000000000000000000000000000000000000000000010100000000000000000000000000000000000000000000000111000000000000000000000000000000000000000000000001210000000000000000000000000000000000000000000000014
*10.17 (平方數)
找出大于Long.MAX_VALUE的前10个平方数。平方数是指形式为/« 的数。例如，4、 9以及16都是平方数。找到一种方使你的程序能快速运行。
import java.math.BigInteger;public class Test { public static void main(String[] args) { BigInteger maxLongVal = BigInteger.valueOf(Long.MAX_VALUE); int count = 0; long rootNum = (long) Math.sqrt(maxLongVal.doubleValue()); BigInteger root = BigInteger.valueOf(rootNum); while (count 0) { System.out.println(n2); count++; } } }} 9223372037000250000922337204307425100192233720491482520049223372055222253009922337206129625401692233720673702550259223372073444256036922337207951825704992233720855922580649223372091666259081
*10.18(大素数)
编写程序找出五个大于Long.MAX_VALUE的素数。
import java.math.BigInteger;public class Test { // BigInteger TWO = BigInteger.valueOf(2L); static final BigInteger lowerBound = BigInteger.valueOf(Long.MAX_VALUE); BigInteger testNum = lowerBound; public static void main(String[] args) { Test obj = new Test(); int idx = 0; while (idx 92233720368547758379223372036854775907922337203685477593192233720368547759399223372036854775963
* 10.19(Mersenne素数)
如果一个素数可以写成 2 p − 1 2^p -1 2p−1的形式，那么该素数就称为Mersenne素数，其中的p是一个正整数。编写程序找出p≤100的所有Mersenne素数，然后显示如下所示的输出。（必须使用BigInteger来存储数字，因为它太大了，不能用1ong来存储。程序可能需要运行几个小时。)
import java.math.BigInteger;public class Test { static int P = 2; static BigInteger TWO = BigInteger.valueOf(2L); public static void main(String[] args) { System.out.print("p 2^p - 1"); while (P BigInteger mersennePrime = TWO.pow(P).subtract(BigInteger.ONE); if (mersennePrime.isProbablePrime(1)) { System.out.print("\n" + P + " " + mersennePrime.toString()); System.out.println(); P++; } } }}public static void main(String[] args) {BigDecimal e = new BigDecimal(1); for (int i = 100; i BigDecimal numerator = BigDecimal.valueOf(1.0); BigDecimal denominator = new BigDecimal(factor(i)); BigDecimal result = numerator.pide(denominator, 25, BigDecimal.ROUND_UP); e = e.add(result); if (i % 100 == 0) System.out.println(e); }}public static BigInteger factor(int n) {BigInteger factorial = BigInteger.ONE;for (int i = 1; i public static void main(String[] args) {BigDecimal a = new BigDecimal(Long.MAX_VALUE);BigDecimal b = a.add(BigDecimal.ONE);for (int i = 0; i 0) { splitList.add(subString); } return splitList.toArray(new String[]{}); }} *10.26 (计算器)
修改程序清单7-9,接收一个字符串的表达式，其中操作符和操作数由0到多个空格隔开。例如，3+4 和 3 + 4 都是可以接受的表达式。
public class Test { public static void main(String[] args) { StringBuilder str = new StringBuilder(); for (String arg : args) { str.append(arg); } String str2 = str.toString().replaceAll(" ", ""); str2 = str2.replaceAll("[+]", "%+%"); str2 = str2.replaceAll("[-]", "%-%"); str2 = str2.replaceAll("[.]", "%.%"); str2 = str2.replaceAll("[/]", "%/%"); args = str2.split("%"); int result = 0; switch (args[1].charAt(0)) { case '+': result = Integer.parseInt(args[0]) + Integer.parseInt(args[2]); break; case '-': result = Integer.parseInt(args[0]) - Integer.parseInt(args[2]); break; case '.': result = Integer.parseInt(args[0]) * Integer.parseInt(args[2]); break; case '/': result = Integer.parseInt(args[0]) / Integer.parseInt(args[2]); break; } System.out.println(args[0] + ' ' + args[1] + ' ' + args[2] + " = " + result); }} **10.27 (实现 StringBuilder类)
在Java库中提供了StringBuilder类。给出你自己对下面方法的实现(将新类命名为MyStringBuilder1):
public class Test { public static void main(String[] args) { MyStringBuilder1 stringBuilder1 = new MyStringBuilder1("SOMESTRINGTESTHERE"); System.out.println(stringBuilder1.toLowerCase().toString()); System.out.println(stringBuilder1.length()); MyStringBuilder1 stringBuilder3 = stringBuilder1.append(12); System.out.println(stringBuilder1.toString()); System.out.println(stringBuilder3.toString()); MyStringBuilder1 stringBuilder2 = new MyStringBuilder1("AddedSomeStringhere"); stringBuilder1.append(stringBuilder2); System.out.println(stringBuilder1.toString()); System.out.println(stringBuilder1.substring(3,11)); }} public class MyStringBuilder1 { char[] values; public MyStringBuilder1(String s) { values = s.toCharArray(); } public MyStringBuilder1 append(MyStringBuilder1 s) { int oldLength = this.values.length; char[] nuValues = new char[oldLength + s.length()]; System.arraycopy(this.values, 0, nuValues, 0, oldLength); System.arraycopy(s.values, 0, nuValues, oldLength, s.length()); this.values = nuValues; return this; } public MyStringBuilder1 append(int i) { int oldLength = values.length; String temp = i + ""; char[] nuVals = new char[values.length + temp.length()]; char[] integer = temp.toCharArray(); System.arraycopy(this.values, 0, nuVals, 0, this.values.length); System.arraycopy(integer, 0, nuVals, oldLength, integer.length); this.values = nuVals; return this; } public int length() { return values.length; } public char charAt(int index) { return values[index]; } public MyStringBuilder1 toLowerCase() { char[] nu = new char[this.values.length]; for (int i = 0; i somestringtesthere18SOMESTRINGTESTHERE12SOMESTRINGTESTHERE12SOMESTRINGTESTHERE12AddedSomeStringhereESTRINGT
**10.28 (实现 StringBuilder类)
在Java库中提供了StringBuilder类。给出你自己对下面方法的实现(将新类命名为MyStringBuilder2):
public class Test { public static void main(String[] args) { //Test StringBuilder2 MyStringBuilder2 myStringBuilder2 = new MyStringBuilder2("SuperCalifradolistic"); System.out.print("Start MyStringBuilder2 values: "); System.out.println(myStringBuilder2.toString()); System.out.print("ToUpperCase: "); System.out.println(myStringBuilder2.toUpperCase().toString()); System.out.print("Insert: "); myStringBuilder2.insert(3, new MyStringBuilder2("TESTinsertTEST")); System.out.println(myStringBuilder2.toString()); System.out.print("Reverse: "); System.out.println(myStringBuilder2.reverse().toString()); System.out.println("subString: " + myStringBuilder2.substring(5).toString()); }} import java.util.Arrays;public final class MyStringBuilder2 { char[] values; public MyStringBuilder2() { this("".toCharArray()); } public MyStringBuilder2(char[] chars) { this.values = chars; } public MyStringBuilder2(String s) { this(s.toCharArray()); } public MyStringBuilder2 insert(int offset, MyStringBuilder2 s) { char[] nuVals = new char[s.values.length + offset]; System.arraycopy(this.values, 0, nuVals, 0, offset); System.arraycopy(s.values, 0, nuVals, offset, s.values.length); this.values = nuVals; return this; } public MyStringBuilder2 reverse() { char[] nuVals = new char[values.length]; for (int i = values.length - 1, j = 0; i >= 0; i--, j++) { nuVals[j] = values[i]; } this.values = nuVals; return this; } public MyStringBuilder2 substring(int begin) { String s = ""; for (int i = begin; i Start MyStringBuilder2 values: SuperCalifradolisticToUpperCase: SUPERCALIFRADOLISTICInsert: SUPTESTinsertTESTReverse: TSETtresniTSETPUSsubString: resniTSETPUS
下一篇：英文服务器客户信息怎么填?
