正则表达式

已于 2023-03-14 20:48:45 修改
阅读量109 收藏
点赞数 3
分类专栏： 编程技巧 文章标签： java Powered by 金山文档
于 2023-03-14 20:47:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DQ3335/article/details/129539806
版权

正则的应用场景：

  • 密码格式校验、密码匹配校验

  • 字符串匹配

  • 字符串替换

import java.util.regex.Pattern;

public class lamda {
    public static void main(String[] args) throws Exception {
        System.out.println("密码格式正确:"+isRightToInputPassword("aaaaaa"));
        System.out.println("密码格式正确:"+isRightToInputPassword("dongqingDq#123"));
    }
    //构建密码的输入操作理解
    /**@Parmarms: 参数值(输入的式字符串的理解操作)
     * @DEFENATION 定义量
     * 1. 6~16位字符
     * 2.数字
     * 3.大小写字母
     * 4.特殊字符组组合
     * */
    /**
     * 如此循环操作，如何进行理解才是非常关键的操作之一
     * */
    public static boolean isRightToInputPassword(String password) throws Exception{
//        //定义小写的数据判定
//         boolean isLowerCase=false;
//         //定义大写的数据判定
//         boolean isUpperCase=false;
//         //定义特殊字符的数据判定
//         boolean isSpecial=false;
//         //定义数字的数据判定
//         boolean isInt=false;
//         char [] passwordArray= password.toCharArray();
//         int length=passwordArray.length;
//         if (length <6 || length > 16){
//            throw new Exception("对不起，你所输入的字符长度是不合法的");
//        }
//        //对相关的字符串进行设计操作，如何实现是非常必要的理解之一
//        for (char c : passwordArray){
//             if (c>'a' && c<'z'){
//                 isLowerCase = true;
//                 continue;
//             }
//             if (c>'A' && c<'Z') {
//                 isUpperCase=true;
//                 continue;
//             }
//             //构建数字的assidoc数字码来进行求解
//             if (c>48 && c<57){
//                 isInt=true;
//                 continue;
//             }
//             if (c>33 && c<47){
//                 isSpecial=true;
//             }
//        }
//         return isLowerCase && isInt && isSpecial && isUpperCase;
//     }
        return Pattern.matches("^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[~@#S%*_\\-+=:.?])[A-Za-z0-9~@#S%*_\\-+=:.?]{8,20}$", password);
    }
}
import java.util.regex.Pattern;

public class StringMatch {
    private static final String target="fbcd&dongqing";
    public static void main(String[] args) {
        String name="fbcd&dongqing";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(isRuslt);
    }
}

关于正则表达式的核心就是正则校验的操作形式理解

\xx系正则表达式：

  • \d寻求数字的联合求解（表示一个数字）

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="aaa\\d";
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="aaa5";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(isRuslt);
    }
}
import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="aaa\\dbbb";
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="aaa5.1bbb";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(isRuslt);
    }
}

\\d \\d后面跟上两个数字

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="aaa\\d\\d";
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="aaa53";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(isRuslt);
    }
}

\D表示后面跟上一个非数字

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="aaa\\D";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="aaas";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

\D\D\D表示长度为3的非数字字符串

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="\\D\\D\\D";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="aaa";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

111\\\D222 表示111和222之间跟上一个非数字

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="111\\D222";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="111t222";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

\w表示一个字母（大小写）、数字、下划线

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23\\w417";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23_417";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

\W表示这个位置除了字母，数字，下划线之外所有的特殊字符

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23\\W417";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23#417";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

\s表示匹配一个看不见的符号，即为空格制表符等

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23\\s417";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23 417";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}
import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23\\s417";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23 417";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

\S表示一个看得见的符号

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23\\S417";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23a417";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

\num后面跟数字表示匹配第几个括号的内容

  • 直接进行匹配然后添加相关操作

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="ab(c)d\\1";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abcdc";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}
import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="ab(cd)\\1";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abcdcd";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}
import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="ab(c)(d)\\1\\2";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abcdcd";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 注意与括号相关的理解操作，如何进行实现是非常必要的，主要是匹配问题

特殊系正则：

. 表示一个字符位置（可以进行多个组和表示多个字符）

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23....417";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23aatt417";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

|表示输入的字符满足后面所跟字符关系，才符合条件

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23(aa||bb||cc)";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23bb";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 注意事项：还是应该对相关字符括号进行明确，注意字符串的拼接理解

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23(aa||bb||cc)22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23bb22";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

等同于或操作

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23(aaaaaaa|bbbbbbb)22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23bbbbbbb22";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 运用直线操作可以代表相关的字符串类型

?表示匹配前面的子表达式0次或者一次

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="abc?de";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abcde";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 只能说匹配的是前面的单个子表达式（在这里就理解为除c or 包括c吧）

+匹配前面的子表达式一次或者多次(至少一次)

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="abc+de";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abccccccde";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 这里面是否有一种迭代的思想在里面呢？

*表示ab和de之间有任意个子表达式的匹配个数

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="abc*de";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abde";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 居然可以表示0个！

括号系正则 【】{}

[]表示匹配括号中的任意字符操作

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23[abc]22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23c22";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 只能代表字符类型的匹配操作

[^xxx]表示不与括号中的字符匹配，即除括号里面的字符去匹配其他的

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23[^abc]22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23e22";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

[a-z]表示a-z之间所有字符都满足条件的匹配

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23[a-z]22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23f22";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 这个表示闭区间操作

[1-9]表示1~9之间所有字符都满足匹配条件

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23[1-9]22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23922";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 此方法只能表示数字1~9之间的相关数字操作，千万需要对操作进行注意

  • 此方法等价于\d的操作理解，如何进行实现是非常必要的操作之一

[^xxx]表示相关的非符合操作的字符串

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23[^a-z]22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23!22";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 这个除了相关字符的理解，是可以对特殊字符进行操作的！

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="23[^1-9]22";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="23a22";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

{n}这里的n表示非负整数，匹配确定的前面的表达式n次

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="abc{4}de";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abccccde";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}
import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="ab(xx|yy){4}de";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abyyyyyyyyde";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

确定的子表达式是否只是一个单个的字符串的理解呢？

{n，m}表示子表达式最多匹配m次,最少匹配n次

import java.util.regex.Pattern;

public class StringMatch {
    //原来整个必须是固定格式的操作才是符合概念理解的操作的
    private static final String target="abc{2,4}de";
    /**为什么java里面和他给的语法完全不一致啊，为什么会是两个反斜杠呢？
     * */
    public static void main(String[] args) {
        //还是需要注意字符转换的操作
        String name="abcccde";
        boolean isRuslt= Pattern.matches(target,name);
        System.out.println(target);
        System.out.println(isRuslt);
    }
}

  • 依旧是闭区间啊

FBCD1012
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IP 正则表达式验证
12-12
您可能感兴趣的文章:javascript 手机号码正则表达式验证函数JS正则表达式验证数字代码JavaScript正则表达式验证身份证号码是否合法(两种方法)jquery正则表达式验证（手机号、身份证号、中文名称）邮箱地址正则...
正则表达式系列|（以xx开头xx结尾提取、切分、替换）
Oaklkm的博客
08-01 1575
正则表达式是对字符串操作的一种逻辑公式；作用：检索、替换、切分那些符合某个模式(规则)的文本，可以通过一些设定的规则来匹配一些字符串，是一个强大的字符串匹配工具。以上就是正则表达式用来检索、替换那些符合某个模式(规则)的文本案例，后续会陆续补充完善。
一看就懂：正则表达式
热门推荐
小白一个
03-25 7万+
案例引入 在讲正则表达式前，我们不妨先从一个场景来逐渐引入。 你可能有过这样的经历：我们去某些网站注册帐号，当你在设置密码的时候，网站会提示你密码的长度范围，以及对应的规则限制（如下图）。 根据上图，我们将密码设置规则可以描述为两个条件： （1）长度为6-16位； （2）密码中必须包含数字，大写字母，小写字母，特殊字符（指定字符）； 现在假设我们不知道正则表达式，作为程序员的你，该如何去实现这样一个密码验证呢？ 下面是我写的一个校验方法（样本）： /** * 校验用户密码是否满足..
正则表达式（常用版）
BLWY_1124的博客
05-25 4万+
正则表达式 是用来描述字符串内容格式，使用它通常用于匹配一个字符串的内容是否符合格式要求 正则表达式的语法： 1.[]:表示一个字符,该字符可以是[]中指定的内容 例如: [abc]:这个字符可以是a或b或c [a-z] :表示任意一个小写字母 [a-zA-Z] :表示任意一个字母 [a-zA-Z0-9_] :表示任意一个数字字母下划线 [^abc] :该字符只要不是a或b或c 2.预定义字符: . :表示任意一个字符,没有范围限制 \d :表示任意一个数字,等同于[0-9] \w :表示任意一个单词
JavaScript正则表达式
01-08
1、正则表达式是描述字符模式的对象，正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。 2、String和RegExp都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。 3、...
正则表达式汇总-Labview
03-25
正则表达式汇总
匹配中文汉字的正则表达式介绍
12-13
匹配中文字符的正则表达式： [\u4e00-\u9fa5] 或许你也需要匹配双字节字符，中文也是双字节的字符 代码如下: 匹配双字节字符(包括汉字在内)：[^\x00-\xff] 注：可以用来计算字符串的长度（一个双字节字符长度计2，...
正则表达式大全.docx
10-13
该文件总结了一部分正则表达式，在学习判断用户名和密码的过程中会有所帮助，仅供参考，如果有总结不对的地方，请联系作者修改
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 296
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1416
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 559
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1312
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 751
consul官网地址。
迭代器模式
LuckFairyLuckBaby的博客
04-23 469
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 701
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
java通过Comparator比较器对集合进行多属性连续分组内升降排序，以及null空值排最前或最后
hkl_Forever的博客
04-26 137
一、排序数据准备，分别对 one、two、three 三个属性进行连续分组内排序。连续排序，并且把被排序属性值为null的排在最后。连续排序，并且把被排序属性值为null的排在最后。
@Value
最新发布
思索的涟漪，突破自我
04-26 167
Value注解是 Spring 框架中的一个注解，用于从属性文件、环境变量、Java 系统属性等地方读取值，并将这些值注入到 Spring 管理的 Bean 中。
正则表达式正则表达式
04-17
正则表达式（Regular Expression）是一种用于匹配、查找和替换文本的强大工具。它是由一系列字符和特殊字符组成的模式，可以用来描述字符串的特征。正则表达式在各种编程语言和文本编辑器中广泛应用。 以下是正则...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值