第十一章 正则表达式、包装类和BigDecimal

一、正则表达式

常用的正则表达式，本篇仅对正则表达式作简单介绍，不做深入解析

正则表达式定义了字符串的模式
正则表达式可以用来搜索、编辑或处理文本
正则表达式并不仅限于某一种语言，在不同语言中有细微的差别

实例：
一个字符串其实就是一个简单的正则表达式，例如 Hello World 正则表达式匹配 “Hello World” 字符串

java正则表达式教程。.（点号）也是一个正则表达式，它匹配任何一个字符如：“a” 或 “1”

this is text
匹配字符串 “this is text”

this\s+is\s+text
注意字符串中的 \s+
匹配单词 “this” 后面的 \s+ 可以匹配多个空格，之后匹配 is 字符串，在之后 \s+ 匹配多个空格然后再跟上 text 字符串
可以匹配这个实例：this is text

正则表达式java使用。^\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 是一个非强制异常类，它表示一个正则表达式模式中的语法错误

java正则表达式转义、以下实例实现了查找字符串中是否包含了 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

java包类。以下实例实现了判断身份证号格式是否正确：

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
身份证号格式正确

JAVA安装教程，请输入您的身份证号：
X12345678912345678
身份证格式错误！

二、包装类

1.概述

Java 中的基本数据类型没有属性和方法，而包装类就是为了让它们拥有属性和方法，实现对象化交互

数值型包装类都继承自 Number，而字符型和布尔型继承自 Object

2.装箱与拆箱：

• 装箱：基本数据类型转换为包装类
• 拆箱：包装类转换为基本数据类型

JAVA。自动装箱与自动拆箱实例：

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 是两个不同的对象，== 比较的是内存地址，因此结果为 falseSystem.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