【JAVA SE】第十一章 正则表达式、包装类和BigDecimal
第十一章 正则表达式、包装类和BigDecimal
文章目录
- 第十一章 正则表达式、包装类和BigDecimal
- 一、正则表达式
- 二、包装类
-
- 1.概述
- 2.装箱与拆箱：
- 3.基本数据和包装类之间的转换
- 4.基本数据类型和包装类的转换
- 5.包装类对象之间的比较：
- 三、BigDecimal
-
- 1.概述
- 2.常用构造函数
- 3.常用方法
- 4.大小比较
一、正则表达式
本篇仅对正则表达式作简单介绍，不做深入解析
正则表达式定义了字符串的模式
正则表达式可以用来搜索、编辑或处理文本
正则表达式并不仅限于某一种语言，在不同语言中有细微的差别
实例：
一个字符串其实就是一个简单的正则表达式，例如 Hello World 正则表达式匹配 “Hello World” 字符串
.（点号）也是一个正则表达式，它匹配任何一个字符如：“a” 或 “1”
this is text
匹配字符串 “this is text”
this\s+is\s+text
注意字符串中的 \s+
匹配单词 “this” 后面的 \s+ 可以匹配多个空格，之后匹配 is 字符串，在之后 \s+ 匹配多个空格然后再跟上 text 字符串
可以匹配这个实例：this is text
^\d+(.\d+)?
^ 定义了以什么开始
\d 匹配一个或多个数字
? 设置括号内的选项是可选的
. 匹配 “.”
可以匹配的实例：“5”，“1.5” 和 “2.21”
Java 正则表达式和 Perl 的是最为相似的
java.util.regex 包主要包括以下三个类：
- Pattern 类：
pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern对象。该方法接受一个正则表达式作为它的第一个参数 - Matcher 类：
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与 Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象 - PatternSyntaxException：
PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误
以下实例实现了查找字符串中是否包含了 sisyphus 子串：
import java.util.regex.*;
class RegexExample1{
public static void main(String[] args){
String content = "I am demo" +
"from sisyphus.com.";
String pattern = ".*sisyphus.*";
boolean isMatch = Pattern.matches(pattern, content);
System.out.println("字符串中是否包含了 'sisyphus' 子字符串? " + isMatch);
}
}
运行结果：
字符串中是否包含了 ‘sisyphus’ 子字符串? true
以下实例实现了判断身份证号格式是否正确：
package com.sisyphus.regex;
import java.util.Scanner;
public class TestRegex {
public static void main(String[] args) {
//1.接收身份证号
System.out.println("请输入您的身份证号：");
String input = new Scanner(System.in).nextLine();
//2.编辑正则表达式
//身份证号的规律：一般都是 18 位，前 17 位是数字
//最后一位可能是数字，也可能是 X
//单个 \ 在 java 中有特殊的意义，会认为这是一个转义字符
//如果想使用 \ 需要在 \ 前面再加一个 \ 也就是 \\
String regex = "\\d{17}[0-9X]";
//3.判断用户输入的数据是否符合正则的规则
if (input.matches(regex)){
System.out.println("身份证号格式正确");
}else{
System.out.println("身份证格式错误！");
}
}
}
运行结果：
请输入您的身份证号：
12345620001010789X
身份证号格式正确
请输入您的身份证号：
X12345678912345678
身份证格式错误！
二、包装类
1.概述
Java 中的基本数据类型没有属性和方法，而包装类就是为了让它们拥有属性和方法，实现对象化交互
| 基本类型 | 对应的包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
数值型包装类都继承自 Number，而字符型和布尔型继承自 Object
2.装箱与拆箱：
- 装箱：基本数据类型转换为包装类
- 拆箱：包装类转换为基本数据类型
自动装箱与自动拆箱实例：
package com.sisyphus.temp;
public class Number {
public static void main(String[] args) {
//1.定义包装类型的数据
//回顾：以前创建包装类型的两种方式
Integer i1 = new Integer(127);
Integer i2 = Integer.valueOf(127);
//2.现在的方式
/**1.自动装箱：编译器会自动把基本类型 int 包装成包装类型 Integer
* 然后交给 i3 来保存，自动装箱底层发生的阿代码是 Integer.valueOf();
* valueOf() 的转换方向：int -> Integer*/
Integer i3 = 5;//不会报错，这个现象就是自动装箱
/**2.自动拆箱：编译器会自动把包装类型的 i1 拆掉“箱子”，变回基本数据类型
* 然后交给 i4 来保存，自动拆箱底层发生的代码是 i1.intValue();
* intValue() 的转换方向：Integer -> int*/
int i4 = i1;//不会报错，这个现象就是自动拆箱
}
}
3.基本数据和包装类之间的转换
package com.sisyphus.temp;
public class Number {
public static void main(String[] args) {
//1.自动装箱
int t1 = 1;
Integer t2 = t1;
//2.手动装箱
Integer t3 = new Integer(t1);
System.out.println("int 类型 t1 = " + t1);
System.out.println("自动装箱，Integer 类型对象 t2 =" + t2);
System.out.println("手动装箱，Integer 类型对象 t3 =" + t3);
//1.自动拆箱
int t4 = t2;
//2.手动拆箱
//通过 intValue() 方法返回 int 值
int t5 = t2.intValue();
System.out.println("自动拆箱，int 型 t4 = " + t4);
System.out.println("手动拆箱，int 型 t5 = " + t5);
}
}
int 类型 t1 = 1
自动装箱，Integer 类型对象 t2 =1
手动装箱，Integer 类型对象 t3 =1
自动拆箱，int 型 t4 = 1
手动拆箱，int 型 t5 = 1
4.基本数据类型和包装类的转换
package com.sisyphus.temp;
public class Number {
public static void main(String[] args) {
//1.1将基本数据类型转换为字符串
int t1 = 12;
String t2 = Integer.toString(t1);
System.out.println("int 转换为 String：" + t2);
//1.2通过 parseInt()，将字符串转换为基本数据类型
int t3 = Integer.parseInt(t2);
//2.通过 valueOf()，先把字符串转换为包装类，然后自动拆箱完成转换
int t4 = Integer.valueOf(t2);
System.out.println("t3：" + t3);
System.out.println("t4：" + t4);
}
}
运行结果：
int 转换为 String：12
t3：12
t4：12
5.包装类对象之间的比较：
package com.sisyphus.temp;
public class Number {
public static void main(String[] args) {
Integer one = new Integer(100);
Integer two = new Integer(100);
//one 和 two 是两个不同的对象，== 比较的是内存地址，因此结果为 false
System.out.println("one == two：" + (one == two));
//自动装箱，实际执行的是 Integer three = Integer.valueOf(100)
// 这时缓存区没有，会构造一个
Integer three = 100;
System.out.println("three == 100：" + (three == 100));//自动拆箱
//这时缓存区有，就会直接取用
/**Java 为了提高拆箱效率，在执行过程中提供了一个缓存区（对象池）【类似于常量数组】
* 如果传入的参数在区间 [-128，127] 之间，就会直接去缓存查找数据，如果有就直接取用
* 如果没有就隐式调用 new 方法*/
Integer four = 100;
System.out.println("three == four：" + (three == four));//之所以加括号是因为 + 的优先级比 == 大
//测试一下超过 200 的数
Integer five = 200;
System.out.println("five == 200：" + (five == 200));
Integer six = 200;
System.out.println("five == six：" + (five == six));
}
}
运行结果：
one == two：false
three == 100：true
three == four：true
five == 200：true
five == six：false
三、BigDecimal
1.概述
Java 在 java.math 包中提供的 API 类 BigDecimal，用来对超过 16 位有效位的数进行精确的运算。双精度浮点型变量 double 可以处理 16 位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理
一般情况下，对于那些不需要精确计算精度的数字，我们可以直接使用 Float 和 Double 处理，但是 Double.valueOf(String) 和 Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用 BigDecimal 类来操作
BigDecimal 所创建的是对象，故我们不能使用传统的 +、-、×、/ 等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是 BigDecimal 对象
2.常用构造函数
- BigDecimal(int)
创建一个具有参数所指定整数值的对象 - BigDecimal(double)
创建一个具有参数所指定双精度值的对象 - BigDecimal(long)
创建一个具有参数所指定长整数值的对象 - BigDecimal(String)
创建一个具有参数所指定以字符串表示的数值的对象
实例：
BigDecimal a =new BigDecimal(0.1);
System.out.println("a values is:"+a);
BigDecimal b =new BigDecimal("0.1");
System.out.println("b values is:"+b);
运行结果：
a values is:0.1000000000000000055511151231257827021181583404541015625
b values is:0.1
原因分析：
参数类型为 double 的构造方法的结果有一定的不可预知性，有人可能认为在 Java 中写入 newBigDecimal(0.1) 所创建的 BigDecimal 正好等于 0.1 ，但是它实际上等于 0.1000000000000000055511151231257827021181583404541015625。这是因为 0 无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）
而String 构造方法是完全可预知的，new BigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1.因此，通常建议优先使用 String 构造方法
当 double 必须用作 BigDecmal 的源时，采取以下操作：
先使用 Double.toString(double) 方法，然后使用 BigDecimal(String) 构造方法，最后要获取该结果，使用 static valueOf(double)
package com.sisyphus.bigdecimal;
import java.math.BigDecimal;
import java.util.Scanner;
/**本类用作浮点数运算不精确的解决方案*/
public class TestBigDecimal {
public static void main(String[] args) {
f2();//使用 BigDecimal 解决浮点数运算不精确的问题
}
private static void f1() {
System.out.println("请输入您要计算的第一个数");
Scanner scanner = new Scanner(System.in);
double a = scanner.nextDouble();
System.out.println("请输入您要计算的第二个数");
Scanner scanner1 = new Scanner(System.in);
double b = scanner1.nextDouble();
//2.创建工具类对象
BigDecimal bd1 = new BigDecimal(String.valueOf(a));//传 Stirng 类型的参数
BigDecimal bd2 = new BigDecimal(String.valueOf(b));//传 Stirng 类型的参数
//3.通过工具类对象进行四则运算
//定义同类型的 BigDecimal引用类型变量来保存结果
BigDecimal bd3;//用于保存结果
bd3 = bd1.add(bd2);//做加法运算
System.out.println(bd3);
bd3 = bd1.subtract(bd2);//做减法运算
System.out.println(bd3);
bd3 = bd1.multiply(bd2);//做乘法运算
System.out.println(bd3);
//divide(除数，保留位数，舍入方式【四舍五入】)
bd3 = bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);//做除法运算
System.out.println(bd3);
}
}
运行结果:：
请输入您要计算的第一个小数
请输入您要计算的第一个小数
10
请输入您要计算的第二个小数
3
13.0
7.0
30.00
3.333
3.常用方法
- add(BigDecimal)
BigDecimal 对象中的值相加，返回 BigDecimal 对象 - subtract(BigDecimal)
BigDecimal 对象中的值相减，返回 BigDecimal 对象 - multiply(BigDecimal)
BigDecimal 对象中的值相乘，返回 BigDecimal 对象 - divide(BigDecimal)
BigDecimal 对象中的值相除，返回 BigDecimal 对象 - toString()
将 BigDecimal 对象中的值转换成字符串 - doubleValue()
将 BigDecimal 对象中的值转换成双精度数 - floatValue()
将 BigDecimal 对象中的值转换成单精度数 - longValue()
将 BigDecimal 对象中的值转换成长整数 - intValue()
将 BigDecimal 对象中的值转换成整数
4.大小比较
Java 中对 BigDecimal 比较大小一般用的是 compareTo() 方法
int a = bigdecimal.compareTo(bigdecimal2)
a 的值：
a = -1，表示 bigdecimal 小于 bigdecimal2
a = 0，表示 bigdecimal 等于 bigdecimal2
a = 1，表示 bigdecimal 大于 bigdecimal2