JAVA SE01 Unit02
- 编写验证Email的正则表达式
- 使用split方法拆分字符串
- 使用replaceAll实现字符串替换
- 重写Cell类的toString方法
- 重写Cell类的equals方法
- 测试Number的intValue和doubleValue方法
- 测试Integer的parseInt方法
- 测试Double的parseDouble方法
1 编写验证Email的正则表达式
1.1 问题
写出与email匹配的正则表达式，并测试该正则表达式的正确性。
1.2 方案
首先，分析email的正则表达式，email的正则表达式如下：
[a-zA-Z0-9_\.-]+@([a-zA-Z0-9-]+\.)+[a-zA-Z0-9]{2,4}
以上正则表达式可以分成三部分，各个部分如下：
1） [a-zA-Z0-9_\.-]+@
表示a~z、A～Z、0～9、下划线、点以及减号可以出现至少1次也可以多次，然后出现@符号。
2） ([a-zA-Z0-9-]+\.)+
这段中的“（）”表示分组，这段正则表示这一组至少出现一次，也可以出现多次。括号中的内容表示，a~z、A～Z、0～9及减号可以至少出现1次也可以出现多次，然后出现“.”字符。
3） [a-zA-Z0-9]{2,4}
表示a~z、A～Z、0～9可以出现大于等于2次，小于等于4次。
其次，使用String类的matches方法，可以测试一个字符串是否和一个正则表达式匹配，matches方法的声明如下：
public boolean matches(String regex)
以上方法表示当字符串和正则表达式regex匹配时返回true，否则，返回false。
1.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：添加测试方法
首先，在名为JavaSE的工程下的src下新建名为day02的包，然后，在该包下新建名为TestRegEx的类，然后在该类中添加测试方法email，代码如下所示：
package day02;
import org.junit.Test;
public class TestRegEx {
#cold_bold /**
#cold_bold *
#cold_bold * 测试email是否合法
#cold_bold */
#cold_bold @Test
#cold_bold public void email() {
#cold_bold }
}
步骤二：测试email正则表达式的正确性
首先，定义字符变量emailRegEx，该变量赋值为正则表达式:
"^[a-zA-Z0-9_\\.-]+@([a-zA-Z0-9-]+\\.)+[a-zA-Z0-9]{2,4}$"
其中，^表示匹配输入的开始位置，$表示匹配输入的结束位置。此处需要注意的是，在正则表达式中“\.”表示的是“.”字符，但是，在Java代码中需要对“\”字符做转意，即“\\”表示一个“\”。因此在定义Java的正则表达式变量emailRegEx时，使用“\\.”来表示一个“.”字符。
然后，测试email（bjliyi@tarena.com.cn）是否和正则表达式emailRegEx匹配，代码如下所示：
package day02;
import org.junit.Test;
public class TestRegEx {
/**
*
* 测试email是否合法
*/
@Test
public void email() {
#cold_bold String emailRegEx =
#cold_bold "^[a-zA-Z0-9_\.-]+@([a-zA-Z0-9-]+\.)+[a-zA-Z0-9]{2,4}$";
#cold_bold
#cold_bold String email = "bjliyi@tarena.com.cn";
#cold_bold
#cold_bold System.out.println(email.matches(emailRegEx));
}
}
步骤三：运行
运行方法email，控制台输出结果如下：
true
从输出结果可以看出email（bjliyi@tarena.com.cn）和正则表达式emailRegEx是匹配的。
1.4 完整代码
package day02;
import org.junit.Test;
public class TestRegEx {
/**
*
* 测试email是否合法
*/
@Test
public void email() {
String emailRegEx =
"^[a-zA-Z0-9_\\.-]+@([a-zA-Z0-9-]+\\.)+[a-zA-Z0-9]{2,4}$";
String email = "bjliyi@tarena.com.cn";
System.out.println(email.matches(emailRegEx));
}
}
2 使用split方法拆分字符串
2.1 问题
使用split方法进行字符串的拆分，具体要求如下所示：
1） 使用空格对字符串"java cpp php c# objective-c"进行拆分。
2） 使用+、-以及=对字符串"100+200-150=150"进行拆分。
2.2 方案
在Java API中的String类提供了split方法，实现使用正则表达式对字符串进行拆分的方法，split方法的声明如下所示：
String[] split(String regex)
以上方法表示以regex所表示的字符串为分隔符，将字符串拆分成字符串数组，其中，参数regex为正则表达式。
2.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：添加测试方法
在TestRegEx中添加测试方法testSplit，代码如下所示：
package day02;
import org.junit.Test;
#cold_boldimport java.util.Arrays;
public class TestRegEx {
#cold_bold /**
#cold_bold * 使用split方法拆分字符串
#cold_bold *
#cold_bold */
#cold_bold @Test
#cold_bold public void testSplit() {
#cold_bold
#cold_bold }
}
步骤二：使用split方法
首先，使用空格对字符串"java cpp php c# objective-c" 进行分割，在正则表达式中，使用“\\s”来表示一个空白字符。
然后，使用+、-以及=对字符串"100+200-150=150"进行拆分，在正则表达式中，使用
"[\\+\\-=]"来表示+、-以及=。代码如下所示：
package day02;
import org.junit.Test;
import java.util.Arrays;
public class TestRegEx {
/**
* 使用split方法拆分字符串
*
*/
@Test
public void testSplit() {
#cold_bold // 按空格拆分
#cold_bold String str = "java cpp php c# objective-c";
#cold_bold String[] strArr = str.split("\\s");
#cold_bold System.out.println(Arrays.toString(strArr));
#cold_bold
#cold_bold // 按+、-、=符号拆分
#cold_bold String line = "100+200-150=150";
#cold_bold strArr = line.split("[\\+\\-=]");
#cold_bold System.out.println(Arrays.toString(strArr));
}
}
步骤三：运行
运行方法testSplit，控制台输出结果如下：
[java, cpp, php, c#, objective-c] [100, 200, 150, 150]
从输出结果可以看出已经将字符串"java cpp php c# objective-c"和字符串"100+200-150=150"按照要求的方式拆分为数组中元素。
2.4 完整代码
本案例中，类TestRegEx的完整代码如下所示：
package day02;
import org.junit.Test;
import java.util.Arrays;
public class TestRegEx {
//...（之前案例的代码，略）
/**
* 使用split方法拆分字符串
*
*/
@Test
public void testSplit() {
// 按空格拆分
String str = "java cpp php c# objective-c";
String[] strArr = str.split("\\s");
System.out.println(Arrays.toString(strArr));
// 按+、-、=符号拆分
String line = "100+200-150=150";
strArr = line.split("[\\+\\-=]");
System.out.println(Arrays.toString(strArr));
}
}
3 使用replaceAll实现字符串替换
3.1 问题
使用replaceAll实现字符串替换，具体要求为将字符串"abc123bcd45ef6g7890"中的数字替换为汉字“数字”，如果是连续的数字，那么替换为一个汉字“数字”。
3.2 方案
在Java API中的String类提供了replaceAll方法，实现将字符串中匹配正则表达式的字符串替换成其它字符串，replaceAll方法的声明如下所示：
String replaceAll(String regex, String replacement)
以上方法实现将字符串中匹配正则表达式regex的字符串替换成replacement。
3.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：添加测试方法
在TestRegEx中添加测试方法testReplaceAll，代码如下所示：
package day02;
import org.junit.Test;
import java.util.Arrays;
public class TestRegEx {
#cold_bold /**
#cold_bold * 使用replaceAll方法实现字符串替换
#cold_bold *
#cold_bold */
#cold_bold @Test
#cold_bold public void testReplaceAll() {
#cold_bold
#cold_bold }
}
步骤二：使用replaceAll方法
将字符串"abc123bcd45ef6g7890"中的数字替换为汉字“数字”，如果是连续的数字，那么替换为一个汉字“数字”，在正则表达式中，使用"[\\d+]"来表示可以出现一个或多个数字，代码如下所示：
package day02;
import org.junit.Test;
import java.util.Arrays;
public class TestRegEx {
/**
* 使用replaceAll方法实现字符串替换
*
*/
@Test
public void testReplaceAll() {
#cold_bold // 将str中的所有数字替换为“数字”二字
#cold_bold String str = "abc123bcd45ef6g7890";
#cold_bold str = str.replaceAll("\\d+", "数字");
#cold_bold System.out.println(str);
}
}
步骤三：运行
运行方法testReplaceAll，控制台输出结果如下：
abc数字bcd数字ef数字g数字
从输出结果可以看出已经将字符串"abc123bcd45ef6g7890"中的数字替换为汉字“数字”。
3.4 完整代码
本案例中，类TestRegEx的完整代码如下所示：
package day02;
import org.junit.Test;
import java.util.Arrays;
public class TestRegEx {
//...（之前案例的代码，略）
/**
* 使用replaceAll方法实现字符串替换
*
*/
@Test
public void testReplaceAll() {
// 将str中的所有数字替换为“数字”二字
String str = "abc123bcd45ef6g7890";
str = str.replaceAll("\\d+", "数字");
System.out.println(str);
}
}
4 重写Cell类的toString方法
4.1 问题
Object是Java的继承root类，Java类继承了Object的所有方法，如: toString(), hashCode(), equals()，其中toString()方法的特点如下:
1），toString() 方法 返回对象的文本描述。
2），经常被系统默认调用, 默认返回: 全限定名@HashCode，默认调用是指输出对象时会默认调用toString方法。
3），建议Java类覆盖toString(), 返回合理的文本。
本案例要求在Cell类中覆盖toString方法，返回行列的值，例如：6，3。
4.2 方案
首先，新建 Cell 类，然后在其中覆盖toString方法，返回row和col的值；
然后，测试toString方法是否覆盖生效。首先，在JavaSE工程下的day02包下新建TestCell，然后，在该类中添加测试方法testToString，最后，实例化一个Cell类的对象，其row、col为6、3，并输出该对象。
4.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：新建Cell类
新建 Cell 类，然后在其中覆盖toString方法，返回row和col的值，代码如下所示：
package day02;
public class Cell {
int row;
int col;
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
public Cell() {
this(0, 0);
}
public Cell(Cell cell) {
this(cell.row, cell.col);
}
public void drop() {
row++;
}
public void moveRight() {
col++;
}
public void moveLeft() {
col--;
}
#cold_bold @Override
#cold_bold public String toString() {
#cold_bold return row + "," + col;
#cold_bold }
}
步骤二：写测试方法
测试toString方法是否覆盖生效。首先，在JavaSE工程下的day02包下新建TestCell，然后，在该类中添加测试方法testToString，最后，实例化一个Cell类的对象，其row、col为6、3，并输出该对象，代码如下所示：
package day02;
import org.junit.Test;
public class TestCell {
/**
* 测试toString方法
*/
@Test
public void testToString() {
Cell cell = new Cell(6, 3);
System.out.println(cell); // 6,3
}
}
步骤三：运行
运行testToString方法，控制台输出结果如下所示：
6,3
从运行结果可以看出，已经成功覆盖了toString方法，返回实际row、col的值6、3。
4.4 完整代码
本案例中，类Cell的完整代码如下所示：
package day02;
public class Cell {
int row;
int col;
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
public Cell() {
this(0, 0);
}
public Cell(Cell cell) {
this(cell.row, cell.col);
}
public void drop() {
row++;
}
public void moveRight() {
col++;
}
public void moveLeft() {
col--;
}
@Override
public String toString() {
return row + "," + col;
}
}
TestCell类完整代码如下：
package day02;
import org.junit.Test;
public class TestCell {
/**
* 测试toString方法
*/
@Test
public void testToString() {
Cell cell = new Cell(6, 3);
System.out.println(cell); // 6,3
}
}
5 重写Cell类的equals方法
5.1 问题
Java程序中测试两个变量是否相等有两种方式：一种是利用==运算符，另一种是利用equals。
当使用==比较两个引用变量时，它们必须指向同一个对象，==判断才会返回true。
equals方法是Object类提供的一个实例方法，因此所有引用变量都可以调用该方法来判断是否与其它引用变量相等。但使用这个方法判断两个对象相等的标准与使用==运算符没有区别，同样要求两个引用变量指向同一个对象才会返回true。因此这个Object类提供的equals方法没有太大的实际意义，如果希望采用自定义的相等标准，则可以采用重写equals方法。
本案例要求在Cell类中重写equals方法，两个Cell引用变量相等的条件是行行相等，列列相等。
5.2 方案
首先，在上一案例的基础上，在Cell类中覆盖equals方法，两个Cell引用变量相等的条件是行行相等，列列相等
然后，测试equals方法是否覆盖生效。首先，在类TestCell中添加测试方法testEquals，然后，创建cell1对象和cell2对象，代码如下：
Cell cell1 = new Cell(6, 3); Cell cell2 = new Cell(6, 3);
最后分别使用==和equals比较cell1对象和cell2对象是否相等。
5.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：在Cell类中覆盖equals方法
在上一案例的基础上，在Cell类中覆盖equals方法，两个Cell引用变量调用equals方法返回true的条件是行行相等，列列相等，代码如下所示：
package day02;
public class Cell {
int row;
int col;
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
public Cell() {
this(0, 0);
}
public Cell(Cell cell) {
this(cell.row, cell.col);
}
public void drop() {
row++;
}
public void moveRight() {
col++;
}
public void moveLeft() {
col--;
}
@Override
public String toString() {
return row + "," + col;
}
#cold_bold @Override
#cold_bold public boolean equals(Object obj) {
#cold_bold if (obj == null) {
#cold_bold return false;
#cold_bold }
#cold_bold if (this == obj) {
#cold_bold return true;
#cold_bold }
#cold_bold if (obj instanceof Cell) {
#cold_bold Cell cell = (Cell) obj;
#cold_bold return cell.row == row && cell.col == col;
#cold_bold } else {
#cold_bold return false;
#cold_bold }
#cold_bold }
}
步骤二：测试equals方法是否生效
测试equals方法是否覆盖生效。首先，在类TestCell中添加测试方法testEquals，然后，创建cell1对象和cell2对象； 最后分别使用==和equals比较cell1对象和cell2对象是否相等，代码如下所示：
package day02;
import org.junit.Test;
public class TestCell {
#cold_bold /**
#cold_bold * 测试equals方法
#cold_bold */
#cold_bold @Test
#cold_bold public void testEquals() {
#cold_bold Cell cell1 = new Cell(6, 3);
#cold_bold Cell cell2 = new Cell(6, 3);
#cold_bold System.out.println(cell1 == cell2); // false
#cold_bold System.out.println(cell1.equals(cell2)); // true
#cold_bold
#cold_bold }
}
步骤三：运行
运行testEquals方法，控制台输出结果如下所示：
false true
从运行结果可以看出，使用==比较的结果为false、使用equals比较的结果为true，说明Cell类成功覆盖了equals方法，实现了行行相等并且列列相等两个Cell的引用变量则相等。
5.4 完整代码
本案例中，类Cell的完整代码如下所示：
package day02;
public class Cell {
int row;
int col;
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
public Cell() {
this(0, 0);
}
public Cell(Cell cell) {
this(cell.row, cell.col);
}
public void drop() {
row++;
}
public void moveRight() {
col++;
}
public void moveLeft() {
col--;
}
@Override
public String toString() {
return row + "," + col;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (this == obj) {
return true;
}
if (obj instanceof Cell) {
Cell cell = (Cell) obj;
return cell.row == row && cell.col == col;
} else {
return false;
}
}
}
TestCell类完整代码如下：
package day02;
import org.junit.Test;
public class TestCell {
//...（之前案例的代码，略）
/**
* 测试equals方法
*/
@Test
public void testEquals() {
Cell cell1 = new Cell(6, 3);
Cell cell2 = new Cell(6, 3);
System.out.println(cell1 == cell2); // false
System.out.println(cell1.equals(cell2)); // true
}
}
6 测试Number的intValue和doubleValue方法
6.1 问题
在Java中，抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类。该类提供了六个方法，如图-1所示。
图- 1
以上六个方法中，floatValue方法和doubleValue方法在使用时，可能涉及到舍入；其它四个方法可能涉及到舍入或者取整。
本案例要求测试Number类的intValue方法和doubleValue方法，即，首先，定义Number类型的两个变量：
Number d = 123.45; Number n = 123;
要求获取d对象和n对象所属的数据类型。
然后，将d对象分别转换为int类型变量和double类型变量，并输出转换后的结果。
最后，将n对象分别转换为int类型变量和double类型变量，并输出转换后的结果。
6.2 方案
首先，构建包和类，并在类中新建测试方法。
其次，使用代码d.getClass().getName()和代码n.getClass().getName()获取d对象和n对象所属的数据类型。此处只需了解这样可以获取对象所属数据类型即可。
第三，使用Number类的 intValue方法和doubleValue方法，将d对象分别转换为int类型变量和double类型变量，并输出转换后的结果。
第四，使用Number类的 intValue方法和doubleValue方法，将n对象分别转换为int类型变量和double类型变量，并输出转换后的结果。
6.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建包、类以及测试方法
首先在day02包下新建名为TestNumber的类，然后在该类中新建测试方法testIntValueAndDoubleValue，代码如下所示：
package day02;
import org.junit.Test;
public class TestNumber {
/**
* 测试Number的intValue方法和doubleValue方法
*/
@Test
public void testIntValueAndDoubleValue() {
}
}
步骤二：获取Number类的对象所属类型
使用代码d.getClass().getName()和代码n.getClass().getName()获取d对象和n对象所属的数据类型。此处只需了解这样可以获取对象所属数据类型即可。代码如下所示：
package day02;
import org.junit.Test;
public class TestNumber {
/**
* 测试Number的intValue方法和doubleValue方法
*/
@Test
public void testIntValueAndDoubleValue() {
#cold_bold Number d = 123.45;
#cold_bold Number n = 123;
#cold_bold
#cold_bold // 输出d和n对象所属的类型
#cold_bold System.out.println(d.getClass().getName()); // java.lang.Double
#cold_bold System.out.println(n.getClass().getName()); // java.lang.Integer
}
}
步骤三：运行
运行步骤二中的testIntValueAndDoubleValue方法，控制台输出结果如下所示：
java.lang.Double java.lang.Integer
从输出结果可以看出，d的所属类型为Double，n的所属类型为Integer，这是因为，123.45该直接量的类型为double，经过自动装箱以后转换为Double类型，Double类型是Number类型的子类，子类类型转换为父类类型属于自动类型转换，因此，d的所属类型为Double，同理，n的所属类型为Integer。
步骤四：将d对象分别转换为int类型变量和double类型变量
使用Number类的 intValue方法和doubleValue方法，将d对象分别转换为int类型变量和double类型变量，并输出转换后的结果，代码如下所示：
package day02;
import org.junit.Test;
public class TestNumber {
/**
* 测试Number的intValue方法和doubleValue方法
*/
@Test
public void testIntValueAndDoubleValue() {
Number d = 123.45;
Number n = 123;
// 输出d和n对象所属的类型
System.out.println(d.getClass().getName()); // java.lang.Double
System.out.println(n.getClass().getName()); // java.lang.Integer
#cold_bold int intValue = d.intValue();
#cold_bold double doubleValue = d.doubleValue();
#cold_bold System.out.println(intValue + "," + doubleValue); // 123,123.45
}
}
步骤五：运行
运行方法testIntValueAndDoubleValue，最后一条输出语句的输出内容为：
123,123.45
从输出结果上可以看出，将原本Double类型的对象d，转换为int类型后，取了d对象的整数部分。但转换为double类型后没有变化。
步骤六：将n对象分别转换为int类型变量和double类型变量
使用Number类的 intValue方法和doubleValue方法，将n对象分别转换为int类型变量和double类型变量，并输出转换后的结果。
package day02;
import org.junit.Test;
public class TestNumber {
/**
* 测试Number的intValue方法和doubleValue方法
*/
@Test
public void testIntValueAndDoubleValue() {
Number d = 123.45;
Number n = 123;
// 输出d和n对象所属的类型
System.out.println(d.getClass().getName()); // java.lang.Double
System.out.println(n.getClass().getName()); // java.lang.Integer
int intValue = d.intValue();
double doubleValue = d.doubleValue();
System.out.println(intValue + "," + doubleValue); // 123,123.45
#cold_bold intValue = n.intValue();
#cold_bold doubleValue = n.doubleValue();
#cold_bold System.out.println(intValue + "," + doubleValue); // 123,123.0
}
}
步骤七：运行
再次运行testIntValueAndDoubleValue方法，最后一条输出语句的输出内容为：
123,123.0
从输出结果上可以看出，将原本Integer类型的对象n，转换为double类型后，小数点后保留一位小数。但转换为int类型后没有变化。
6.4 完整代码
本案例的完整代码如下所示：
package day02;
import org.junit.Test;
public class TestNumber {
/**
* 测试Number的intValue方法和doubleValue方法
*/
@Test
public void testIntValueAndDoubleValue() {
Number d = 123.45;
Number n = 123;
// 输出d和n对象所属的类型
System.out.println(d.getClass().getName()); // java.lang.Double
System.out.println(n.getClass().getName()); // java.lang.Integer
int intValue = d.intValue();
double doubleValue = d.doubleValue();
System.out.println(intValue + "," + doubleValue); // 123,123.45
intValue = n.intValue();
doubleValue = n.doubleValue();
System.out.println(intValue + "," + doubleValue); // 123,123.0
}
}
7 测试Integer的parseInt方法
7.1 问题
测试Integer的parseInt方法,即，首先将字符串“123”转换为int类型并输出结果，然后，将字符串"壹佰贰拾叁"转换为int类型，并查看运行效果。
7.2 方案
首先，使用Integer的parseInt方法，将字符串“123”转换为int类型，正常运行并可以输出int类型的值123；然后，再次使用Integer的parseInt方法，将字符串"壹佰贰拾叁"转换为int类型，运行后，会出现异常。
7.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
在day02包下新建类TestInteger，在该类中添加单元测试方法testParseInt，代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
/**
* 测试Integer的parseInt方法
*/
@Test
public void testParseInt() {
}
}
步骤二：将字符串“123”转成整数类型
使用Integer的parseInt方法，将字符串“123”转换为int类型，正常运行并可以输出int类型的值123，代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
/**
* 测试Integer的parseInt方法
*/
@Test
public void testParseInt() {
#cold_bold String str = "123";
#cold_bold int value = Integer.parseInt(str);
#cold_bold System.out.println(value); // 123
}
}
运行上述代码，控制台输出结果为：
123
说明已经成功的将字符串“123”转换成int类型的123。
步骤三：字符串"壹佰贰拾叁"转换为int类型
再次使用Integer的parseInt方法，将字符串"壹佰贰拾叁"转换为int类型，代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
/**
* 测试Integer的parseInt方法
*/
@Test
public void testParseInt() {
String str = "123";
int value = Integer.parseInt(str);
System.out.println(value); // 123
#cold_bold str = "壹佰贰拾叁";
#cold_bold // 会抛出NumberFormatException
#cold_bold value = Integer.parseInt(str);
}
}
运行上述代码后，会出现异常:
java.lang.NumberFormatException: For input string: "壹佰贰拾叁"
从异常情况可以看出，Java程序无法将字符串"壹佰贰拾叁"转换为int类型，因此，抛出了java.lang.NumberFormatException异常。所以在使用Integer的parseInt方法时，要注意传入的方法的参数为数字。
7.4 完整代码
本案例中，类TestInteger的完整代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
/**
* 测试Integer的parseInt方法
*/
@Test
public void testParseInt() {
String str = "123";
int value = Integer.parseInt(str);
System.out.println(value); // 123
str = "壹佰贰拾叁";
// 会抛出NumberFormatException
// value = Integer.parseInt(str);
}
}
8 测试Double的parseDouble方法
8.1 问题
测试Double的parseDouble方法,即，首先将字符串“12345.00”转换为double类型并输出结果，然后，将字符串"￥12345.00"转换为double类型，并查看运行效果。
8.2 方案
首先，使用Double的parseDouble方法，将字符串“12345.00”转换为double类型，正常运行并可以输出double类型的值12345.00； 然后，再次使用Double的parseDouble方法，将字符串"￥12345.00"转换为double类型，运行后，会出现异常。
8.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
在TestInteger类中添加单元测试方法testParseDouble，代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
#cold_bold /**
#cold_bold *测试Double的parseDouble方法
#cold_bold */
#cold_bold @Test
#cold_bold public void testParseDouble() {
#cold_bold
#cold_bold }
}
步骤二：将字符串“12345.00”转成double类型
使用Double的parseDouble方法，将字符串“12345.00”转换为double类型，正常运行并可以输出double类型的值12345.0，代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
/**
*测试Double的parseDouble方法
*/
@Test
public void testParseDouble() {
#cold_bold String str = "12345.00";
#cold_bold double value = Double.parseDouble(str); // 12345.0
#cold_bold System.out.println(value);
}
}
运行上述代码，控制台输出结果为：
12345.0
说明已经成功的将字符串“12345.00”转换成double类型的12345.0。
步骤三：字符串"￥12345.00"转换为double类型
再次使用Double的parseDouble方法，将字符串"￥12345.00"转换为double类型，代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
/**
*测试Double的parseDouble方法
*/
@Test
public void testParseDouble() {
String str = "12345.00";
double value = Double.parseDouble(str); // 12345.0
System.out.println(value);
#cold_bold
#cold_bold str = "￥12345.00";
#cold_bold // 会抛出NumberFormatException
#cold_bold // value = Double.parseDouble(str);
}
}
运行上述代码后，会出现异常:
java.lang.NumberFormatException: For input string: "￥12345.00"
从异常情况可以看出，Java程序无法将字符串"￥12345.00"转换为double类型，因此，抛出了java.lang.NumberFormatException异常。所以在使用Double的parseDouble方法时，要注意传入的方法的参数为数字。
8.4 完整代码
本案例中，类TestInteger的完整代码如下所示：
package day02;
import org.junit.Test;
public class TestInteger {
//...（之前案例的代码，略）
/**
*测试Double的parseDouble方法
*/
@Test
public void testParseDouble() {
String str = "12345.00";
double value = Double.parseDouble(str); // 12345.0
System.out.println(value);
str = "￥12345.00";
// 会抛出NumberFormatException
// value = Double.parseDouble(str);
}
}