Java常用API_正则表达式_检验字符串是否满足规则——基础使用方法及综合练习

autumn boot

已于 2024-04-05 16:10:42 修改

阅读量1.5k

点赞数 29

文章标签： java 开发语言

于 2024-04-05 15:36:33 首次发布

本文链接：https://blog.csdn.net/wsxcjg/article/details/137370007

版权

正则表达式可以校验字符串是否满足一定的规则，并用来校验数据格式的合法性。

简单举例：

校验一个qq号是否符合要求

要求：6位到20位之内，不能以0开头，必须全是数字

代码演示：

public class Test1 {
    public static void main(String[] args) {
        //符合要求的字符串
        String qq1 = "1112222333";

        //不符合要求的字符串
        //开头为0
        String qq2 = "0112222333";
        //不是全数字
        String qq3 = "1112222a33";
        //位数非6~20位
        String qq4 = "12345";

        //输出结果
        System.out.println(qq1.matches("[1~9]\\d{5,19}"));
        System.out.println(qq2.matches("[1~9]\\d{5,19}"));
        System.out.println(qq3.matches("[1~9]\\d{5,19}"));
        System.out.println(qq4.matches("[1~9]\\d{5,19}"));
    }
}

运行结果：

我来提取出来使用了正则表达式的语句并解释一下：

接下来我将介绍正则表达式的字符类和与定义字符都有哪些和其表示什么意思：

字符类：

[abc]:        只能是a,b或c
[^abc]:       除了a,b,c之外的任何字符
[a-zA-Z]:     a到z或A到Z
[a-d[m-p]]:   a到d，或m到p
[a-z&&[def]]: a到z和def的交集（即d,e,f）
[a-z&&[^bc]]: a到z和非bc的交集（等同于[ad-z]）
[a-z&&[^m-p]]:a到z和除了m到p的交集（等同于[a-lq-z]）

代码演示：

public class Test2 {
    public static void main(String[] args) {

        //只能是a,b或c
        System.out.println("----------1----------");
        System.out.println("a".matches("[abc]"));//true
        System.out.println("z".matches("[abc]"));//false
        System.out.println("7".matches("[abc]"));//false

        //除了a,b,c之外的任何字符
        System.out.println("----------2----------");
        System.out.println("a".matches("[^abc]"));//f
        System.out.println("z".matches("[^abc]"));//t
        System.out.println("7".matches("[^abc]"));//t

        //a到z或A到Z
        System.out.println("----------3----------");
        System.out.println("a".matches("[a-zA-Z]"));//t
        System.out.println("A".matches("[a-zA-Z]"));//t
        System.out.println("7".matches("[a-zA-Z]"));//f

        //a到d，或m到p
        System.out.println("----------4----------");
        System.out.println("a".matches("[a-d[m-p]]"));//t
        System.out.println("m".matches("[a-d[m-p]]"));//t
        System.out.println("f".matches("[a-d[m-p]]"));//f

        //a到z和def的交集（即d,e,f）
        System.out.println("----------5----------");
        System.out.println("a".matches("[a-z&&[def]]"));//f
        System.out.println("d".matches("[a-z&&[def]]"));//t
        System.out.println("7".matches("[a-z&&[def]]"));//f

        //a到z和非bc的交集（等同于[ad-z]）
        System.out.println("----------6----------");
        System.out.println("a".matches("[a-z&&[^bc]]"));//t
        System.out.println("b".matches("[a-z&&[^bc]]"));//f
        System.out.println("7".matches("[a-z&&[^bc]]"));//f

        //a到z和除了m到p的交集（等同于[a-lq-z]）
        System.out.println("----------7----------");
        System.out.println("a".matches("[a-z&&[^m-p]]"));//t
        System.out.println("m".matches("[a-z&&[^m-p]]"));//f
        System.out.println("0".matches("[a-z&&[^m-p]]"));//f

    }
}

运行结果：

注意：

正则表达式的字符类一个中括号只能判断字符串中的一个字符，若对长度为2以上的字符串使用正则表达式的字符类判断，那么需要对应长度数量的中括号，第一个字符会根据第一个中括号中的条件判断，后面的字符则会根据后面的中括号判断。

代码演示：

public class Test3 {
    public static void main(String[] args) {
        System.out.println("ab".matches("[abc][abc]"));//true
        System.out.println("ab".matches("[abc]"));//false
    }
}

运行结果：

预定义字符：

预定义字符和字符类的作用差不多，单独使用只匹配一个字符，并且两者可以通过不同形式表达相同限制范围。

代码演示：

public class Test4 {
    public static void main(String[] args) {
        //预定义字符  单个字符

        //  .    任何字符
        System.out.println("------1------");
        System.out.println("a".matches("."));//true
        System.out.println("a你".matches("."));//false
        System.out.println("a你".matches(".."));//true


        //  \d  一个数字:[0-9]
        System.out.println("------2------");
        System.out.println("a".matches("\\d"));//f
        System.out.println("1".matches("\\d"));//t
        System.out.println("11".matches("\\d"));//f


        //  \D  非数字:[^0-9]
        System.out.println("------3------");
        System.out.println("a".matches("\\D"));//t
        System.out.println("1".matches("\\D"));//f
        System.out.println("aa".matches("\\D"));//f


        //  \s  一个空白字符:[\t\n\x0B\f\r]
        System.out.println("------4------");
        System.out.println("\t".matches("\\s"));//t
        System.out.println("a".matches("\\s"));//f
        System.out.println("\t\t".matches("\\s"));//f


        //  \S  非空白字符:[^\s]  与上一个空白字符为补集
        System.out.println("------5------");
        System.out.println("\t".matches("\\S"));//f
        System.out.println("a".matches("\\S"));//t
        System.out.println("aa".matches("\\S"));//f


        //  \w  [a-zA-Z_0-9]英文、数字、下划线
        System.out.println("------6------");
        System.out.println("a".matches("\\w"));//t
        System.out.println("A".matches("\\w"));//t
        System.out.println("1".matches("\\w"));//t
        System.out.println("只".matches("\\w"));//f
        System.out.println("因".matches("\\w"));//f
        System.out.println("aa".matches("\\w"));//f


        //  \W(大写W)  [^\w] 一个非单词字符  与上一个单词字符为补集
        System.out.println("------7------");
        System.out.println("a".matches("\\W"));//f
        System.out.println("A".matches("\\W"));//f
        System.out.println("1".matches("\\W"));//f
        System.out.println("只".matches("\\W"));//t
        System.out.println("因".matches("\\W"));//t
        System.out.println("aa".matches("\\W"));//f

    }
}

运行结果：

数量词（与字符类或预定义字符搭配使用）：

通过字符类或预定义字符与数量词搭配使用，可以达到一个字符类或预定义字符判断多个字符。

常用数量词有：

X为字符类或预定义字符
X?     一次或零次
X*     零次或多次
X+     一次或多次
X{n}   正好n次
X{n,}  至少n次
X{n,m} 至少n但不超过m次

代码演示：

这里我都使用的预定义字符 . 表示任意字符都可以

public class Test5 {
    public static void main(String[] args) {
        //使用数量词  可以判断多个字符
        //X为字符类或预定义字符
        //X?     一次或零次
        System.out.println("------1------");
        System.out.println("".matches(".?"));//t
        System.out.println("a".matches(".?"));//t
        System.out.println("aa".matches(".?"));//f

        //X*     零次或多次
        System.out.println("------2------");
        System.out.println("".matches(".*"));//t
        System.out.println("a".matches(".*"));//t
        System.out.println("aa".matches(".*"));//t

        //X+     一次或多次
        System.out.println("------3------");
        System.out.println("".matches(".+"));//f
        System.out.println("a".matches(".+"));//t
        System.out.println("aa".matches(".+"));//t

        //X{n}   正好n次
        System.out.println("------4------");
        System.out.println("".matches(".{2}"));//f
        System.out.println("a".matches(".{2}"));//f
        System.out.println("aa".matches(".{2}"));//t

        //X{n,}  至少n次
        System.out.println("------5------");
        System.out.println("".matches(".{2,}"));//f
        System.out.println("a".matches(".{2,}"));//f
        System.out.println("aa".matches(".{2,}"));//t
        System.out.println("aaa".matches(".{2,}"));//t

        //X{n,m} 至少n但不超过m次
        System.out.println("------6------");
        System.out.println("".matches(".{1,3}"));//f
        System.out.println("a".matches(".{1,3}"));//t
        System.out.println("aa".matches(".{1,3}"));//t
        System.out.println("aaa".matches(".{1,3}"));//t
        System.out.println("aaaa".matches(".{1,3}"));//f

        //混合使用
        System.out.println("----混合举例----");
        //要求十个单词字符
        System.out.println("234abcABC_".matches("\\w{10}"));//t
        //要求数字或字母但不能是abc，且位数为5-10位
        System.out.println("123abcABC".matches("[0-9a-zA-Z&&[^abc]]{5,10}"));//f
        System.out.println("123abcABC123123".matches("[0-9a-zA-Z&&[^abc]]{5,10}"));//f
        System.out.println("123defABC".matches("[0-9a-zA-Z&&[^abc]]{5,10}"));//t

    }
}

运行结果：

基本练习1：

题目：使用正则表达式验证用户输入的手机号码、座机号码、邮箱号是否满足要求。

手机号码要求：第一位为1，第二位为3到9的数字，每一位都为数字，总位数要为11位

举例：13011112222

座机号码要求：第一部分:区号要求：以0开头，每一位都为数字，3位或4位

第二部分: - 要求：可以出现也可以不出现，即0次或1次

第三部分:号码要求：不能以0开头，由5到10位数字组成

举例：0234-123456 02222222

邮箱号要求：第一部分:@左边要求：字母数字或下划线都可，无位数限制，但至少有一位

第二部分:@ 要求：必须出现，且只能出现一次

第三部分:@右边要求：

也分为三部分：1.分隔符号点: . 的左边:字母或者数字，2到6位

2. 分隔符号点: . : 必须有且只有一个 .

3.分隔符号点: . 的右边 :字母2到3位

4.2和3可出现1到2次，即可以后缀.com.cn

举例：abc123@111.com 123@test.com.cn

编写代码：

public class Test6 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        //手机号码验证
        System.out.println("请输入手机号码：");
        while (true) {
            String phone = sc.next();
            if(phone.matches("1[3-9]\\d{9}")) {
                System.out.println("输入的手机号满足要求");
                break;
            } else {
                System.out.println("输入的手机号不满足要求，请重新输入：");
            }
        }

        //座机号码验证
        System.out.println("请输入座机号码：");
        while (true) {
            String landline = sc.next();
            if(landline.matches("0\\d{2,3}\\-?[1-9]{4,9}")) {
                System.out.println("输入的座机号码满足要求");
                break;
            } else {
                System.out.println("输入的座机号码不满足要求，请重新输入：");
            }
        }

        //邮箱号验证
        System.out.println("请输入邮箱号：");
        while (true) {
            String email = sc.next();
            if(email.matches("\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}")) {
                System.out.println("输入的邮箱号满足要求");
                break;
            } else {
                System.out.println("输入的邮箱号不满足要求，请重新输入：");
            }
        }

    }
}

运行结果：

基本练习2：

题目：校验身份证号码

举例：11122220000101361x

分析要求：前面6位：第一位不为0，其余五位都为数字

再四位为年份：年份前两位为18、19、20，后两位任意两位数字

两位月份：01 ~ 12

两位日期：01 ~31

最后四位：前三位可以为任意数字，最后一位可以为数字可以为大写X或小写x

编写代码：

public class Test7 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身份证号码：");
        while (true) {
            String personId = sc.next();
            if (personId.matches("[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|10|11|12)((0[1-9])|([12]\\d)|(3[01]))\\d{3}[\\dXx]")) {
                System.out.println("输入的身份证号码满足要求");
                break;
            } else {
                System.out.println("输入的身份证号码不满足要求，请重新输入：");
            }
        }
    }
}