9. Java字符串支持正则表达式的方法

Java ------ String字符串

- - - - [1. 正则表达式](#1. 正则表达式)
        
        [2. String正则API](#2. String正则API)
        
        [3. Object类和toString方法](#3. Object类和toString方法)
        
        [4. equals方法](#4. equals方法)
        
        [5. 包装类及Number](#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

|----------------------------------------------------------------------------------------------|
| 正则表达式的分组：使用`()`进行分组表示分组（将`()`里的正则表达式看作一个整体），使用`|`表示或关系作用：用于匹配、查找和替换符合特定规则的文本 |

简单使用代码

java 复制代码

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

java 复制代码

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="fancq@tarena.com.cn";
        // 电子邮箱正则表达式
        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方法 |

java 复制代码

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方法的比较规则与`==`相同 |

java 复制代码

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;
    }
}

java 复制代码

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对象

java 复制代码

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"));
    }
}