Java-正则表达式

1 先看例题

需求

• 需求：编写一Java程序校验qq号是否复核规范
  1.账号长度必须是5-10
  2.不能以0开头
  3。必须全补是数字

代码为：

public class RegularDemo1 {
    public static void main(String[] args) {
        String m = "1870873";
        System.out.println(Chack(m));
        System.out.println(Chack1(m));
    }
    public static boolean Chack1(String m){
        String regex = "[0-9][0-9]{4,9}";
        return m.matches(regex);
    }
public static boolean Chack(String m){
        boolean flag = false;
        //必须是5-10位
    if(m.length()>=5 && m.length()<=10){
        //不能以0开头
        if(m.charAt(0) != 0){
            flag = true;
            //将字符串转换成数组
            char[] chars = m.toCharArray();
            for (int i = 0; i < chars.length; i++) {
                if(!Character.isDigit(chars[i])){
                    flag = false;
                }
            }
        }
    }else{
        System.out.println("长度不符合QQ号的标准！");
    }
    if(flag){
        return true;
    }else{
        return false;
    }
    }
}

总结：如果用判断和循环的话，代码量太多。如果用正则表达式的话代码量会少很多：如下：

    public static boolean Chack1(String m){
        String regex = "[0-9][0-9]{4,9}";
        return m.matches(regex);
    }

1.1原义字符：

• 原义字符（字符本身就可以当作一个正则表达式）如: #,2,a,b等等

package com.bigdat.java.day18;
/*
        原义字符（字符本身就可以当做一个表达式）
 */
public class RegularDemo2 {
    public static void main(String[] args) {
        String regex = "aa";
        String str = "aacedjji342kjHJLKJJhjl3j";
        //String replaceALL(String regex,String replacement)
        //用给定的替换替换掉与给定的 regex 类型匹配的数据
        System.out.println(str.replaceAll(regex,"-"));
    }
}

1.2字符类：

• []作用是将字符进行分类，可以匹配到中括号中的任意一个字符
• [abc]将来会匹配到abc中任意一个字符

package com.shujia.wyh.day17;
/*
        正则表达式的语法规则：
        字符类：
 */
public class RegularDemo3 {
    public static void main(String[] args) {
        //[]作用是将字符进行分类，可以匹配到中括号中的任意一个字符
        //[abc]将来会匹配到abc中任意一个字符
        String regex = "[abc]";
        String str = "abc1234cc21c21sadcsa&.;123!";
        System.out.println(str.replaceAll(regex,"_"));
    }
}

1.3 范围类 []

package com.shujia.wyh.day17;
/*
        范围类：

 */
public class RegularDemo4 {
    public static void main(String[] args) {
        //需求1：我想要匹配所有的小写字母
//        String regex = "[abcdefghijklmnopqrstuvwxyz]";
        //[a-z]表示匹配a到z中的所有小写字母
        String regex = "[a-z]";
        String str = "abcABC1234ERQcc21c21sDASadcsABCCa&.;123!";
        System.out.println("要匹配的字符串为：\n" + str);
        System.out.println("==========================================");
        System.out.println(str.replaceAll(regex, "_"));

        //需求2：我想要匹配所有的大写字母
        regex = "[A-Z]";
        System.out.println(str.replaceAll(regex, "_"));

        //需求3：我即想要匹配小写字母，也想要匹配大写字母
//        regex = "[a-zA-Z]";
        regex = "[A-z]";
        System.out.println(str.replaceAll(regex, "_"));

        //需求4：我想要匹配所有的数字
        regex = "[0-9]";
        System.out.println(str.replaceAll(regex, "_"));

        //需求5：我想匹配不仅大小写数字还有感叹号，分号咋办？
        regex = "[0-9a-zA-Z!;&.]";
        System.out.println(str.replaceAll(regex, "_"));

        //需求6：我想匹配除了大小写字母和数字以外的符号
        regex = "[^0-9a-zA-Z]";
        System.out.println(str.replaceAll(regex, "_"));
    }
}

1.4 预定义类

预定义类
\d == [0-9] 代表的是数字
\D == [^0-9]代表的是非数字
\s == 空白字符
\w == [a-zA-Z0-9]
\W == [^a-zA-Z0-9]
. == 任意字符

public class RegularDemo5 {
    public static void main(String[] args) {
        String regex = "\\d";  // \\d代表转义，使用它原本的意思
        String str = "abcABC 1234  ERQcc2 1c21sDA Sadcs ABC Ca&.;12  3!";
        System.out.println("要匹配的字符串为：\n" + str);
        System.out.println("==========================================");
        System.out.println(str.replaceAll(regex, "_"));

        regex = "\\D";
        System.out.println(str.replaceAll(regex, "_"));

        regex = "\\s";
        System.out.println(str.replaceAll(regex, "_"));

        regex = "\\w";
        System.out.println(str.replaceAll(regex, "_"));

        regex = "\\W";
        System.out.println(str.replaceAll(regex, "_"));

        regex = ".";
        System.out.println(str.replaceAll(regex, "_"));

        //仅仅单纯要匹配一个字符.
        regex = "[.]";
        System.out.println(str.replaceAll(regex, "_"));
        regex = "\\.";
        System.out.println(str.replaceAll(regex, "_"));
    }
}

1.5 量词分类

量词分类：

    ?:出现了0次或者1次
    +:代表出现了1次或者多次
    *:代表出现了任意次
    {n}:代表出现了n次
    {n,m}:出现了n-m次
    {n,}:代表出现了至少n==次

public class RegularDemo7 {
    public static void main(String[] args) {
        String regex = "^b?";
        String str = "aaaaaabaaacdeaaaafg";
        System.out.println("要匹配的字符串为：\n" + str);
        System.out.println("==========================================");
        System.out.println(str.replaceAll(regex, "_"));

        regex = "^b+";
        System.out.println(str.replaceAll(regex, "_"));

        regex = "^a+"; //匹配连续出现1次以上并且是开头的a
        System.out.println(str.replaceAll(regex, "_"));

        regex = "a+"; //匹配连续出现1次以上的a
        System.out.println(str.replaceAll(regex, "_"));

        regex = "^a{2}"; //匹配连续出现2次的a
        System.out.println(str.replaceAll(regex, "_"));

        regex = "^a{2,5}"; //匹配连续出现2次到5次的a开头
        System.out.println(str.replaceAll(regex, "_"));

        regex = "a{4,}"; //匹配连续出现4次以上
        System.out.println(str.replaceAll(regex, "_"));
    }
}

1.6 分组

• abc{3}只会匹配abccc而不是abc
• 如果进行了分组（abc）就会按照组来

public class RegularDemo8 {
    public static void main(String[] args) {
        //将连续出现了3次以上的abc替换成_
//        String regex = "abc{3,}"; //ab后面接着3次以上的c
        String regex = "(abc){3,}"; //使用小括号将abc看作是一组，然后匹配这组出现了3次以上
        String str = "abccccccccABC123ABC123abcABCabcabcabc123ABC123123";
        System.out.println("要匹配的字符串为：\n" + str);
        System.out.println("==========================================");
        System.out.println(str.replaceAll(regex, "_"));

        //需求2：ABC后面跟上出现1次以上的123为一个整体进行匹配
        //ABC123123123
        regex = "ABC(123){1,}";
        System.out.println(str.replaceAll(regex, "_"));

        //需求3：ABC后面跟上出现1次以上的123或者abc为一个整体进行匹配
        //ABC123123
        //ABCabcabc
        regex = "ABC(123|abc){1,}";
        System.out.println(str.replaceAll(regex, "_"));
    }
}

1.7 反向引用）（在日期案例上用的比较多）

• 将规则进行分组之后可以用$符号调换对应的位置：如；
• (\d{4})-(\d{2})-(\d{2})
  -和($1) ($2) ($3)相互对应

public class RegularDemo9 {
    public static void main(String[] args) {
        //日期案例
        // 2022-03-28  ---> 03/28/2022
        String regex = "(\\d{4})-(\\d{2})-(\\d{2})";
        String str = "2022-03-28 dasdas 2022-04-05";
        System.out.println(str.replaceAll(regex,"$2/$3/$1"));

        //需求2：我不想你取出月份
        regex = "(\\d{4})-(?:\\d{2})-(\\d{2})";
        System.out.println(str.replaceAll(regex,"$2/$1"));
    }
}

1.8 正则表达式在JAVA中的应用

1、字符串的查找操作：Pattern和Matcher
2、字符串的匹配操作：可以使用字符串String类中matches()方法
3、字符串的分割操作：可以使用字符串String类中的split()方法
4、字符串的替换工作：字符串中的replaceAll()方法和replaceFirst()方法

Pattern和Matcher案例

public class RegexText {
    public static void main(String[] args) {
        String str =
                ".user-info-popup_1v_mi {\n" +
                "  position: absolute;\n" +
                "  top: 100%;\n" +
                "  right: 50%;\n" +
                "  display: none;\n" +
                "  margin-top: -4px;\n" +
                "  margin-right: -42px;\n" +
                "  padding: 0 16px 16px;\n" +
                "}";
        String regex = "[0-9]";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);
        int  count = 0;
        while (m.find()) {
            count++;
            System.out.println("找到："+m.group(0)+"共："+count+"个");
        }
    }
}

matches()方法

public class RegularDemo10 {
    public static void main(String[] args) {
        String regex = "\\w{3,}";
        String str = "abcdef123;!";
        //public boolean matches(String regex)告诉这个字符串是否匹配给定的regular expression 。
        System.out.println(str.matches(regex));
        System.out.println("======================================");

String类中的split()方法通过正则表达式规定的规则进行分割

即

        String say = "java is the best  programing language,java xiang-bang-bang";
        String[] q2 = say.split("[ ,-]");
        System.out.println(q2.length);
        for (int i = 0; i < q2.length; i++){
            System.out.println(q2[i]);

public class StringDemo {
    public static void main(String[] args) {
        String str = "this is a text";
        //需求 1
        String[] s1 = str.split("[ ]");
        for (String s : s1) {
            System.out.println(s);
        }

字符串的查找操作：Pattern和Matcher

• pattern p = pattern.compile(String regex)
• Matcher matchers = p.matcher(str)

代码如下

age com.bigdat.java.day18;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
    正则表达式的自我练习
 */
public class RegexText {
    public static void main(String[] args) {
        String str =
                ".user-info-popup_1v_mi {\n" +
                "  position: absolute;\n" +
                "  top: 100%;\n" +
                "  right: 50%;\n" +
                "  display: none;\n" +
                "  margin-top: -4px;\n" +
                "  margin-right: -42px;\n" +
                "  padding: 0 16px 16px;\n" +
                "}";
        String regex = "[0-9]";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);
        int  count = 0;
        while (m.find()) {
            count++;
            System.out.println("找到："+m.group(0)+"共："+count+"个");
        }
    }
}