正则表达式，包装类

1 编写RegExUtils类，提供静态方法实现对身份证号码、邮政编码、手机号码的合法性校验

参考答案

在企业的项目中，我们通常也会构建一些工具类，用于专门的用途。这些类，大多以XxxUtils作为命名。例如当前案例中要求的RegUtils，主要用于使用正则表达式验证各种信息是否合法。要实现当前案例的需求，需要以下步骤：

首先，构建RegExUtils类，在该类中添加静态常量IDENTITY_CARD、ZIP_CODE以及PHONE_NUMBER分别表示身份证号码、邮政编码以及手机号码的正则表达式。

其次，在RegUtils类中，定义check方法，该方法用于检查字符串str是否和正则表达式regex匹配。

最后，在RegExUtils类中，添加方法identityCard、zipcode以及phoneNumber分别用于实现检测身份证号码、邮政编码以及手机号码是否为合法的。

实现此案例需要按照如下步骤进行。

步骤一：构建工具类RegUtils

在工程JavaSE中，新建类RegExUtils，代码如下所示：

 

1. package day02;
3. public class RegExUtils {
5. }

步骤二：定义静态常量表示正则表达式

在RegExUtils类中,添加静态常量IDENTITY_CARD、ZIP_CODE以及PHONE_NUMBER分别表示验证身份证号码、邮政编码以及手机号码的正则表达式，代码如下所示：

 

1. package day02;
3. public class RegExUtils {
4.     //验证身份证号码的正则表达式
5.     private static final String IDENTITY_CARD = "^\\d{15}|\\d{18}$";
6.     //验证邮政编码的正则表达式
7.     private static final String ZIP_CODE = "^[1-9][0-9]{5}$";
8.     //正则手机号码的正则表达式
9.     private static final String PHONE_NUMBER = "^13[0-9]{9})|(15[89][0-9]{8}$";
10. }

对于上述正则表达式能看懂即可。

步骤三：构建检查字符串str是否和正则表达式匹配的方法check

在RegExUtils类中，定义check方法，该方法用于检查字符串str是否和正则表达式regex匹配，代码如下所示：

 

1. package day02;
3. public class RegExUtils {
5.     //验证身份证号码的正则表达式
6.     private static final String IDENTITY_CARD = "^\\d{15}|\\d{18}$";
7.     //验证邮政编码的正则表达式
8.     private static final String ZIP_CODE = "^[1-9][0-9]{5}$";
9.     //正则手机号码的正则表达式
10.     private static final String PHONE_NUMBER = "^13[0-9]{9})|(15[89][0-9]{8}$";
12.     /**
13.      * 检查字符串str是否和正则表达式regex匹配
14.      *
15.      * @param str
16.      * 字符串
17.      * @param regex
18.      * 正则表达式
19.      * @return 如果字符串str和正则表达式regex匹配,返回true，否则，返回false
20.      */
21.     private static boolean check(String str, String regex) {
22.         return str.matches(regex);
23.     }
24. }

步骤四：检查

在RegExUtils类中，添加方法identityCard、zipcode以及phoneNumber分别用于实现检测身份证号码、邮政编码以及手机号码是否为合法的，代码如下所示：

 

1. package day02;
3. public class RegExUtils {
4.     //验证身份证号码的正则表达式
5.     private static final String IDENTITY_CARD = "^\\d{15}|\\d{18}$";
6.     //验证邮政编码的正则表达式
7.     private static final String ZIP_CODE = "^[1-9][0-9]{5}$";
8.     //正则手机号码的正则表达式
9.     private static final String PHONE_NUMBER = "^13[0-9]{9})|(15[89][0-9]{8}$";
11.     /**
12.      * 检查字符串str是否和正则表达式regex匹配
13.      *
14.      * @param str
15.      * 字符串
16.      * @param regex
17.      * 正则表达式
18.      * @return 如果字符串str和正则表达式regex匹配,返回true，否则，返回false
19.      */
20.     private static boolean check(String str, String regex) {
21.         return str.matches(regex);
22.     }
25.     /**
26.      * 检测是否为合法的身份证号码
27.      *
28.      * @param str
29.      * 身份证号码字符串
30.      * @return 如果身份证号码字符串和正则表达式匹配则返回true，否则返回false
31.      */
32.     public static boolean identityCard(String str) {
33.         return check(str, IDENTITY_CARD);
34.     }
36.     /**
37.      * 检测是否为合法的邮政编码
38.      *
39.      * @param str
40.      * 邮政编码字符串
41.      * @return 如果邮政编码字符串和正则表达式匹配则返回true，否则返回false
42.      */
43.     public static boolean zipcode(String str) {
44.         return check(str, ZIP_CODE);
45.     }
47.     /**
48.      * 检测是否为合法的手机号码
49.      *
50.      * @param str
51.      * 手机号码字符串
52.      * @return 如果手机号码字符串和正则表达式匹配则返回true，否则返回false
53.      */
54.     public static boolean phoneNumber(String str) {
55.         return check(str, PHONE_NUMBER);
56.     }
57. }

观察上述方法，可以看出，在上述方法中都调用了步骤二定义check方法，check方法的重用率很高，这也是单独定义check方法的原因。

本案例中，RegExUtils的完整代码如下所示：

代码

2 重写员工类（Emp）的equals和toString方法

在面向对象的课程中，我们曾使用过Emp类，本案例要求重写Emp类的toString方法和equals方法，详细要求如下：

1），重写Emp类的toString方法，返回Emp对象的名字、年龄、性别和工资信息，例如：张三，23，男，5000。

2），重写Emp类的equals方法，两个Emp引用变量相等的条件是名字相等。

参考答案

实现此案例需要按照如下步骤进行。

步骤一：创建 Emp类

创建 Emp类，并在其中覆盖toString方法，返回Emp对象的名字，年龄，性别和工资信息，代码如下所示：

 

1. package day02;
3. public class Emp {
4.     String name;
5.     int age;
6.     char gender;
7.     double salary;
9.     public void printInfo() {
10.         System.out.println("--------------------");
11.         System.out.println("姓名： " + name);
12.         System.out.println("年龄：" + age);
13.         System.out.println("性别：" + gender);
14.         System.out.println("薪水：" + salary);
15.     }
17.     @Override
18.     public String toString() {
19.         return name + "," + age + "," + gender + "," + salary;
20.     }
21. }

步骤二：写测试方法

测试toString方法是否覆盖生效。首先，在JavaSE工程下的day02包下新建TestEmp，然后，在该类中添加测试方法testToString，最后，实例化一个Emp类的对象，其name、age、gender、salary为张三、23、男、5000，并输出该对象，代码如下所示：

 

1. package day02;
3. import org.junit.Test;
5. public class TestEmp {
6.     /**
7.      * 测试toString方法
8.      */
9.     @Test
10.     public void testToString() {
11.         Emp emp = new Emp();
12.         emp.name="张三";
13.         emp.age=23;
14.         emp.gender='男';
15.         emp.salary=5000;
16.         System.out.println(emp); // 张三，23，男，5000
17.     }
18. }

步骤三：运行

运行testToString方法，控制台输出结果如下所示：

 

1. 张三，23，男，5000

从运行结果可以看出，已经成功覆盖了toString方法，返回name、age、gender、salary的值为张三，23，男，5000。

步骤四：在Emp类中覆盖equals方法

在Emp类中覆盖equals方法，两个Emp引用变量相等的条件是名字相等，代码如下所示：

 

1. package day02;
3. public class Emp {
4.     String name;
5.     int age;
6.     char gender;
7.     double salary;
9.     public void printInfo() {
10.         System.out.println("--------------------");
11.         System.out.println("姓名： " + name);
12.         System.out.println("年龄：" + age);
13.         System.out.println("性别：" + gender);
14.         System.out.println("薪水：" + salary);
15.     }
17.     @Override
18.     public String toString() {
19.         return name + "," + age + "," + gender + "," + salary;
20.     }
22.     @Override
23.     public boolean equals(Object obj) {
24.         if (obj == null) {
25.             return false;
26.         }
27.         if (this == obj) {
28.             return true;
29.         }
30.         if (obj instanceof Emp) {
31.             Emp emp = (Emp) obj;
32.             return this.name.equals(emp.name);
33.         } else {
34.             return false;
35.         }
36.     }
37. }

此处需要注意，属性name的类型为String类型，比较两个字符序列是否相等使用equals方法。

步骤五：测试equals方法是否生效

测试equals方法是否覆盖生效。首先，在类TestEmp中添加测试方法testEquals，然后，创建emp1对象和emp2对象； 最后，分别使用==和equals比较emp1对象和emp2对象是否相等，代码如下所示：

 

1. package day02;
3. import org.junit.Test;
5. public class TestEmp {
6.     /**
7.      * 测试toString方法
8.      */
9.     @Test
10.     public void testToString() {
11.         Emp emp = new Emp();
12.         emp.name="张三";
13.         emp.age=23;
14.         emp.gender='男';
15.         emp.salary=5000;
16.         System.out.println(emp); // 张三，23，男，5000
17.     }
19.     /**
20.      * 测试equals方法
21.      */
22.     @Test
23.     public void testEquals() {
24.         Emp emp1 = new Emp();
25.         emp1.name="张三";
26.         emp1.age=24;
27.         emp1.gender='女';
28.         emp1.salary=6000;
29.         Emp emp2 = new Emp();
30.         emp2.name="张三";
31.         emp2.age=23;
32.         emp2.gender='男';
33.         emp2.salary=5000;
34.         System.out.println(emp1 == emp2); // false
35.         System.out.println(emp1.equals(emp2)); // true
36.     }
37. }

步骤六：运行

运行testEquals方法，控制台输出结果如下所示：

1. false
2. true

从运行结果可以看出，使用==比较的结果为false、使用equals比较的结果为true，说明Emp类成功覆盖了equals方法，实现了名字（name）相等两个Emp的引用变量则相等。

本案例中，Emp类的完整代码如下所示：

 

1. package day02;
3. public class Emp {
4.     String name;
5.     int age;
6.     char gender;
7.     double salary;
9.     public void printInfo() {
10.         System.out.println("--------------------");
11.         System.out.println("姓名： " + name);
12.         System.out.println("年龄：" + age);
13.         System.out.println("性别：" + gender);
14.         System.out.println("薪水：" + salary);
15.     }
17.     @Override
18.     public String toString() {
19.         return name + "," + age + "," + gender + "," + salary;
20.     }
22.     @Override
23.     public boolean equals(Object obj) {
24.         if (obj == null) {
25.             return false;
26.         }
27.         if (this == obj) {
28.             return true;
29.         }
30.         if (obj instanceof Emp) {
31.             Emp emp = (Emp) obj;
32.             return this.name.equals(emp.name);
33.         } else {
34.             return false;
35.         }
36.     }
37. }

隐藏

TestEmp类的完整代码如下：

 

1. package day02;
3. import org.junit.Test;
5. public class TestEmp {
6.     /**
7.      * 测试toString方法
8.      */
9.     @Test
10.     public void testToString() {
11.         Emp emp = new Emp();
12.         emp.name="张三";
13.         emp.age=23;
14.         emp.gender='男';
15.         emp.salary=5000;
16.         System.out.println(emp); // 张三，23，男，5000
17.     }
19.     /**
20.      * 测试equals方法
21.      */
22.     @Test
23.     public void testEquals() {
24.         Emp emp1 = new Emp();
25.         emp1.name="张三";
26.         emp1.age=24;
27.         emp1.gender='女';
28.         emp1.salary=6000;
29.         Emp emp2 = new Emp();
30.         emp2.name="张三";
31.         emp2.age=23;
32.         emp2.gender='男';
33.         emp2.salary=5000;
34.         System.out.println(emp1 == emp2); // false
35.         System.out.println(emp1.equals(emp2)); // true
36.     }
37. }

隐藏

3 输入数字字符串，转换为整数或浮点数

用户从控制台接收一个字符串，通过程序判断该字符串是整数，还是小数。如果既不是整数也不是小数，程序输出“数字格式不正确”。程序交互过程如下所示：

用户输入整数字符串的情况，如图-1所示：

图- 1

用户输入为小数的情况，如图-2所示：

图- 2

用户输入的既不是整数也不是小数的情况，如图-3所示：

图- 3

参考答案

实现此案例需要按照如下步骤进行。

步骤一：新建TestChange类，添加testStringToIntOrDouble方法

首先，在工程JavaSE的day02包下新建类TestChange；然后，在该类中添加方法testStringToIntOrDouble，代码如下所示：

 

1. package day02;
3. import java.util.Scanner;
4. import org.junit.Test;
6. public class TestChange {
7.     @Test
8.     public void testStringToIntOrDouble() {
9.     }
10. }

步骤二：定义正则表达式

定义匹配整数和匹配小数的正则表达式，代码如下所示：

 

1. package day02;
3. import org.junit.Test;
4. public class TestChange {
5.     @Test
6.     public void testStringToIntOrDouble() {
7.         String integerRegex = "^[0-9]+$";
8.         String decimalRegex = "^[0-9]+\\.[0-9]+$";
9.     }
10. }

步骤三：对用户输入的字符串进行判断

首先，接收用户输入的字符串；然后，使用字符串的matches方法判断该字符串是整数还是小数或是其它情况，代码如下所示：

 

1. package day02;
3. import java.util.Scanner;
4. import org.junit.Test;
6. public class TestChange {
7.     @Test
8.     public void testStringToIntOrDouble() {
9.         String integerRegex = "^[0-9]+$";
10.         String decimalRegex = "^[0-9]+\\.[0-9]+$";
11.         Scanner scanner = new Scanner(System.in);
12.         System.out.println("请输入一个数字:");
13.         String numberStr = scanner.nextLine();
14.         if(numberStr.matches(integerRegex)){
15.             System.out.println("这是一个整数:"+Integer.parseInt(numberStr));
16.         }else if(numberStr.matches(decimalRegex)){
17.             System.out.println("这是一个小数:"+Double.parseDouble(numberStr));
18.         }else{
19.             System.out.println("数字格式不正确!");
20.         }
21.     }
22. }

上述代码中，使用Integer的parseInt方法将字符串转换为整数、使用Double的parseDouble方法将字符串转换为浮点数。

本案例的完整代码如下所示：

 

1. package day02;
3. import java.util.Scanner;
4. import org.junit.Test;
6. public class TestChange {
7.     @Test
8.     public void testStringToIntOrDouble() {
9.         String integerRegex = "^[0-9]+$";
10.         String decimalRegex = "^[0-9]+\\.[0-9]+$";
11.         Scanner scanner = new Scanner(System.in);
12.         System.out.println("请输入一个数字:");
13.         String numberStr = scanner.nextLine();
14.         if(numberStr.matches(integerRegex)){
15.             System.out.println("这是一个整数:"+Integer.parseInt(numberStr));
16.         }else if(numberStr.matches(decimalRegex)){
17.             System.out.println("这是一个小数:"+Double.parseDouble(numberStr));
18.         }else{
19.             System.out.println("数字格式不正确!");
20.         }
21.     }
22. }

隐藏

4 简述自动装箱和拆箱的原理

参考答案

装箱和拆箱是 “编译器”认可的，而不是虚拟机。编译器在生成类的字节码时，插入必要的方法调用，例如：

将自动装箱处理为：

 

1. Integer a = 100 => Integer a = Integer.valueOf(100)
2. Integer b = 200 => Integer b = Integer.valueOf(200)
3. Integer c = a +b =>
4. Integer c = Integer.valueOf (a.intValue( ) + b.intValue( ))

可以看出，自动装箱时，调用了Integer的valueOf方法将int类型的值100转换成了Integer类型。

自动拆箱处理为：

 

1. int d = c => int d = c . intValue( )

可以看出，自动拆箱时，调用了Integer的intValue方法，将Integer类型的变量转成了int类型。