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

    Java —— String字符串

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    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="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]);
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    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 +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    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));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在这里插入图片描述

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
  • 相关阅读:
    论文解读（Graph-MLP）《Graph-MLP: Node Classification without Message Passing in Graph》
    青少年python系列 39.匿名函数和递归函数
    简单了解一下国产操作系统
    MATLB|具有储能的经济调度及机会约束和鲁棒优化
    索引的设计原则
    R3LIVE源码解析(10) — R3LIVE中r3live_vio.cpp文件
    Linux基础IO
    STM32 - SPI硬件外设
    消息队列-RabbitMQ
    Java设计模式之组合模式
  • 原文地址：https://blog.csdn.net/qq_58801558/article/details/132910090