9. Java字符串支持正则表达式的方法
Java —— String字符串
-
-
-
-
-
- 1. 正则表达式
- 2. String正则API
- 3. Object类和toString方法
- 4. equals方法
- 5. 包装类及Number
-
-
-
-
1. 正则表达式
| 正则表达式（Regular Expression）：简称为Regex或RegExp，是一种用于描述字符串模式的工具 作用：用于匹配、查找和替换符合特定规则的文本 |
匹配规则：
字符匹配：
普通字符：表示匹配该字符本身
转义字符（\）：用于匹配特殊字符，如.表示匹配句点字符
字符类（[ ]）：用于匹配一组字符中的任意一个字符，如[abc]表示匹配a、b或c
范围（-）：用于指定字符范围，如[a-z]表示匹配任意小写字母
排除（^）：用于在字符类中排除某个字符，如[^0-9]表示匹配除数字外的任意字符
量词：
*：匹配前面元素的零次或多次；X*：表示0个或多个X
+：匹配前面元素的一次或多次；X+：表示表示1个或任意多个X（大于等于1个X）
?：匹配前面元素的零次或一次；X?：表示0个或1个X
{n}：匹配前面元素恰好出现n次；X{n}：表示n个X
{n, m}：匹配前面元素至少出现n次，最多出现m次；X{n,}：表示n到多个X；X{n,m}：表示n到m个X
特殊字符：
.：匹配除换行符以外的任意一个字符
^：匹配输入字符串的开始位置
$：匹配输入字符串的结束位置 示例：用户名（8-10个连续字符）^\w{8,10}$或者\w{8,10}
\b：匹配单词边界
\d：匹配数字字符
\w：匹配字母、数字或下划线字符
分组和捕获：
()：用于将一组字符括起来，可以进行分组和捕获
其他操作符：
|：用于在两个模式之间选择一个匹配
?:：用于设置匹配为非捕获模式，不将结果存储到捕获组中
使用格式及示例
正则表达式是记录文本规则的代码（对字符串数据进行一些复杂匹配，查找，替换等）
[abc]：a、b、c中任意一个字符
[^abc]：除了a、b、c的任意字符
[a-z]：a、b、c、……z中的任意一个字符
[a-zA-Z0-9]：a ~ z、A ~ Z、0 ~ 9中任意一个字符
[a-z&&[^bc]]：a~z中除了b和c以外的任意一个字符，其中&&表示“与”的关系
\d：任意一个数字字符，相当于[0-9]
\D：非数字字符，相当于[^0-9]
\s：空白字符，相当于[\t\n\x0B\f\r]
\S：非空白字符，相当于[^\s]
\w：单词字符，相当于[a-zA-Z_0-9]
\W：非单词字符，相当于[^\w]
- 邮政编码（长度为6的数字）的3种正则表达式写法
①[0-9][0-9][0-9][0-9][0-9][0-9]
②\d\d\d\d\d\d
③\d{6}- 匹配.jar包
\w\.jar
| 正则表达式的分组：使用`()`进行分组表示分组（将`()`里的正则表达式看作一个整体），使用`|`表示或关系 作用：用于匹配、查找和替换符合特定规则的文本 |
- 简单使用代码
package regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test {
public static void main(String[] args) {
String input = "The quick brown fox jumps over the lazy dog.";
// 将时间提取出来
System.out.println(splitDate("Date: 2023-09-15 Time: 11:56:09"));
// 根据长度替换
System.out.println("替换后的文本：" + replacement(input, 4));
// 非捕获模式
System.out.println("quick是否存在：" + nonCapture(input, "quick"));
}
/**
* 将时间分离
* @param input 字符串格式的时间
* @return 分离后的结果
*/
public static String splitDate(String input){
// 匹配日期和时间
String patternString = "Date: (\\d{4})-(\\d{2})-(\\d{2}) Time: (\\d{2}):(\\d{2}):(\\d{2})";
// 创建 Pattern 对象
Pattern pattern = Pattern.compile(patternString);
// 创建 Matcher 对象，并进行匹配
Matcher matcher = pattern.matcher(input);
String year = null, month = null, day = null, hour = null, minute = null, second = null;
// 如果匹配成功，输出匹配结果
if (matcher.find()) {
// 捕获第一个分组：年份
year = matcher.group(1);
// 捕获第二个分组：月份
month = matcher.group(2);
day = matcher.group(3);
hour = matcher.group(4);
minute = matcher.group(5);
second = matcher.group(6);
} else {
System.out.println("No match found.");
}
return "年份：" + year + " 月份：" + month + " 天：" + day + " 小时：" + hour + " 分：" + minute + " 秒：" + second;
}
/**
* 根据单词长度将单词替换为****
* @param input 需要替换的文本
* @param n 替换的单词长度
* @return 替换后的文本
*/
public static String replacement(String input, int n) {
// 匹配长度为4的单词
String patternString = "\\b[a-zA-Z]{%d}\\b".formatted(n);
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(input);
// 将匹配到的单词替换为 ****
String replaced = matcher.replaceAll("****");
return replaced;
}
/**
* 非捕获模式(查找某个单词是否存在)
*
* @param input 需要查找的文本
* @param str 搜索的单词
* @return 是否存在
*/
public static boolean nonCapture(String input, String str) {
// 匹配单词 quick 或 fast，但不捕获结果
String patternString = "(?:%s)".formatted(str);
// 创建 Pattern 对象
Pattern pattern = Pattern.compile(patternString);
// 创建 Matcher 对象，并进行匹配
Matcher matcher = pattern.matcher(input);
return matcher.find();
}
}
2. String正则API
| matches方法：判断当前字符串是否完全符合给定的正则表达式，成功返回true，否则返回false split(String regex)：根据正则表达式对字符串进行拆分，返回一个拆分后的字符串数组 replaceAll(String regex, String replacement)：将字符串中所有匹配正则表达式的部分替换为指定的字符串 replaceFirst(String regex, String replacement)：将字符串中第一个匹配正则表达式的部分替换为指定的字符串 |
package regex;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Regex {
public static void main(String[] args) {
String mail="[email protected]";
// 电子邮箱正则表达式
String re = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
boolean match = mail.matches(re);
if (!match){
System.out.print("不");
}
System.out.println("符合邮箱号");
// split拆分
String str = "asd123fgh456lkj5";
String[] data = str.split("[0-9]+");
System.out.println("拆分后的数组：" + Arrays.toString(data));
// 将部分数字替换为指定字符串
String strs = "asfdghjlk123456uioq456";
strs = strs.replaceAll("[0-9]+"," 数字 ");
System.out.println("替换后的内容：" + strs);
strs = strs.replaceAll("[a-zA-Z]+", " 字符串 ");
System.out.println("替换后的内容：" + strs);
// 脏话替换
String regex = "(qnmlgb|dsb|cnm|mdzz|nc|djb)";
String message = "qnmlgb!你个dsb，你怎么这么nc！你绝对就是一个djb！";
message = message.replaceAll(regex, "***");
System.out.println(message);
// 网址传参参数拆分
String params = "wd=java&rsv_spt=1&rsv_iqid=0x9ad2a0db0011d8d3&issp=1&f=8&" +
"rsv_bp=1&rsv_idx=2&ie=utf-8&tn=baiduhome_pg&rsv_enter=1&rsv_dl=ib&" +
"rsv_sug3=5&rsv_sug1=3&rsv_sug7=100&rsv_sug2=0&rsv_btype=i&inputT=989&rsv_sug4=1990";
// 先拆分为数组
String[] datas = params.split("&");
System.out.println("转化为数组：" + Arrays.toString(datas) + "\n" + "数组长度：" + datas.length);
for (int i = 0; i < datas.length; i++) {
// 拆分为数组
String[] arrays = datas[i].split("=");
System.out.println("参数名：" + arrays[0]);
System.out.println("参数值：" + arrays[1]);
// 直接拆分数组
datas[i] = datas[i].replaceAll("=", "\t值：");
System.out.println("参数名：" + datas[i]);
}
}
}
3. Object类和toString方法
| Object类：在Java类继承结构中，java.lang.Object类位于顶端 特性：① 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类默认为java.lang.Object类 ② Object类型的引用变量可以指向任何类型对象 toString()方法：用于返回对象值的字符串表示 一般重写： 在自定义类中一般要重写toString()方法 调用：① 字符串 + 对象，自动调用 ② java字符串输出语句，直接调用 ③ toString方法作为调试工具，建议自定义类都重写toString方法 |
public class Point {
private int x;
private int y;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
}
4. equals方法
| equals方法：用于比较两个对象是否相同 在Object中：① Object中的方法，检测一个对象是否等于另外一个对象 ② 在Object类中，判断两个对象是否具有相同的引用，即是否为相同的对象 实际应用：在实际应用中（自定义类），一般需要重写（在Object中的底层实现原理为`==`）,如不重写可能直接调用Object中的底层原理进行比较，从而无法达到所需效果 ==：一般用于比较量的值（可应用于任何类型），引用（比较引用变量中存储的值——地址信息，变量是否指向同一个对象） equals：① （重写）比较两个对象的内容是否相等 ② Object默认的equals方法的比较规则与`==`相同 |
public class Point {
private int x;
private int y;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x && y == point.y;
}
}
package objects;
public class Test {
public static void main(String[] args) {
// 测试Object包下面的toString方法
Point p = new Point(1, 2);
System.out.println("p点：" + p);
// 任何对象和字符串拼接后都是字符串
System.out.println("对象：" + p);
Point a = new Point(1, 2);
System.out.println(a);
System.out.println("地址值不同（是不是同一个）：" + (p == a));
// 在自己创建的类中：equals底层的是==，如果不重写就相当于==，重写之后才具有原本equals的特性
System.out.println("equals底层的是==，需要重写（像不像）：" + p.equals(a));
}
}
5. 包装类及Number
| 包装类（Wrapper Class）：为了使基本数据类型具有面向对象的特性而创建的一组类 意义：包装类提供了许多方法，使得可以像操作对象一样操作基本数据类型 包装类还常用于与泛型集合（如List、Set等）一起使用，因为泛型集合只能存储对象，无法直接存储基本数据类型 自动装箱（Autoboxing）和自动拆箱（Unboxing）：在得包装类和基本数据类型之间的转换更加便捷 包装类的不可变 ① 在构造了包装类对象之后，不可以更改包装类在其中的值 ② 包装类是final的，不能定义他们的子集 Number类（抽象）：是所有数字包装类Byte、Double、Float、Integer、Long和Short的父类 |
Boolean：对应于boolean基本数据类型
Byte：对应于byte基本数据类型
Short：对应于short基本数据类型
Integer：对应于int基本数据类型
Long：对应于long基本数据类型
Float：对应于float基本数据类型
Double：对应于double基本数据类型
Character：对应于char基本数据类型
integer常用方法
获取最值常量：MAX_VALUE(),MIN_VALUE()获取最大值和最小值（其他包装类也有该方法，Short.MAX_VALUE，Double.MAX_VALUE等）
将字符串转换为int：parseInt()是一个静态方法，其他还有Double.parseDouble(str)，Integer.parseInt(str), str不能是浮点数（小数不能解析为整数）,Short.parseShort()等
将字符串转换为数值类型：Integer.valueOf(str),可以使用valueOf()方法将字符串转换为Integer对象
package integer;
public class Integers {
public static void main(String[] args) {
Integer n = 123;
Integer m = 123;
Integer i = Integer.valueOf(123);
System.out.println(n==m);
System.out.println(n.equals(m));
System.out.println(n==i);
System.out.println(n.equals(i));
// 获取到值之后进行类型转换
double d = i.doubleValue();
System.out.println(d);
/*
* 包装类的实用案例
*/
// 获取数字包装类的最大值与最小值
System.out.println("byte的最大值：" + Byte.MAX_VALUE);
System.out.println("byte的最小值：" + Byte.MIN_VALUE);
System.out.println("short的最大值：" + Short.MAX_VALUE);
System.out.println("short的最小值：" + Short.MIN_VALUE);
System.out.println("int的最大值：" + Integer.MAX_VALUE);
System.out.println("int的最小值：" + Integer.MIN_VALUE);
System.out.println("float的最大值：" + Float.MAX_VALUE);
System.out.println("float的最小值：" + Float.MIN_VALUE);
System.out.println("double的最大值：" + Double.MAX_VALUE);
System.out.println("double的最小值：" + Double.MIN_VALUE);
// 将字符串转为（使用对应的包装类）基本数据类型 --- Integer.parseInt(str),str不能是浮点数（小数不能解析为整数）
System.out.println("将字符串转为基本int类型：" + Integer.parseInt("123"));
System.out.println("将字符串转为double基本类型" + Double.parseDouble("123.12"));
}
}