自学Java第16Day

兜兜零元 · 2024-8-1 20:59:49

学习目的：面向对象进阶

学习内容：Object、Objects、BigInteger、BigDecimal、正则表达式

学习时间：下午 3 点-下午 6 点

学习产出：

1. Object类

1.1 概述

查看API文档，我们可以看到API文档中关于Object类的定义如下：

Object类地点包是java.lang包。Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类；换句话说，该类所具备的方法，其他所有类都继承了。
但是一样寻常环境下我们很少去主动的创建Object类的对象，调用其对应的方法。更多的是创建Object类的某个子类对象，然后通过子类对象调用Object类中的方法。
1.2 常见方法

> tips：重点讲解内容
<font color=“red” size=“3”>常见方法先容</font>
我们要学习的Object类中的常见方法如下所示：

public String toString() //返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj) //比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone() //对象克隆

复制代码

接下来我们就来通过一些案例演示一下这些方法的特点。
1.2.1 toString方法

实现步骤：

创建一个门生类，提供两个成员变量（name ， age）；并且提供对应的无参构造方法和有参构造方法以及get/set方法
创建一个测试类（ObjectDemo01），在测试类的main方法中去创建门生对象，然后调用该对象的toString方法获取该对象的字符串体现形式，并将结果进行输出

如下所示：
Student类

public class Student {
private String name ; // 姓名
private String age ; // 年龄
// 无参构造方法和有参构造方法以及get和set方法略
...
}

复制代码

public class ObjectDemo01 {
public static void main(String[] args) {
// 创建学生对象
Student s1 = new Student("蛋姐" , "21") ;
// 调用toString方法获取s1对象的字符串表现形式
String result1 = s1.toString();
// 输出结果
System.out.println("s1对象的字符串表现形式为：" + result1);
}
}

复制代码

运行结果：

s1对象的字符串表现形式为：hello.api.system.demo04.Student@3f3afe78

复制代码

为什么控制台输出的结果为：hello.api.system.demo04.Student@3f3afe78；此时我们可以查看一下Object类中toString方法的源码，如下所示：

public String toString() { // Object类中toString方法的源码定义
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

复制代码

此中getClass().getName()对应的结果就是：hello.api.system.demo04.Student；Integer.toHexString(hashCode())对应的结果就是3f3afe78。
我们常常将"hello.api.system.demo04.Student@3f3afe78"这一部门称之为对象的内存地址值。但是一样寻常环境下获取对象的内存地址值没有太大的意义。获取对象的成员变量的字符串拼接形式才算故意义，怎么实现呢？此时我们就需要在Student类中重写Object的toString方法。

@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
'}';
}

复制代码

这段代码就是把Student类中的成员变量进行了字符串的拼接。重写完毕以后，再次运行程序，控制台输出结果如下所示：

s1对象的字符串表现形式为：Student{name='蛋姐', age='21'}

复制代码

此时我们就可以清楚的查看Student的成员变量值，因此重写toString方法的意义就是以精良的格式，更方便的展示对象中的属性值
我们再来查看一下如下代码的输出：

// 创建学生对象
Student s1 = new Student("itheima" , "21") ;
// 直接输出对象s1
System.out.println(s1);

复制代码

运行结果：

Student{name='蛋姐', age='21'}

复制代码

我们可以看到和刚才的输出结果是一致的。那么此时也就证明直接输出一个对象，那么会默认调用对象的toString方法，因此如上代码的等同于如下代码：

// 创建学生对象
Student s1 = new Student("itheima" , "14") ;
// 调用s1的toString方法，把结果进行输出
System.out.println(s1.toString());

复制代码

小结：

在通过输出语句输出一个对象时，默认调用的就是toString()方法
输出地址值一样寻常没故意义，我们可以通过重写toString方法去输出对应的成员变量信息（快捷键：atl + insert ，空白处右键 -> Generate -> 选择toString）
toString方法的作用：以精良的格式，更方便的展示对象中的属性值
一样寻常环境下Jdk所提供的类都会重写Object类中的toString方法

1.2.2 equals方法

实现步骤：
在测试类（ObjectDemo02）的main方法中，创建两个门生对象，然后比较两个对象是否雷同。
代码如下所示：

public class ObjectDemo02 {
public static void main(String[] args) {
// 创建两个学生对象
Student s1 = new Student("蛋姐" , "21") ;
Student s2 = new Student("蛋姐" , "21") ;
// 比较两个对象是否相等
System.out.println(s1 == s2);
}
}

复制代码

运行结果：

false

复制代码

因为"=="号比较的是对象的地址值，而我们通过new关键字创建了两个对象，它们的地址值是不雷同的。因此比较结果就是false。
我们实验调用Object类中的equals方法进行比较，代码如下所示：

// 调用equals方法比较两个对象是否相等
boolean result = s1.equals(s2);
// 输出结果
System.out.println(result);

复制代码

运行结果：

false

复制代码

为什么结果照旧false呢？我们可以查看一下Object类中equals方法的源码，如下所示：

public boolean equals(Object obj) { // Object类中的equals方法的源码
return (this == obj);
}

复制代码

通过源码我们可以发现默认环境下equals方法比较的也是对象的地址值。比较内存地址值一样寻常环境下是没故意义的，我们盼望比较的是对象的属性，假如两个对象的属性雷同，我们认为就是同一个对象；
那么要比较对象的属性，我们就需要在Student类中重写Object类中的equals方法。equals方法的重写，我们也可以利用idea开发工具完成。

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return Objects.equals(name, student.name) && Objects.equals(age, student.age); // 比较的是对象的name属性值和age属性值
}

复制代码

true

复制代码

此时equals方法比较的是对象的成员变量值，而s1和s2两个对象的成员变量值都是雷同的。因此比较完毕以后的结果就是true。
小结：

默认环境下equals方法比较的是对象的地址值
比较对象的地址值是没故意义的，因此一样寻常环境下我们都会重写Object类中的equals方法

1.2.3 对象克隆的分类

        浅克隆：
        不管对象内部的属性是根本数据类型照旧引用数据类型，都完全拷贝过来。
        根本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。
        Object类默认的是浅克隆。
        深克隆：
         根本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的。

public class ObjectDemo4 {
public static void main(String[] args) throws CloneNotSupportedException {
// protected object clone(int a) 对象克隆
//1.先创建一个对象
int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};
User u1 = new User(1, "蛋姐", "1234qwer", "girl11", data);
//2.克隆对象
//细节:
//方法在底层会帮我们创建一个对象,并把原对象中的数据拷贝过去。
//书写细节:
//1.重写Object中的clone方法
//2.让javabean类实现Cloneable接口
//3.创建原对象并调用clone就可以了
//User u2 =(User)u1.clone();
//验证一件事情：Object中的克隆是浅克隆
//想要进行深克隆，就需要重写clone方法并修改里面的方法体
//int[] arr = u1.getData();
//arr[0] = 100;
//System.out.println(u1);
//System.out.println(u2);
//以后一般会用第三方工具进行克隆
//1.第三方写的代码导入到项目中
//2.编写代码
//Gson gson =new Gson();
//把对象变成一个字符串
//String s=gson.toJson(u1);
//再把字符串变回对象就可以了
//User user =gson.fromJson(s, User.class);
//int[] arr=u1.getData();
//arr[0] = 100;
//打印对象
//System.out.println(user);
}
}
import java.util.StringJoiner;
//Cloneable
//如果一个接口里面没有抽象方法
//表示当前的接口是一个标记性接口
//现在Cloneable表示一旦实现了，那么当前类的对象就可以被克降
//如果没有实现，当前类的对象就不能克隆
public class User implements Cloneable {
private int id;
private String username;
private String password;
private String path;
private int[] data;
public User() {
}
public User(int id, String username, String password, String path, int[] data) {
this.id = id;
this.username = username;
this.password = password;
this.path = path;
this.data = data;
}
/**
* 获取
*
* @return id
*/
public int getId() {
return id;
}
/**
* 设置
*
* @param id
*/
public void setId(int id) {
this.id = id;
}
/**
* 获取
*
* @return username
*/
public String getUsername() {
return username;
}
/**
* 设置
*
* @param username
*/
public void setUsername(String username) {
this.username = username;
}
/**
* 获取
*
* @return password
*/
public String getPassword() {
return password;
}
/**
* 设置
*
* @param password
*/
public void setPassword(String password) {
this.password = password;
}
/**
* 获取
*
* @return path
*/
public String getPath() {
return path;
}
/**
* 设置
*
* @param path
*/
public void setPath(String path) {
this.path = path;
}
/**
* 获取
*
* @return data
*/
public int[] getData() {
return data;
}
/**
* 设置
*
* @param data
*/
public void setData(int[] data) {
this.data = data;
}
public String toString() {
return "角色编号为：" + id + "，用户名为：" + username + "密码为：" + password + ", 游戏图片为:" + path + ", 进度:" + arrToString();
}
public String arrToString() {
StringJoiner sj = new StringJoiner(", ", "[", "]");
for (int i = 0; i < data.length; i++) {
sj.add(data[i] + "");
}
return sj.toString();
}
@Override
protected Object clone() throws CloneNotSupportedException {
//调用父类中的clone方法
//相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。
//先把被克隆对象中的数组获取出来
int[] data = this.data;
//创建新的数组
int[] newData =new int[data.length];
//拷贝数组中的数据
for (int i = 0; i < data.length; i++) {
newData[i] = data[i];
}
//调用父类中的方法克隆对象
User u=(User)super.clone();
//因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
u.data =newData;
return u;
}
}

复制代码

2.Objects类

2.1 概述

查看API文档，我们可以看到API文档中关于Objects类的定义如下：

        Objects类地点包是在java.util包下，因此在利用的时间需要进行导包。并且Objects类是被final修饰的，因此该类不能被继承。
        Objects类提供了一些对象常见操作的方法。好比判断对象是否相等，判断对象是否为null等等。
        我们可以发现Objects类中无无参构造方法，因此我们不能利用new关键字去创建Objects的对象。同时我们可以发现Objects类中所提供的方法都是静态的。因此我们可以通过类名直接去调用这些方法。
2.2 常见方法

        我们要重点学习的Objects类中的常见方法如下所示：

public static String toString(Object o) // 获取对象的字符串表现形式
public static boolean equals(Object a, Object b) // 比较两个对象是否相等
public static boolean isNull(Object obj) // 判断对象是否为null
public static boolean nonNull(Object obj) // 判断对象是否不为null

复制代码

我们要了解的Objects类中的常见方法如下所示：

public static <T> T requireNonNull(T obj) // 检查对象是否不为null,如果为null直接抛出异常；如果不是null返回该对象；
public static <T> T requireNonNullElse(T obj, T defaultObj) // 检查对象是否不为null，如果不为null，返回该对象；如果为null返回defaultObj值
public static <T> T requireNonNullElseGet(T obj, Supplier<? extends T> supplier) // 检查对象是否不为null，如果不为null，返回该对象；如果 // 为null,返回由Supplier所提供的值

复制代码

上述方法中的可以明白为是Object类型。
实现步骤：

创建一个门生类，提供两个成员变量（name ， age）；并且提供对应的无参构造方法和有参构造方法以及get/set方法，并且重写toString方法和equals方法
创建一个测试类（ObjectsDemo01）, 在该类中编写测试代码

如下所示：
Student类

public class Student {
private String name ; // 姓名
private String age ; // 年龄
// 其他代码略
...
}

复制代码

public class ObjectsDemo01 {
public static void main(String[] args) {
// 调用方法
method_04() ;
}
// 测试nonNull方法
public static void method_04() {
// 创建一个学生对象
Student s1 = new Student("蛋姐" , "21") ;
// 调用Objects类中的nonNull方法
boolean result = Objects.nonNull(s1);
// 输出结果
System.out.println(result);
}
// 测试isNull方法
public static void method_03() {
// 创建一个学生对象
Student s1 = new Student("蛋姐" , "21") ;
// 调用Objects类中的isNull方法
boolean result = Objects.isNull(s1);
// 输出结果
System.out.println(result);
}
// 测试equals方法
public static void method_02() {
// 创建两个学生对象
Student s1 = new Student("蛋姐" , "21") ;
Student s2 = new Student("蛋姐" , "21") ;
// 调用Objects类中的equals方法，比较两个对象是否相等
boolean result = Objects.equals(s1, s2); // 如果Student没有重写Object类中的equals方法，此处比较的还是对象的地址值
// 输出结果
System.out.println(result);
}
// 测试toString方法
public static void method_01() {
// 创建一个学生对象
Student s1 = new Student("蛋姐" , "21") ;
// 调用Objects中的toString方法,获取s1对象的字符串表现形式
String result = Objects.toString(s1); // 如果Student没有重写Object类中的toString方法，此处还是返回的对象的地址值
// 输出结果
System.out.println(result);
}
}

复制代码

public class ObjectsDemo02 {
public static void main(String[] args) {
// 调用方法
method_03();
}
// 演示requireNonNullElseGet
public static void method_03() {
// 创建一个学生对象
Student s1 = new Student("蛋姐" , "21") ;
// 调用Objects对象的requireNonNullElseGet方法,该方法的第二个参数是Supplier类型的，查看源码我们发现Supplier是一个函数式接口,
// 那么我们就可以为其传递一个Lambda表达式，而在Supplier接口中所定义的方法是无参有返回值的方法，因此具体调用所传入的Lambda表达式如下所示
Student student = Objects.requireNonNullElseGet(s1, () -> {
return new Student("蛋姐" , "21");
});
// 输出
System.out.println(student);
}
// 演示requireNonNullElse
public static void method_02() {
// 创建一个学生对象
Student s1 = new Student("蛋姐" , "21") ;
// 调用Objects对象的requireNonNullElse方法
Student student = Objects.requireNonNullElse(s1, new Student("itcast", "14"));
// 输出
System.out.println(student);
}
// 演示requireNonNull
public static void method_01() {
// 创建一个学生对象
Student s1 = new Student("蛋姐" , "21") ;
// 调用Objects对象的requireNonNull方法
Student student = Objects.requireNonNull(s1);
// 输出
System.out.println(student);
}
}

复制代码

3.BigInteger类

3.1 引入

        平时在存储整数的时间，Java中默认是int类型，int类型有取值范围：-2147483648 ~ 2147483647。假如数字过大，我们可以利用long类型，但是假如long类型也表示不下怎么办呢？
        就需要用到BigInteger，可以明白为：大的整数。
        有多大呢？理论上最大到42亿的21亿次方。
        根本上在内存撑爆之前，都无法到达这个上限。
3.2 常见方法

public BigInteger(int num, Random rnd) //获取随机大整数，范围：[0 ~ 2的num次方-1]
public BigInteger(String val) //获取指定的大整数
public BigInteger(String val, int radix) //获取指定进制的大整数
下面这个不是构造，而是一个静态方法获取BigInteger对象
public static BigInteger valueOf(long val) //静态方法获取BigInteger的对象，内部有优化

复制代码

构造方法小结：

假如BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
假如BigInteger表示的超出long的范围，可以用构造方法获取。
对象一旦创建，BigInteger内部记录的值不能发生改变。
只要进行计算都会产生一个新的BigInteger对象

<font color=“red” size=“3”>常见成员方法</font>
BigDecimal类中利用最多的照旧提供的进行四则运算的方法，如下：

public BigInteger add(BigInteger val) //加法
public BigInteger subtract(BigInteger val) //减法
public BigInteger multiply(BigInteger val) //乘法
public BigInteger divide(BigInteger val) //除法
public BigInteger[] divideAndRemainder(BigInteger val) //除法，获取商和余数
public boolean equals(Object x) //比较是否相同
public BigInteger pow(int exponent) //次幂、次方
public BigInteger max/min(BigInteger val) //返回较大值/较小值
public int intValue(BigInteger val)

复制代码

import java.math.BigInteger;
public class BigIntegerDemo1 {
public static void main(String[] args) {
/*
public BigInteger(int num, Random rnd) 获取随机大整数，范围:[0~ 2的num次方-11
public BigInteger(String val) 获取指定的大整数
public BigInteger(String val, int radix) 获取指定进制的大整数
public static BigInteger valueOf(long val) 静态方法获取BigInteger的对象，内部有优化
细节:
对象一旦创建里面的数据不能发生改变。
*/
//1.获取一个随机的大整数
/* Random r=new Random();
for (int i = e; i < 100; i++) {
BigInteger bd1 = new BigInteger(4,r);
System.out.println(bd1);//[@ ~ 15]}
}
*/
//2.获取一个指定的大整数，可以超出long的取值范围
//细节:字符串中必须是整数，否则会报错
/* BigInteger bd2 = new BigInteger("1.1");
System.out.println(bd2);
*/
/*
BigInteger bd3 = new BigInteger("abc");
System.out.println(bd3);
*/
//3.获取指定进制的大整数
//细节:
//1.字符串中的数字必须是整数
//2.字符串中的数字必须要跟进制吻合。
//比如二进制中，那么只能写日和1，写其他的就报错。
BigInteger bd4 = new BigInteger("123", 2);
System.out.println(bd4);
//4.静态方法获取BigInteger的对象，内部有优化
//细节:
//1.能表示范围比较小，只能在long的取值范围之内，如果超出long的范围就不行了。
//2.在内部对常用的数字: -16 ~ 16 进行了优化。
// 提前把-16~16 先创建好BigInteger的对象，如果多次获取不会重新创建新的。
BigInteger bd5 = BigInteger.valueOf(16);
BigInteger bd6 = BigInteger.valueOf(16);
System.out.println(bd5 == bd6);//true
BigInteger bd7 = BigInteger.valueOf(17);
BigInteger bd8 = BigInteger.valueOf(17);
System.out.println(bd7 == bd8);//false
//5.对象一旦创建内部的数据不能发生改变
BigInteger bd9 =BigInteger.valueOf(1);
BigInteger bd10 =BigInteger.valueOf(2);
//此时，不会修改参与计算的BigInteger对象中的借，而是产生了一个新的BigInteger对象记录
BigInteger result=bd9.add(bd10);
System.out.println(result);//3
}
}

复制代码

import java.math.BigInteger;
public class BigIntegerDemo2 {
public static void main(String[] args) {
/*
public BigInteger add(BigInteger val) 加法
public BigInteger subtract(BigInteger val) 减法
public BigInteger multiply(BigInteger val) 乘法
public BigInteger divide(BigInteger val) 除法，获取商
public BigInteger[] divideAndRemainder(BigInteger val) 除法，获取商和余数
public boolean equals(Object x) 比较是否相同
public BigInteger pow(int exponent) 次幂
public BigInteger max/min(BigInteger val) 返回较大值/较小值
public int intValue(BigInteger val) 转为int类型整数，超出范围数据有误
*/
//1.创建两个BigInteger对象
BigInteger bd1 = BigInteger.valueOf(10);
BigInteger bd2 = BigInteger.valueOf(5);
//2.加法
BigInteger bd3 = bd1.add(bd2);
System.out.println(bd3);
//3.除法，获取商和余数
BigInteger[] arr = bd1.divideAndRemainder(bd2);
System.out.println(arr[0]);
System.out.println(arr[1]);
//4.比较是否相同
boolean result = bd1.equals(bd2);
System.out.println(result);
//5.次幂
BigInteger bd4 = bd1.pow(2);
System.out.println(bd4);
//6.max
BigInteger bd5 = bd1.max(bd2);
//7.转为int类型整数，超出范围数据有误
/* BigInteger bd6 = BigInteger.valueOf(2147483647L);
int i = bd6.intValue();
System.out.println(i);
*/
BigInteger bd6 = BigInteger.valueOf(200);
double v = bd6.doubleValue();
System.out.println(v);//200.0
}
}

复制代码

3.3 底层存储方式

        对于计算机而言，着实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在现实存储的时间，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。
        数组中最多能存储元素个数：21亿多
        数组中每一位能表示的数字：42亿多
        理论上，BigInteger能表示的最大数字为：42亿的21亿次方。
        但是还没到这个数字，电脑的内存就会撑爆，所以一样寻常认为BigInteger是无限的。
4.BigDecimal类

4.1 引入

        起首我们来分析一下如下程序的执行结果：

public class BigDecimalDemo01 {
public static void main(String[] args) {
System.out.println(0.09 + 0.01);
}
}

复制代码

这段代码比较简单，就是计算0.09和0.01之和，并且将其结果在控制台进行输出。那么按照我们的想法在控制台输出的结果应该为0.1。那么现实的运行结果是什么呢？我们来运行一下程序，控制台的输出。
结果如下所示：

0.09999999999999999

复制代码

        这样的结果着实就是一个丢失精度的结果。为什么会产生精度丢失呢？
        在利用float或者double类型的数据在进行数学运算的时间，很有大概会产生精度丢失题目。我们都知道计算机底层在进行运算的时间，利用的都是二进制数据；当我们在程序中写了一个十进制数据，在进行运算的时间，计算时机将这个十进制数据转换成二进制数据，然后再进行运算，计算完毕以后计算时机把运算的结果再转换成十进制数据给我们展示；假如我们利用的是整数类型的数据进行计算，那么在把十进制数据转换成二进制数据的时间不会存在精度题目；假如我们的数据是一个浮点类型的数据，有的时间计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的趋近于这个十进数的二进制数据；这样利用一个不太准确的数据进行运算的时间，终极就会造成精度丢失；为了提高精度，Java就给我们提供了BigDecimal供我们进行数据运算。
4.2 常见方法

        BigDecimal类中利用最多的照旧提供的进行四则运算的方法，如下：

public BigDecimal add(BigDecimal value) // 加法运算
public BigDecimal subtract(BigDecimal value) // 减法运算
public BigDecimal multiply(BigDecimal value) // 乘法运算
public BigDecimal divide(BigDecimal value) // 触发运算

复制代码

接下来我们就来通过一些案例演示一下这些成员方法的利用。

public class BigDecimalDemo01 {
public static void main(String[] args) {
// 创建两个BigDecimal对象
BigDecimal b1 = new BigDecimal("0.3") ;
BigDecimal b2 = new BigDecimal("4") ;
// 调用方法进行b1和b2的四则运算，并将其运算结果在控制台进行输出
System.out.println(b1.add(b2)); // 进行加法运算
System.out.println(b1.subtract(b2)); // 进行减法运算
System.out.println(b1.multiply(b2)); // 进行乘法运算
System.out.println(b1.divide(b2)); // 进行除法运算
}
}

复制代码

运行结果：

4.3
-3.7
1.2
0.075

复制代码

此时我们可以看到利用BigDecimal类来完成浮点数的计算不会存在损失精度的题目。
假如利用BigDecimal类型的数据进行除法运算的时间，得到的结果是一个无限循环小数，那么就会报错：ArithmeticException。如下代码所示：

public class BigDecimalDemo02 {
public static void main(String[] args) {
// 创建两个BigDecimal对象
BigDecimal b1 = new BigDecimal("1") ;
BigDecimal b2 = new BigDecimal("3") ;
// 调用方法进行b1和b2的除法运算，并且将计算结果在控制台进行输出
System.out.println(b1.divide(b2));
}
}

复制代码

运行程序进行测试，控制台输出结果如下所示：

Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
at java.base/java.math.BigDecimal.divide(BigDecimal.java:1716)
at com.itheima.api.bigdecimal.demo02.BigDecimalDemo02.main(BigDecimalDemo02.java:14)

复制代码

针对这个题目怎么办理，此时我们就需要利用到BigDecimal类中别的一个divide方法，如下所示：

BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

复制代码

上述divide方法参数阐明：

divisor: 除数对应的BigDecimal对象；
scale: 精确的位数；
roundingMode: 取舍模式；
取舍模式被封装到了RoundingMode这个枚举类中（关于枚举我们后期再做重点讲解），在这个枚举类中定义了很多种取舍方式。最常见的取舍方式有如下几个：
UP(直接进1) ， FLOOR(直接删除) ， HALF_UP(4舍五入),我们可以通过如下格式直接访问这些取舍模式：枚举类名.变量名

复制代码

接下来我们就来演示一下这些弃取模式，代码如下所示：

public class BigDecimalDemo02 {
public static void main(String[] args) {
// 调用方法
method_03() ;
}
// 演示取舍模式HALF_UP
public static void method_03() {
// 创建两个BigDecimal对象
BigDecimal b1 = new BigDecimal("0.3") ;
BigDecimal b2 = new BigDecimal("4") ;
// 调用方法进行b1和b2的除法运算，并且将计算结果在控制台进行输出
System.out.println(b1.divide(b2 , 2 , RoundingMode.HALF_UP));
}
// 演示取舍模式FLOOR
public static void method_02() {
// 创建两个BigDecimal对象
BigDecimal b1 = new BigDecimal("1") ;
BigDecimal b2 = new BigDecimal("3") ;
// 调用方法进行b1和b2的除法运算，并且将计算结果在控制台进行输出
System.out.println(b1.divide(b2 , 2 , RoundingMode.FLOOR));
}
// 演示取舍模式UP
public static void method_01() {
// 创建两个BigDecimal对象
BigDecimal b1 = new BigDecimal("1") ;
BigDecimal b2 = new BigDecimal("3") ;
// 调用方法进行b1和b2的除法运算，并且将计算结果在控制台进行输出
System.out.println(b1.divide(b2 , 2 , RoundingMode.UP));
}
}

复制代码

小结：后期在进行两个数的除法运算的时间，我们常常利用的是可以设置弃取模式的divide方法。
5. 正则表达式

5.1 正则表达式的概念及演示

在Java中，我们经常需要验证一些字符串，例如：年龄必须是2位的数字、用户名必须是8位长度而且只能包罗大小写字母、数字等。正则表达式就是用来验证各种字符串的规则。它内部形貌了一些规则，我们可以验证用户输入的字符串是否匹配这个规则。
先看一个不利用正则表达式验证的例子：下面的程序让用户输入一个QQ号码，我们要验证：
- QQ号码必须是5–15位长度
- 而且必须全部是数字
- 而且首位不能为0

public class RegexDemo1 {
public static void main(String[] args) {
/* 假如现在要求校验一个qq号码是否正确。
规则:6位及20位之内，日不能在开头，必须全部是数字。
先使用目前所学知识完成校验需求然后体验一下正则表达式检验。
*/
String qq ="1234567890";
System.out.println(checkQQ(qq));
System.out.println(qq.matches("[1-9]\\d{5,19}"));
}
public static boolean checkQQ(String qq) {
//规则:6位及20位之内，日不能在开头，必须全部是数字。
//核心思想:
//先把异常数据进行过滤
//下面的就是满足要求的数据了。
int len = qq.length();
if (len < 6 || len > 20) {
return false;
}
//0不能在开头
if (qq.startsWith("0")) {
return false;
}
//必须全部是数字
for (int i = 0; i < qq.length(); i++) {
char c = qq.charAt(i);
if (c < '0' | c > '9') {
return false;
}
}
return true;
}
}

复制代码

利用正则表达式验证：

public class Demo {
public static void main(String[] args) {
String qq ="1234567890";
System.out.println(qq.matches("[1-9]\\d{5,19}"));
}
}

复制代码

5.2 正则表达式-字符类

语法示例：

[abc]：代表a或者b，或者c字符中的一个。
[^abc]：代表除a,b,c以外的任何字符。
[a-z]：代表a-z的所有小写字符中的一个。
[A-Z]：代表A-Z的所有大写字符中的一个。
[0-9]：代表0-9之间的某一个数字字符。
[a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的恣意一个字符。
[a-dm-p]：a 到 d 或 m 到 p之间的恣意一个字符。

代码示例：

public class RegexDemo2 {
public static void main(String[] args) {
//public boolean matches(String regex):判断是否与正则表达式匹配，匹配返回true
// 只能是a b c
System.out.println("-----------1-------------");
System.out.println("a".matches("[abc]")); // true
System.out.println("z".matches("[abc]")); // false
// 不能出现a b c
System.out.println("-----------2-------------");
System.out.println("a".matches("[^abc]")); // false
System.out.println("z".matches("[^abc]")); // true
System.out.println("zz".matches("[^abc]")); //false
System.out.println("zz".matches("[^abc][^abc]")); //true
// a到zA到Z(包括头尾的范围)
System.out.println("-----------3-------------");
System.out.println("a".matches("[a-zA-z]")); // true
System.out.println("z".matches("[a-zA-z]")); // true
System.out.println("aa".matches("[a-zA-z]"));//false
System.out.println("zz".matches("[a-zA-Z]")); //false
System.out.println("zz".matches("[a-zA-Z][a-zA-Z]")); //true
System.out.println("0".matches("[a-zA-Z]"));//false
System.out.println("0".matches("[a-zA-Z0-9]"));//true
// [a-d[m-p]] a到d，或m到p
System.out.println("-----------4-------------");
System.out.println("a".matches("[a-d[m-p]]"));//true
System.out.println("d".matches("[a-d[m-p]]")); //true
System.out.println("m".matches("[a-d[m-p]]")); //true
System.out.println("p".matches("[a-d[m-p]]")); //true
System.out.println("e".matches("[a-d[m-p]]")); //false
System.out.println("0".matches("[a-d[m-p]]")); //false
// [a-z&&[def]] a-z和def的交集。为:d，e，f
System.out.println("----------5------------");
System.out.println("a".matches("[a-z&[def]]")); //false
System.out.println("d".matches("[a-z&&[def]]")); //true
System.out.println("0".matches("[a-z&&[def]]")); //false
// [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
System.out.println("-----------6------------_");
System.out.println("a".matches("[a-z&&[^bc]]"));//true
System.out.println("b".matches("[a-z&&[^bc]]")); //false
System.out.println("0".matches("[a-z&&[^bc]]")); //false
// [a-z&&[^m-p]] a到z和除了m到p的交集。(等同于[a-1q-z])
System.out.println("-----------7-------------");
System.out.println("a".matches("[a-z&&[^m-p]]")); //true
System.out.println("m".matches("[a-z&&[^m-p]]")); //false
System.out.println("0".matches("[a-z&&[^m-p]]")); //false
}
}

复制代码

5.3 正则表达式-逻辑运算符

语法示例：
- &&：并且
- | ：或者
- \ ：转义字符
代码示例：

public class Demo {
public static void main(String[] args) {
String str = "had";
//1.要求字符串是小写辅音字符开头，后跟ad
String regex = "[a-z&&[^aeiou]]ad";
System.out.println("1." + str.matches(regex));
//2.要求字符串是aeiou中的某个字符开头，后跟ad
regex = "[a|e|i|o|u]ad";//这种写法相当于：regex = "[aeiou]ad";
System.out.println("2." + str.matches(regex));
}
}

复制代码

public class RegexDemo3 {
public static void main(String[] args) {
// \ 转义字符改变后面那个字符原本的含义
//练习:以字符串的形式打印一个双引号
//"在Java中表示字符串的开头或者结尾
//此时\表示转义字符，改变了后面那个双引号原本的含义
//把他变成了一个普普通通的双引号而已。
System.out.println(""");
// \表示转义字符
//两个\的理解方式：前面的\是一个转义字符，改变了后面\原本的含义，把他变成一个普普通通的\而已。
System.out.println("c:Users\\moon\\IdeaProjects\\basic-code\\myapi\\src\\com\\itheima\\a08regexdemo\\RegexDemo1.java");
}
}

复制代码

5.4 正则表达式-预定义字符

语法示例：
- “.” ：匹配任何字符。
- “\d”：任何数字[0-9]的简写；
- “\D”：任何非数字[^0-9]的简写；
- “\s”：空白字符：[ \t\n\x0B\f\r] 的简写
- “\S”：非空白字符：[^\s] 的简写
- “\w”：单词字符：[a-zA-Z_0-9]的简写
- “\W”：非单词字符：[^\w]
代码示例：

public class Demo {
public static void main(String[] args) {
//.表示任意一个字符
System.out.println("你".matches("..")); //false
System.out.println("你".matches(".")); //true
System.out.println("你a".matches(".."));//true
// \\d 表示任意的一个数字
// \\d只能是任意的一位数字
// 简单来记:两个\表示一个\
System.out.println("a".matches("\\d")); // false
System.out.println("3".matches("\\d")); // true
System.out.println("333".matches("\\d")); // false
//\\w只能是一位单词字符[a-zA-Z_0-9]
System.out.println("z".matches("\\w")); // true
System.out.println("2".matches("\\w")); // true
System.out.println("21".matches("\\w")); // false
System.out.println("你".matches("\\w"));//false
// 非单词字符
System.out.println("你".matches("\\W")); // true
System.out.println("---------------------------------------------");
// 以上正则匹配只能校验单个字符。
// 必须是数字字母下划线至少 6位
System.out.println("2442fsfsf".matches("\\w{6,}"));//true
System.out.println("244f".matches("\\w{6,}"));//false
// 必须是数字和字符必须是4位
System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
}
}

复制代码

5.5 正则表达式-数量词

语法示例：
- X? : 0次或1次
- X* : 0次到多次
- X+ : 1次或多次
- X{n} : 恰恰n次
- X{n,} : 至少n次
- X{n,m}: n到m次(n和m都是包罗的)
代码示例：

public class Demo {
public static void main(String[] args) {
// 必须是数字字母下划线至少 6位
System.out.println("2442fsfsf".matches("\\w{6,}"));//true
System.out.println("244f".matches("\\w{6,}"));//false
// 必须是数字和字符必须是4位
System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
}
}

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

自学Java第16Day

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云