目录
8.14 String类的replaceAll方法中使用正则表达式
一、Math类
1.1 概述
查看API文档，我们可以看到API文档中关于Math类的定义如下：
Math类所在包为java.lang包，因此在使用的时候不需要进行导包。并且Math类被final修饰了，因此该类是不能被继承的。
Math类包含执行基本数字运算的方法，我们可以使用Math类完成基本的数学运算。
要想使用Math类我们就需要先创建该类的对象，那么创建对象就需要借助于构造方法。因此我们就需要首先查看一下API文档，看看API文档中针对Math类有没有提供对应的构造方法。通过API文档来查看
一下Math类的成员，如下所示：
1.2 常见方法
public static int abs(int a) // 返回参数的绝对值
public static double ceil(double a) // 返回大于或等于参数的最小整数
public static double floor(double a) // 返回小于或等于参数的最大整数
public static int round(float a) // 按照四舍五入返回最接近参数的int类型的值
public static int max(int a,int b) // 获取两个int值中的较大值
public static int min(int a,int b) // 获取两个int值中的较小值
public static double pow (double a,double b) // 计算a的b次幂的值
public static double sqrt(double a) // 返回a的平方根
public static double cbrt(double a) // 返回a的立方根
public static double random() // 返回一个[0.0,1.0)的随机值代码演示：
public class MathDemo01 {
public static void main(String[] args) {
// public static int abs(int a) 返回参数的绝对值
System.out.println("-2的绝对值为：" + Math.abs(-2));
System.out.println("2的绝对值为：" + Math.abs(2));
// public static double ceil(double a) 返回大于或等于参数的最小整数
System.out.println("大于或等于23.45的最小整数位：" + Math.ceil(23.45));
System.out.println("大于或等于-23.45的最小整数位：" + Math.ceil(-23.45));
// public static double floor(double a) 返回小于或等于参数的最大整数
System.out.println("小于或等于23.45的最大整数位：" + Math.floor(23.45));
System.out.println("小于或等于-23.45的最大整数位：" + Math.floor(-23.45));
// public static int round(float a) 按照四舍五入返回最接近参数的int
System.out.println("23.45四舍五入的结果为：" + Math.round(23.45));
System.out.println("23.55四舍五入的结果为：" + Math.round(23.55));
// public static int max(int a,int b) 返回两个int值中的较大值
System.out.println("23和45的最大值为: " + Math.max(23, 45));
// public static int min(int a,int b) 返回两个int值中的较小值
System.out.println("12和34的最小值为: " + Math.min(12 , 34));
// public static double pow (double a,double b)返回a的b次幂的值
System.out.println("2的3次幂计算结果为: " + Math.pow(2,3));
//细节：
如果第二个参数0~1之间的小数
System.out.println(Math.pow(4,0.5));//2.0
System.out.println(Math.pow(2,-2));//0.25
//建议：
//第二个参数：一般传递大于等于1的正整数
System.out.println(Math.sqrt(4,0.5));//2.0
System.out.println(Math.cbrt(2,-2));//2.0
// public static double random()返回值为double的正值，[0.0,1.0)
System.out.println("获取到的0-1之间的随机数为: " + Math.random());
}
}控制台输出：
-2的绝对值为：2
2的绝对值为：2
大于或等于23.45的最小整数位：24.0
大于或等于-23.45的最小整数位：-23.0
小于或等于23.45的最大整数位：23.0
小于或等于-23.45的最大整数位：-24.0
23.45四舍五入的结果为：23
23.55四舍五入的结果为：24
23和45的最大值为: 45
12和34的最小值为: 12
2的3次幂计算结果为: 8.0
2.0
0.25
2.0
2.0
获取到的0-1之间的随机数为: 0.7322484131745958
1.3 算法小题(质数)
需求：
判断一个数是否为一个质数
代码实现：
public class MathDemo2 {
public static void main(String[] args) {
//判断一个数是否为一个质数
System.out.println(isPrime(997));
//997 2~996 995次
}
public static boolean isPrime(int number) {
int count = 0;
for (int i = 2; i <= Math.sqrt(number); i++) {
count++;
if (number % i == 0) {
return false;
}
}
System.out.println(count);
return true;
}
}1.4 算法小题(自幂数)
自幂数，一个n位自然数等于自身各个数位上数字的n次幂之和
举例1：三位数 1^3 + 5^3 + 3^3 = 153
举例2：四位数 1^4 + 6^4 + 3^4 + 4^3 = 1634
如果自幂数是：
-
一位自幂数，也叫做：独身数
-
三位自幂数：水仙花数 四位自幂数：四叶玫瑰数
-
五位自幂数：五角星数 六位自幂数：六合数
-
七位自幂数：北斗七星数 八位自幂数：八仙数
-
九位自幂数：九九重阳数 十位自幂数：十全十美数
要求1：统计一共有多少个水仙花数。
//水仙花数:100 ~ 999
int count = 0;
//得到每一个三位数
for (int i = 100; i <= 999; i++) {
//个位 十位 百位
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
//判断:
//每一位的三次方之和 跟本身 进行比较。
double sum = Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3);
if (sum == i) {
count++;
//System.out.println(i);
System.out.println(count);
}
}要求2：证明没有两位的自幂数。
int count = 0;
for (int i =10 ; i<=99;i++){
int ge = i % 10;
int shi = i / 10 % 10;
double sum = Math.pow(ge, 2) + Math.pow(shi, 2);
if (sum == i) {
count++;
//System.out.println(i);
}
}
if (count==0){
System.out.println("没有两位自幂数");
}要求3：（课后作业）分别统计有多少个四叶玫瑰数和五角星数。（答案：都是3个）
public class Mathdemo2 {
public static void main(String[] args) {
int count1 = 0;
int count2 = 0;
for (int i =1000 ; i<=9999;i++){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
int qian = i/1000%10;
double sum = Math.pow(ge, 4) + Math.pow(shi, 4)+Math.pow(bai,4)+Math.pow(qian,4);
if (sum == i) {
count1++;
//System.out.println(i);
}
}
System.out.println("有"+count1+"个四叶玫瑰数");
for (int i =10000 ; i<=99999;i++){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
int qian = i/1000%10;
int wan = i/10000%10;
double sum = Math.pow(ge, 5) + Math.pow(shi, 5)+Math.pow(bai,5)+Math.pow(qian,5)+Math.pow(wan,5);
if (sum == i) {
count2++;
//System.out.println(i);
}
}
System.out.println("有"+count2+"个五角星数");
}
}二、System类
2.1 概述
System类所在包为java.lang包，因此在使用的时候不需要进行导包。并且System类被final修饰了，因此该类是不能被继承的。
System包含了系统操作的一些常用的方法。比如获取当前时间所对应的毫秒值，再比如终止当前JVM等等。
2.2 常见方法
// 获取当前时间所对应的毫秒值（当前时间为0时区所对应的时间即就是英国格林尼治天文台旧址所在位置）
public static long currentTimeMillis()
// 终止当前正在运行的Java虚拟机，0表示正常退出，非零表示异常退出
public static void exit(int status)
// 进行数值元素copy
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 代码演示：
package com.itheima.a02systemdemo;
public class Systemdemo1 {
public static void main(String[] args) {
//判断1~10000之间有多少个质数
long start = System.currentTimeMillis();
for (int i = 1; i < 10000; i++) {
boolean flag = isPrime1(i);
if (flag) {
System.out.println(i);
}
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
//以前的方式来判断
public static boolean isPrime1(int number) {
for (int i = 2; i < number; i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
//改进之后的方式来判断的 --- 效率高
public static boolean isPrime2(int number) {
for (int i = 2; i < Math.sqrt(number); i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
}
package com.itheima.a02systemdemo;
public class Systemdemo2 {
public static void main(String[] args) {
//拷贝数组
int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
int[] arr2 = new int[10];
//把arr1数组拷贝到arr2
//参数一：数据源
//参数二：从数据源数组的第几个索引开始拷贝
//参数三：目的地，把数据拷贝到哪个数组
//参数四：目的地数组的索引
//参数五：拷贝个数
System.arraycopy(arr1,0,arr2,0,10);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+" ");
}
}
}
arraycopy方法底层细节：
1.如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错
2.在拷贝的时候需要考虑数组的长度，如果超出范围也会报错
3.如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型
代码演示：
public class SystemDemo3 {
public static void main(String[] args) {
//public static void arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数) 数组拷贝
//细节:
//1.如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错
//2.在拷贝的时候需要考虑数组的长度，如果超出范围也会报错
//3.如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型
Student s1 = new Student("zhangsan", 23);
Student s2 = new Student("lisi", 24);
Student s3 = new Student("wangwu", 25);
Student[] arr1 = {s1, s2, s3};
Person[] arr2 = new Person[3];
//把arr1中对象的地址值赋值给arr2中
System.arraycopy(arr1, 0, arr2, 0, 3);
//遍历数组arr2
for (int i = 0; i < arr2.length; i++) {
Student stu = (Student) arr2[i];
System.out.println(stu.getName() + "," + stu.getAge());
}
}
}
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
*
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
*
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
*
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
*
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Person{name = " + name + ", age = " + age + "}";
}
}
class Student extends Person {
public Student() {
}
public Student(String name, int age) {
super(name, age);
}
}三、Runtime
3.1 概述
Runtime表示Java中运行时对象，可以获取到程序运行时设计到的一些信息
3.2 常见方法
public static Runtime getRuntime() //当前系统的运行环境对象
public void exit(int status) //停止虚拟机
public int availableProcessors() //获得CPU的线程数
public long maxMemory() //JVM能从系统中获取总内存大小（单位byte）
public long totalMemory() //JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory() //JVM剩余内存大小（单位byte）
public Process exec(String command) //运行cmd命令3.3 恶搞好基友
需求：
界面上方按钮默认隐藏
界面中间有一个提示文本和三个按钮
当你的好基友点击中间三个按钮的时候就在N秒之后关机，不同的按钮N的值不一样
任意一个按钮被点击之后，上方了按钮出现。当点击上方按钮之后取消关机任务
public class Test {
public static void main(String[] args) {
new MyJframe();
}
}public class MyJframe extends JFrame implements ActionListener {
JButton yesBut = new JButton("帅爆了");
JButton midBut = new JButton("一般般吧");
JButton noBut = new JButton("不帅，有点磕碜");
JButton dadBut = new JButton("饶了我吧！");
//决定了上方的按钮是否展示
boolean flag = false;
public MyJframe() {
initJFrame();
initView();
//显示
this.setVisible(true);
}
private void initView() {
this.getContentPane().removeAll();
if (flag) {
//展示按钮
dadBut.setBounds(50, 20, 100, 30);
dadBut.addActionListener(this);
this.getContentPane().add(dadBut);
}
JLabel text = new JLabel("你觉得自己帅吗？");
text.setFont(new Font("微软雅黑", 0, 30));
text.setBounds(120, 150, 300, 50);
yesBut.setBounds(200, 250, 100, 30);
midBut.setBounds(200, 325, 100, 30);
noBut.setBounds(160, 400, 180, 30);
yesBut.addActionListener(this);
midBut.addActionListener(this);
noBut.addActionListener(this);
this.getContentPane().add(text);
this.getContentPane().add(yesBut);
this.getContentPane().add(midBut);
this.getContentPane().add(noBut);
this.getContentPane().repaint();
}
private void initJFrame() {
//设置宽高
this.setSize(500, 600);
//设置标题
this.setTitle("恶搞好基友");
//设置关闭模式
this.setDefaultCloseOperation(3);
//置顶
this.setAlwaysOnTop(true);
//居中
this.setLocationRelativeTo(null);
//取消内部默认布局
this.setLayout(null);
}
@Override
public void actionPerformed(ActionEvent e) {
Object obj = e.getSource();
if (obj == yesBut) {
//给好基友一个弹框
showJDialog("xxx，你太自信了，给你一点小惩罚");
try {
Runtime.getRuntime().exec("shutdown -s -t 3600");
} catch (IOException ioException) {
ioException.printStackTrace();
}
flag = true;
initView();
} else if (obj == midBut) {
System.out.println("你的好基友点击了一般般吧");
//给好基友一个弹框
showJDialog("xxx，你还是太自信了，也要给你一点小惩罚");
try {
Runtime.getRuntime().exec("shutdown -s -t 7200");
} catch (IOException ioException) {
ioException.printStackTrace();
}
flag = true;
initView();
} else if (obj == noBut) {
System.out.println("你的好基友点击了不帅");
//给好基友一个弹框
showJDialog("xxx，你还是有一点自知之明的，也要给你一点小惩罚");
try {
Runtime.getRuntime().exec("shutdown -s -t 1800");
} catch (IOException ioException) {
ioException.printStackTrace();
}
flag = true;
initView();
} else if (obj == dadBut) {
//给好基友一个弹框
showJDialog("xxx，这次就饶了你~");
try {
Runtime.getRuntime().exec("shutdown -a");
} catch (IOException ioException) {
ioException.printStackTrace();
}
}
}
public void showJDialog(String content) {
//创建一个弹框对象
JDialog jDialog = new JDialog();
//给弹框设置大小
jDialog.setSize(200, 150);
//让弹框置顶
jDialog.setAlwaysOnTop(true);
//让弹框居中
jDialog.setLocationRelativeTo(null);
//弹框不关闭永远无法操作下面的界面
jDialog.setModal(true);
//创建Jlabel对象管理文字并添加到弹框当中
JLabel warning = new JLabel(content);
warning.setBounds(0, 0, 200, 150);
jDialog.getContentPane().add(warning);
//让弹框展示出来
jDialog.setVisible(true);
}
}
四、Object类
4.1 概述
Object类所在包是java.lang包。Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类；换句话说，该类所具备的方法，其他所有类都继承了。
4.2 常见方法
public String toString() //返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj) //比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone() //对象克隆演示toString方法
实现步骤：
-
创建一个学生类，提供两个成员变量（name ， age）；并且提供对应的无参构造方法和有参构造方法以及get/set方法
-
创建一个测试类（ObjectDemo01），在测试类的main方法中去创建学生对象，然后调用该对象的toString方法获取该对象的字符串表现形式，并将结果进行输出
Student类 ：
package com.itheima.a04objectdemo;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return name + "," + age;
}
}
ObjectDemo01测试类：
public class ObjectDemo1 {
public static void main(String[] args) {
//1.toString 返回对象的字符串表示形式
Object obj = new Object();
String str1 = obj.toString();
System.out.println(str1);//java.lang.Object@4eec7777
Student stu = new Student("zhangsan",23);
String str2 = stu.toString();
System.out.println(str2);//com.itheima.a04objectdemo.Student@41629346
//细节：
//System:类名
//out:静态变量
//System.out:获取打印的对象
//println():方法
//参数:表示打印的内容
//核心逻辑：
//当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串。
//然后再打印在控制台上，打印完毕换行处理。
//思考：默认情况下，因为Object类中的toString方法返回的是地址值
//所以，默认情况下，打印一个对象打印的就是地址值
//但是地址值对于我们是没什么意义的？
//我想要看到对象内部的属性值？我们该怎么办？
//处理方法：重写父类Object类中的toString方法
System.out.println(stu);//com.itheima.a04objectdemo.Student@41629346
//总结：toString方法的结论：
//如果我们打印一个对象，想看到属性值的话，那么就重写toString方法就可以了。
//在重写的方法中，把对象的属性值进行拼接。
}
}
小结：
-
在通过输出语句输出一个对象时，默认调用的就是toString()方法
-
输出地址值一般没有意义，我们可以通过重写toString方法去输出对应的成员变量信息（快捷键：atl + insert ， 空白处 右键 -> Generate -> 选择toString）
-
toString方法的作用：以良好的格式，更方便的展示对象中的属性值
-
一般情况下Jdk所提供的类都会重写Object类中的toString方法
演示equals方法
在测试类（ObjectDemo02）的main方法中，创建两个学生对象，然后比较两个对象是否相同
public class ObjectDemo02 {
public static void main(String[] args) {
// 创建两个学生对象
Student s1 = new Student("itheima" , "14") ;
Student s2 = new Student("itheima" , "14") ;
// 比较两个对象是否相等
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开发工具完成，具体的操作如下所示：
1.在空白处使用快捷键：alt + insert。此时会弹出如下的对话框
2.选择equals() and hashCode()方法，此时会弹出如下的对话框
点击next，会弹出如下对话框：
选择neme和age属性点击next，此时就会弹出如下对话框：
取消name和age属性（因为此时选择的是在生成hashCode方法时所涉及到的属性，关于hashCode方法后期再做重点介绍），点击Finish完成生成操作。生成的equals方法和hashCode方法如下：
@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属性值
}
@Override
public int hashCode() {
return 0;
}hashCode方法我们暂时使用不到，可以将hashCode方法删除。重写完毕以后运行程序进行测试，控制台输出结果如下所示：
true
此时equals方法比较的是对象的成员变量值，而s1和s2两个对象的成员变量值都是相同的。因此比较完毕以后的结果就是true。
小结：
-
默认情况下equals方法比较的是对象的地址值
-
比较对象的地址值是没有意义的，因此一般情况下我们都会重写Object类中的equals方法,重写之后比较的就是对象内部的属性值。
扩展：
package com.itheima.a04objectdemo;
public class ObjectDemo2 {
public static void main(String[] args) {
String s = "abc";
StringBuilder sb = new StringBuilder("abc");
System.out.println(s.equals(sb));//false
//因为equals方法是被s调用的，而s是字符串
//所以equals要看String类中的
//字符串中的equals方法,先判断参数是否为字符串
//如果是字符串，再比较内部的属性
//但是如果参数不是字符串，直接返回false
System.out.println(sb.equals(s));//false
//因为equals方法是被sb调用的，而sb是StringBuilder
//所以这里的equals方法要看StringBuilder中的equals方法
//那么在StringBuilder当中，没有重写equals方法
//使用的是Object中的
//在Object当中默认是使用==号比较两个对象的地址值
//而这里的s和sb记录的地址值是不一样的，所以结果返回false
}
}
4.3 对象克隆的分类：
深克隆和浅克隆
浅克隆：
不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来
基本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。
Object类默认的是浅克隆
深克隆：
基本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的
测试类：
package com.itheima.a04objectdemo;
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, "zhangsan", "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);
}
}User类：
package com.itheima.a04objectdemo;
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;
}
}五、Objects类
5.1 概述
Objects类所在包是在java.util包下，因此在使用的时候需要进行导包。并且Objects类是被final修饰的，因此该类不能被继承。
Objects类提供了一些对象常见操作的方法。比如判断对象是否相等，判断对象是否为null等等。
Objects类中无无参构造方法，因此我们不能使用new关键字去创建Objects的对象。同时我们可以发现Objects类中所提供的方法都是静态的。因此我们可以通过类名直接去调用这些方法。
5.2 常见方法
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代码演示：
package com.itheima.a05objectsdemo;
import java.util.Objects;
public class ObjectsDemo1 {
public static void main(String[] args) {
//public static boolean equals(Object a,Object b) 先做非空判断，比较两个对象
//public static boolean isNull(Object obj) 判断对象是否为null，为null返回true,反之
//public static boolean nonNull(Object obj) 判断对象是否为null，跟isNull的结果相反
//1.创建学生类的对象
//Student s1 = new Student("zhangsan",23);
Student s1 = null;
Student s2 = new Student("zhangsan",23);
//2.比较两个对象的属性值是否相同
// boolean result = s1.equals(s2);
// System.out.println(result);//true
// if (s1 != null){
// boolean result = s1.equals(s2);
// System.out.println(result);
// }else {
// System.out.println("调用者为空");
// }
boolean result = Objects.equals(s1,s2);
System.out.println(result);
//细节：
//1.方法的底层会判断s1是否为null,如果为null,直接返回false
//2.如果s1不为null,那么就利用s1再次调用equals方法
//3.此时s1是Student类型，所以最终还是会调用Students中的equals方法。
// 如果没有重写，比较地址值，如果重写了，就比较属性值。
//public static boolean isNull(Object obj) 判断对象是否为null,为null返回true,反之
Student s3 = new Student();
Student s4 = null;
System.out.println(Objects.isNull(s3));//false
System.out.println(Objects.isNull(s4));//true
System.out.println(Objects.nonNull(s3));//true
System.out.println(Objects.nonNull(s4));//false
}
}
六、BigInteger类
6.1 概述
平时在存储整数的时候，Java中默认是int类型，int类型有取值范围：-2147483648 ~ 2147483647。如果数字过大，我们可以使用long类型，但是如果long类型也表示不下怎么办呢？
就需要用到BigInteger，可以理解为：大的整数。
BigInteger所在包是在java.math包下，因此在使用的时候就需要进行导包。我们可以使用BigInteger类进行大整数的计算
6.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的对象，内部有优化代码演示：
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
}
}构造方法小结：
-
如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
-
如果BigInteger表示的超出long的范围，可以用构造方法获取。
-
对象一旦创建，BigInteger内部记录的值不能发生改变。
-
只要进行计算都会产生一个新的BigInteger对象
常见成员方法：
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) //转为int类型整数，超出范围数据有误代码演示：
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
}
}6.3 底层存储方式：
对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。
数组中最多能存储元素个数：21亿多
数组中每一位能表示的数字：42亿多
理论上，BigInteger能表示的最大数字为：42亿的21亿次方。
但是还没到这个数字，电脑的内存就会撑爆，所以一般认为BigInteger是无限的。
存储方式如图所示：
七、BigDecimal类
7.1 引入
首先我们来分析一下如下程序的执行结果：
public class BigDecimalDemo01 {
public static void main(String[] args) {
System.out.println(0.09 + 0.01);
}
}结果如下所示：
0.09999999999999999
这样的结果其实就是一个丢失精度的结果。为什么会产生精度丢失呢？
在使用float或者double类型的数据在进行数学运算的时候，很有可能会产生精度丢失问题。我们都知道计算机底层在进行运算的时候，使用的都是二进制数据； 当我们在程序中写了一个十进制数据 ，在
进行运算的时候，计算机会将这个十进制数据转换成二进制数据，然后再进行运算，计算完毕以后计算机会把运算的结果再转换成十进制数据给我们展示； 如果我们使用的是整数类型的数据进行计算，那
么在把十进制数据转换成二进制数据的时候不会存在精度问题； 如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的
趋近于这个十进数的二进制数据； 这样使用一个不太准确的数据进行运算的时候， 最终就会造成精度丢失；为了提高精度，Java就给我们提供了BigDecimal供我们进行数据运算。
7.2 概述
7.3 常见方法
要用BigDecimal类，那么就需要首先学习一下如何去创建BigDecimal的对象。通过查看API文档，我们可以发现Jdk中针对BigDecimal类提供了很多的构造方法，但是最常用的构造方法是：
package com.itheima.a07BigDecimalDemo;
import java.math.BigDecimal;
public class BigeDecimaldemo1 {
public static void main(String[] args) {
//1.通过传递double类型的小数来创建对象
//细节：
//这种方式有可能是不精确的，所以不建议使用
// BigDecimal bd1 = new BigDecimal(0.01);
// BigDecimal bd2 = new BigDecimal(0.09);
// System.out.println(bd1);
// System.out.println(bd2);
//2.通过传递字符串表示的小数来创建对象
BigDecimal bd3 = new BigDecimal("0.01");
BigDecimal bd4 = new BigDecimal("0.09");
BigDecimal bd5 = bd3.add(bd4);
System.out.println(bd3);
System.out.println(bd4);
System.out.println(bd5);
//3.通过静态方法获取对象
BigDecimal bd6 = BigDecimal.valueOf(10);
BigDecimal bd7 = BigDecimal.valueOf(10);
System.out.println(bd6 == bd7);
//细节：
//1.如果要表示的数字不大，没有超出double的取值范围，建议使用静态方法
//2.如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
//3.如果我们传递的是0~10之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new
}
}
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类型的数据进行除法运算的时候，得到的结果是一个无限循环小数，那么就会报错：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));
}
}7.4 底层存储方式：
把数据看成字符串，遍历得到里面的每一个字符，把这些字符在ASCII码表上的值，都存储到数组中。
八、正则表达式
8.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}"));
}
}8.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
}
}
8.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");
}
}
8.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 } }8.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 } }8.6 正则表达式练习1
需求：
请编写正则表达式验证用户输入的手机号码是否满足要求。
请编写正则表达式验证用户输入的邮箱号是否满足要求。
请编写正则表达式验证用户输入的电话号码是否满足要求。
验证手机号码 13112345678 13712345667 13945679027 139456790271
验证座机电话号码 020-2324242 02122442 027-42424 0712-3242434
验证邮箱号码 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
代码示例：
public class RegexDemo4 { public static void main(String[] args) { /* 需求 请编写正则表达式验证用户输入的手机号码是否满足要求。请编写正则表达式验证用户输入的邮箱号是否满足要求。请编写正则表达式验证用户输入的电话号码是否满足要求。 验证手机号码 13112345678 13712345667 13945679027 139456790271 验证座机电话号码 020-2324242 02122442 027-42424 0712-3242434 验证邮箱号码 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn */ //心得: //拿着一个正确的数据，从左到右依次去写。 //13112345678 //分成三部分: //第一部分:1 表示手机号码只能以1开头 //第二部分:[3-9] 表示手机号码第二位只能是3-9之间的 //第三部分:\\d{9} 表示任意数字可以出现9次，也只能出现9次 String regex1 = "1[3-9]\\d{9}"; System.out.println("13112345678".matches(regex1));//true System.out.println("13712345667".matches(regex1));//true System.out.println("13945679027".matches(regex1));//true System.out.println("139456790271".matches(regex1));//false System.out.println("-----------------------------------"); //座机电话号码 //020-2324242 02122442 027-42424 0712-3242434 //思路: //在书写座机号正则的时候需要把正确的数据分为三部分 //一:区号@\\d{2,3} // 0:表示区号一定是以0开头的 // \\d{2,3}:表示区号从第二位开始可以是任意的数字，可以出现2到3次。 //二:- ?表示次数，日次或一次 //三:号码 号码的第一位也不能以日开头，从第二位开始可以是任意的数字，号码的总长度:5-10位 String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}"; System.out.println("020-2324242".matches(regex2)); System.out.println("02122442".matches(regex2)); System.out.println("027-42424".matches(regex2)); System.out.println("0712-3242434".matches(regex2)); //邮箱号码 //3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn //思路: //在书写邮箱号码正则的时候需要把正确的数据分为三部分 //第一部分:@的左边 \\w+ // 任意的字母数字下划线，至少出现一次就可以了 //第二部分:@ 只能出现一次 //第三部分: // 3.1 .的左边[\\w&&[^_]]{2,6} // 任意的字母加数字，总共出现2-6次(此时不能出现下划线) // 3.2 . \\. // 3.3 大写字母，小写字母都可以，只能出现2-3次[a-zA-Z]{2,3} // 我们可以把3.2和3.3看成一组，这一组可以出现1次或者两次 String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}"; System.out.println("3232323@qq.com".matches(regex3)); System.out.println("zhangsan@itcast.cnn".matches(regex3)); System.out.println("dlei0009@163.com".matches(regex3)); System.out.println("dlei0009@pci.com.cn".matches(regex3)); //24小时的正则表达式 String regex4 = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d"; System.out.println("23:11:11".matches(regex4)); String regex5 = "([01]\\d 2[0-3])(:[0-5]\\d){2}"; System.out.println("23:11:11".matches(regex5)); } }8.7 正则表达式练习2
需求 请编写正则表达式验证用户名是否满足要求。要求:大小写字母，数字，下划线一共4-16位 请编写正则表达式验证身份证号码是否满足要求。 简单要求: 18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x 复杂要求: 按照身份证号码的格式严格要求。
身份证号码: 41080119930228457x 510801197609022309 15040119810705387X 130133197204039024 430102197606046442
代码示例：
public class RegexDemo5 { public static void main(String[] args) { /* 正则表达式练习: 需求 请编写正则表达式验证用户名是否满足要求。要求:大小写字母，数字，下划线一共4-16位 请编写正则表达式验证身份证号码是否满足要求。 简单要求: 18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x 复杂要求: 按照身份证号码的格式严格要求。 身份证号码: 41080119930228457x 510801197609022309 15040119810705387X 130133197204039024 I 430102197606046442 */ //用户名要求:大小写字母，数字，下划线一共4-16位 String regex1 = "\\w{4,16}"; System.out.println("zhangsan".matches(regex1)); System.out.println("lisi".matches(regex1)); System.out.println("wangwu".matches(regex1)); System.out.println("$123".matches(regex1)); //身份证号码的简单校验: //18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x String regex2 = "[1-9]\\d{16}(\\d|x|x)"; String regex3 = "[1-9]\\d{16}[\\dXx]"; String regex5 = "[1-9]\\d{16}(\\d(?i)x)"; System.out.println("41080119930228457x".matches(regex3)); System.out.println("510801197609022309".matches(regex3)); System.out.println("15040119810705387X".matches(regex3)); System.out.println("130133197204039024".matches(regex3)); System.out.println("430102197606046442".matches(regex3)); //忽略大小写的书写方式 //在匹配的时候忽略abc的大小写 String regex4 = "a((?i)b)c"; System.out.println("------------------------------"); System.out.println("abc".matches(regex4));//true System.out.println("ABC".matches(regex4));//false System.out.println("aBc".matches(regex4));//true //身份证号码的严格校验 //编写正则的小心得: //第一步:按照正确的数据进行拆分 //第二步:找每一部分的规律，并编写正则表达式 //第三步:把每一部分的正则拼接在一起，就是最终的结果 //书写的时候:从左到右去书写。 //410801 1993 02 28 457x //前面6位:省份，市区，派出所等信息，第一位不能是0，后面5位是任意数字 [1-9]\\d{5} //年的前半段: 18 19 20 (18|19|20) //年的后半段: 任意数字出现两次 \\d{2} //月份: 01~ 09 10 11 12 (@[1-9]|1[0-2]) //日期: 01~09 10~19 20~29 30 31 (0[1-9]|[12]\\d|3[01]) //后面四位: 任意数字出现3次 最后一位可以是数字也可以是大写x或者小写x \\d{3}[\\dXx] String regex6 = "[1-9]\\d{5}(18|19|20)\\d{2}(@[1-9]|1[0-2])(@[1-9]|[12]\\d|3[01])\\d{3}[\\dxXx]"; System.out.println("41080119930228457x".matches(regex6)); System.out.println("510801197609022309".matches(regex6)); System.out.println("15040119810705387X".matches(regex6)); System.out.println("130133197204039024".matches(regex6)); System.out.println("430102197606046442".matches(regex6)); } }8.8 本地数据爬取
Pattern：表示正则表达式Matcher：文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。 在大串中去找符合匹配规则的子串。
代码示例：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexDemo6 { public static void main(String[] args) { /* 有如下文本，请按照要求爬取数据。 Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11， 因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台 要求:找出里面所有的JavaXX */ String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" + "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台"; //1.获取正则表达式的对象 Pattern p = Pattern.compile("Java\\d{0,2}"); //2.获取文本匹配器的对象 //拿着m去读取str，找符合p规则的子串 Matcher m = p.matcher(str); //3.利用循环获取 while (m.find()) { String s = m.group(); System.out.println(s); } } private static void method1(String str) { //Pattern:表示正则表达式 //Matcher: 文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。 // 在大串中去找符合匹配规则的子串。 //获取正则表达式的对象 Pattern p = Pattern.compile("Java\\d{0,2}"); //获取文本匹配器的对象 //m:文本匹配器的对象 //str:大串 //p:规则 //m要在str中找符合p规则的小串 Matcher m = p.matcher(str); //拿着文本匹配器从头开始读取，寻找是否有满足规则的子串 //如果没有，方法返回false //如果有，返回true。在底层记录子串的起始索引和结束索引+1 // 0,4 boolean b = m.find(); //方法底层会根据find方法记录的索引进行字符串的截取 // substring(起始索引，结束索引);包头不包尾 // (0,4)但是不包含4索引 // 会把截取的小串进行返回。 String s1 = m.group(); System.out.println(s1); //第二次在调用find的时候，会继续读取后面的内容 //读取到第二个满足要求的子串，方法会继续返回true //并把第二个子串的起始索引和结束索引+1，进行记录 b = m.find(); //第二次调用group方法的时候，会根据find方法记录的索引再次截取子串 String s2 = m.group(); System.out.println(s2); } }8.9 网络数据爬取（了解）
需求：
把连接:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i中所有的身份证号码都爬取出来。
代码示例：
public class RegexDemo7 { public static void main(String[] args) throws IOException { /* 扩展需求2: 把连接:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i 中所有的身份证号码都爬取出来。 */ //创建一个URL对象 URL url = new URL("https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i"); //连接上这个网址 //细节:保证网络是畅通 URLConnection conn = url.openConnection();//创建一个对象去读取网络中的数据 BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream())); String line; //获取正则表达式的对象pattern String regex = "[1-9]\\d{17}"; Pattern pattern = Pattern.compile(regex);//在读取的时候每次读一整行 while ((line = br.readLine()) != null) { //拿着文本匹配器的对象matcher按照pattern的规则去读取当前的这一行信息 Matcher matcher = pattern.matcher(line); while (matcher.find()) { System.out.println(matcher.group()); } } br.close(); } }8.10 爬取数据练习
需求：
把下面文本中的座机电话，邮箱，手机号，热线都爬取出来。
来黑马程序员学习Java，手机号:18512516758，18512508907或者联系邮箱:boniu@itcast.cn，座机电话:01036517895，010-98951256邮箱:bozai@itcast.cn，热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090手机号的正则表达式:1[3-9]\d{9}
代码示例：
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexDemo8 { public static void main(String[] args) { /* 需求:把下面文本中的座机电话，邮箱，手机号，热线都爬取出来。 来黑马程序员学习Java， 手机号:18512516758，18512508907或者联系邮箱:boniu@itcast.cn， 座机电话:01036517895，010-98951256邮箱:bozai@itcast.cn， 热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090 手机号的正则表达式:1[3-9]\d{9} 邮箱的正则表达式:\w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}座机电话的正则表达式:θ\d{2,3}-?[1-9]\d{4,9} 热线电话的正则表达式:400-?[1-9]\\d{2}-?[1-9]\\d{3} */ String s = "来黑马程序员学习Java，" + "电话:18512516758，18512508907" + "或者联系邮箱:boniu@itcast.cn，" + "座机电话:01036517895，010-98951256" + "邮箱:bozai@itcast.cn，" + "热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090"; System.out.println("400-618-9090"); String regex = "(1[3-9]\\d{9})|(\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2})" + "|(0\\d{2,3}-?[1-9]\\d{4,9})" + "(400-?[1-9]\\d{2}-?[1-9]\\d{3})"; //1.获取正则表达式的对象 Pattern p = Pattern.compile(regex); //2.获取文本匹配器的对象 //利用m去读取s，会按照p的规则找里面的小串 Matcher m = p.matcher(s); //3.利用循环获取每一个数据 while(m.find()){ String str = m.group(); System.out.println(str); } }8.11 按要求爬取
需求：
有如下文本，按要求爬取数据。
Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台。
需求1：
爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。
需求2：
爬取版本号为8，11，17的Java文本。正确爬取结果为：Java8 Java11 Java17 Java17
需求3：
爬取除了版本号为8，11，17的Java文本。代码示例：
public class RegexDemo9 { public static void main(String[] args) { /* 有如下文本，按要求爬取数据。 Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11， 因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台 需求1:爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。 需求2:爬取版本号为8，11，17的Java文本。正确爬取结果为:Java8 Java11 Java17 Java17 需求3:爬取除了版本号为8，11.17的Java文本， */ String s = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" + "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台"; //1.定义正则表达式 //?理解为前面的数据Java //=表示在Java后面要跟随的数据 //但是在获取的时候，只获取前半部分 //需求1: String regex1 = "((?i)Java)(?=8|11|17)"; //需求2: String regex2 = "((?i)Java)(8|11|17)"; String regex3 = "((?i)Java)(?:8|11|17)"; //需求3: String regex4 = "((?i)Java)(?!8|11|17)"; Pattern p = Pattern.compile(regex4); Matcher m = p.matcher(s); while (m.find()) { System.out.println(m.group()); } } }8.12 贪婪爬取和非贪婪爬取
只写+和表示贪婪匹配，如果在+和后面加问号表示非贪婪爬取
+? 非贪婪匹配
*? 非贪婪匹配
贪婪爬取:在爬取数据的时候尽可能的多获取数据
非贪婪爬取:在爬取数据的时候尽可能的少获取数据
举例：
如果获取数据：ab+
贪婪爬取获取结果:abbbbbbbbbbbb
非贪婪爬取获取结果:ab
public class RegexDemo10 {
public static void main(String[] args) {
/*
只写+和*表示贪婪匹配
+? 非贪婪匹配
*? 非贪婪匹配
贪婪爬取:在爬取数据的时候尽可能的多获取数据
非贪婪爬取:在爬取数据的时候尽可能的少获取数据
ab+:
贪婪爬取:abbbbbbbbbbbb
非贪婪爬取:ab
*/
String s = "Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" +
"经历了很多版木，目前企业中用的最多的是]ava8和]ava11，因为这两个是长期支持版木。" +
"下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
String regex = "ab+";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
while (m.find()) {
System.out.println(m.group());
}
}
}8.13 String的split方法中使用正则表达式
String类的split()方法原型：
public String[] split(String regex)
//参数regex表示正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。/*
有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
要求1:把字符串中三个姓名之间的字母替换为vs
要求2:把字符串中的三个姓名切割出来*/
String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
//细节:
//方法在底层跟之前一样也会创建文本解析器的对象
//然后从头开始去读取字符串中的内容，只要有满足的，那么就切割。
String[] arr = s.split("[\\w&&[^_]]+");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}8.14 String类的replaceAll方法中使用正则表达式
-
String类的replaceAll()方法原型：
/* 有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠 要求1:把字符串中三个姓名之间的字母替换为vs 要求2:把字符串中的三个姓名切割出来*/ String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠"; //细节: //方法在底层跟之前一样也会创建文本解析器的对象 //然后从头开始去读取字符串中的内容，只要有满足的，那么就用第一个参数去替换。 String result1 = s.replaceAll("[\\w&&[^_]]+", "vs"); System.out.println(result1);8.15 正则表达式-分组括号( )
细节：如何识别组号？
只看左括号，不看有括号，按照左括号的顺序，从左往右，依次为第一组，第二组，第三组等等
//需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符 //举例: a123a b456b 17891 &abc& a123b(false) // \\组号:表示把第X组的内容再出来用一次 String regex1 = "(.).+\\1"; System.out.println("a123a".matches(regex1)); System.out.println("b456b".matches(regex1)); System.out.println("17891".matches(regex1)); System.out.println("&abc&".matches(regex1)); System.out.println("a123b".matches(regex1)); System.out.println("--------------------------"); //需求2:判断一个字符串的开始部分和结束部分是否一致?可以有多个字符 //举例: abc123abc b456b 123789123 &!@abc&!@ abc123abd(false) String regex2 = "(.+).+\\1"; System.out.println("abc123abc".matches(regex2)); System.out.println("b456b".matches(regex2)); System.out.println("123789123".matches(regex2)); System.out.println("&!@abc&!@".matches(regex2)); System.out.println("abc123abd".matches(regex2)); System.out.println("---------------------"); //需求3:判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致 //举例: aaa123aaa bbb456bbb 111789111 &&abc&& //(.):把首字母看做一组 // \\2:把首字母拿出来再次使用 // *:作用于\\2,表示后面重复的内容出现日次或多次 String regex3 = "((.)\\2*).+\\1"; System.out.println("aaa123aaa".matches(regex3)); System.out.println("bbb456bbb".matches(regex3)); System.out.println("111789111".matches(regex3)); System.out.println("&&abc&&".matches(regex3)); System.out.println("aaa123aab".matches(regex3));8.16 分组练习
需求:
将字符串：我要学学编编编编程程程程程程。
替换为：我要学编程
String str = "我要学学编编编编程程程程程程"; //需求:把重复的内容 替换为 单个的 //学学 学 //编编编编 编 //程程程程程程 程 // (.)表示把重复内容的第一个字符看做一组 // \\1表示第一字符再次出现 // + 至少一次 // $1 表示把正则表达式中第一组的内容，再拿出来用 String result = str.replaceAll("(.)\\1+", "$1"); System.out.println(result);8.17 忽略大小写的写法
//(?i) ：表示忽略后面数据的大小写 //忽略abc的大小写 String regex = "(?i)abc"; //a需要一模一样，忽略bc的大小写 String regex = "a(?i)bc"; //ac需要一模一样，忽略b的大小写 String regex = "a((?i)b)c";8.18 非捕获分组
非捕获分组：分组之后不需要再用本组数据，仅仅是把数据括起来。
//身份证号码的简易正则表达式 //非捕获分组:仅仅是把数据括起来 //特点:不占用组号 //这里\\1报错原因:(?:)就是非捕获分组，此时是不占用组号的。 //(?:) (?=) (?!)都是非捕获分组//更多的使用第一个 //String regex1 ="[1-9]\\d{16}(?:\\d|x|x)\\1"; String regex2 ="[1-9]\\d{16}(\\d Xx)\\1"; //^([01]\d|2[0-3]):[0-5]\d:[@-5]\d$ System.out.println("41080119930228457x".matches(regex2));8.19 正则表达式练习
手机号码:1[3-9]\\d{9} 座机号码：0\\d{2,3}-?[1-9]\\d{4,9} 邮箱号码：\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2} 24小时：([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d ([01]\\d|2[0-3])(:[0-5]\\d){2} 用户名: \\w{4,16} 身份证号码，简单校验： [1-9]\\d{16}(\\d|X|x) [1-9]\\d{16}[\\dXx] [1-9]\\d{16}(\\d(?i)X) 身份证号码，严格校验： [1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9|[12])\\d|3[01])\\d{3}[\\dXx]
364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
