正则表达式小结

我乃cv大师

已于 2022-05-29 18:52:46 修改

阅读量2.5k

点赞数

文章标签：正则表达式前端后端

于 2021-10-26 21:01:43 首次发布

本文链接：https://blog.csdn.net/WC949464367/article/details/120980540

版权

本文详细介绍了正则表达式在Java中的使用，包括特殊符号的含义、贪婪匹配的概念以及如何进行分组匹配。通过实例展示了如何匹配连续数字、选择匹配符的运用、Matcher常用方法，以及在字符串去重和替换中的应用。同时，文章还提供了正则表达式进行部分匹配和整体匹配的实战案例，帮助读者深入理解和掌握正则表达式在字符串处理中的强大功能。

摘要由CSDN通过智能技术生成

正则表达式在字符串操作真的是宝藏！

正则表达式常用符号使用

正则表达式特殊符号，里面有具体的示例范本

在有+，*，？这些符号时，JAVA在匹配时是贪婪匹配，尽可能匹配到最长的字符段

示例测试

public class zhengze {
    public static void main(String[] args) {
                String content="asdadas1778dczxcafasfasxz1556afawragsgsdgsdgh1784arfawrarw123abcd";
                //1.目标：匹配所有四个数字
                //说明
        //1.\\d表示一个任意的数字 其中"\\"是转义符号，用于匹配的格式，不写就报错
        String regStr="\\d\\d\\d\\d";//连续四个数字
        //2.创建模式对象【即正则表达式对象】
        Pattern pattern=Pattern.compile(regStr);
        //3.创建匹配器matcher,按照正则表达式的规则
        //说明：创建匹配器matcher，按照正则表达式的规则，去匹配content
        Matcher matcher=pattern.matcher(content);
        //4.开始匹配
        while (matcher.find()){
          /*  String a=matcher.group(0);
            System.out.println(Integer.valueOf(a));*/
            System.out.println(matcher.group(0));
        }

        /**
         * 小括号表示分组，第一个小括号表示第一组，第二个小括号表示第二组
         */
        String res1="(\\d\\d)(\\d\\d)";
        Pattern pattern1=Pattern.compile(res1);
        Matcher matcher1=pattern1.matcher(content);
        while (matcher1.find()){

            System.out.println(matcher1.group(0));
            System.out.println(matcher1.group(1));
            System.out.println(matcher1.group(2));
            //当分组后，一段内容分为n组内容，总体内容存储在matcher.group(0)中
            //其他分组小内容依次放在group(1),group(2)....中
        }

    String res2="[abcd]";//匹配在abcd中任意的一个字符
    //    String res2="[a-z]";//匹配在a-z中任意的一个字符
    // String res2="[A-Z]";//匹配在A-Z中任意的一个字符
      // String res2="abc";//匹配在abc字符串，默认不区分大小写
        //String res2="(?i)abc";匹配在abc字符串，不区分大小写
        //String res2="[0-9]";//匹配在0-9中任意的一个字符
        //String res2="[^a-z]";//匹配不是a-z之间的任意一个字符
        //String res2="[abcd]";//匹配在abcd中任意的一个字符
        //String res2="\\D";//匹配不在0-9中任意的一个字符
        //String res2="\\w";//匹配大小写英文字母，数字，下划线
        //String res2="\\W";//等价于[^a-zA-Z0-9]

    Pattern pattern2=Pattern.compile(res2);
    Matcher matcher2=pattern2.matcher(content);
    while (matcher2.find()){

        System.out.println(matcher2.group(0));

        //当分组后，一段内容分为n组内容，总体内容存储在matcher.group(0)中
        //其他分组小内容依次放在group(1),group(2)....中
    }
}
    /**
     * matcher.find()
     *
     * 1.根据指定规则，定位满足条件的子字符串，如(1998)
     *
     *  2.找到后，将子字符串的开始的索引记录到matcher对象的属性int[] groups;
     * group[0]=0,把该子字符串的结束的索引+1的值记录到groups[1]=4
     *
     * 3.同时记录oldLast的值为子字符串结束的索引+1的值，即下次执行时，从4开始
     *
     * 每次操作都会重新覆盖一遍
     */
    //[abc]表示可接收的字符，abc任意一字符匹配即可
    //[^abc]表示不可接收的字符，除了abc以外的任意一字符
    //[A-Z] 连字符，即表示[ABCDEFG.....Z]
}

public class 选择匹配符 {
    public static void main(String[] args) {
        String content="wuchena111231吴辰";


        // String resStr="wu|吴";//"|"为选择匹配，表示既可以..又可以..

        // String resStr="[uch]{3,}";//表示由uch中字母组成的任意长度大于3的字符串


        //+使用
        //  String resStr="\\d+";//匹配最大连续数字，数字只要连续就跟着下去匹配

        //*使用
        // String resStr="1*";//匹配0个1或者多个1

        //^定位符,定开头格式，$结束符

       //String resStr="a1?";//匹配a或者a1,JAVA贪婪匹配，能匹配a1绝不匹配a
       // String resStr="^[0-9]+[a-z]*5$";//以至少一个数字作为开头，后面接至少0个小写字母，以5作为结尾
        /**
         * JAVA匹配时是贪婪匹配，尽可能匹配多的字符串
         */
        //String resStr="[\\d]+";
      //  String resStr="(\\d\\d)(\\d\\d)";//分成2组，全部存放在group(0)中，第一组在group(1)中，第二组在group(2)中
        //String resStr="(?<g1>\\d\\d)(?<g2>\\d\\d)";//对分组进行命名，分别存放于group(g1)与group(g2)中

        String resStr="吴辰(?:教育|老师|同学)";//开头确定，后面连接的多选
        String content1="吴辰老师,吴辰教育,吴辰同学";
        Pattern pattern=Pattern.compile(resStr);
        Matcher matcher=pattern.matcher(content1);
        while (matcher.find()){//找到格式匹配的字符串输出
            System.out.println(matcher.group(0));
        }
        //整体匹配
        System.out.println(Pattern.matches(resStr,content1));
    }
}

Matcher常用方法

下面的范例为运用正则表达式进行字符串去重，去不需要的符号

演示了

matcher.matches()方法(字符串整体匹配，只返回true与false)，

matcher.replaceAll()方法对原文进行相应的字符串替换

matcher.start()/matcher.end() 返回字符串中查找的字符段头和尾的索引

反向内部引用"(.)\\1+"表示查找有重复的字符段

反向外部引用"$1"，与"(.)\\1+"配合使用，进行去重

public class MatcherMethod {
    public static void main(String[] args) {
        String content = "hello edu jack tom hello smith hello";
        String resStr = "hello";
        Pattern pattern = Pattern.compile(resStr);
        Matcher matcher = pattern.matcher(content);
       while (matcher.find()){//局部匹配
           System.out.println("============");
           System.out.println(matcher.start());//对应整个字符串对hello的索引,开头和结尾对应
           System.out.println(matcher.end());
           System.out.println("找到："+content.substring(matcher.start(),matcher.end()));//输出所有hello

       }

       System.out.println(matcher.matches());//整体匹配，返回false



        String resStr1="hello";//需要被替代的单词
        Pattern pattern1=Pattern.compile(resStr1);
        Matcher matcher1=pattern1.matcher(content);
        //注意
        String newcontent=matcher1.replaceAll("吴辰");
        //replaceall中填入需要替代的词语，不改变原有字符串，只是返回新的字符串
        System.out.println(newcontent);

        String content1="wuchen";
        String resStr2="\\w{1,}(\\w|\\-)\\w{1,}";
        Pattern pattern2 = Pattern.compile(resStr2);
        Matcher matcher2 = pattern2.matcher(content1);
       System.out.println(matcher2.matches());

        /**
         * 反向引用；例子
         */
        //匹配两个连续的相同数字 (\\d)\\1
        //匹配五个连续相同数字(\\d)\\1{4}
        //匹配个位与千位相同，十位与百位相同的数5225，1551 (\\d)(\\d)\\2\\1
        /**
         * 利用正则表达式去重
         */
        String content3="我我...要要...学编程";

        String resStr3="\\.";

        Pattern pattern3=Pattern.compile(resStr3);

        Matcher matcher3=pattern3.matcher(content3);

        String n1=matcher3.replaceAll("");//去除省略号

        System.out.println(n1);

        pattern3=Pattern.compile("(.)\\1+");//使用此方式，\\1是看是否重复(反向引用)，即输出重复的字段,(.)应该是表示任意字符

        matcher=pattern3.matcher(n1);//此n1为去除省略号后的字符串

       String abc= matcher.replaceAll("$1");//反向引用$1，直接去重

        System.out.println(abc);

        //while (matcher.find()){
          //  System.out.println(matcher.group(0));
       // }


        //去掉重复的字
           Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");//一句话实现字符串去重

    }
}

字符串对于特定的字符进行查找和替换，并且可以省去pattern，写法更加简单

public class 字符替换 {
    public static void main(String[] args) {
        String content="2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，" +
                "几周后其获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日，" ;
        //使用正则表达式，将JDK1.3和JDK1.4替换成JDK
       String s= content.replaceAll("JDK1.3|JDK1.4","JDK");//将JDK1.3，JDK1.4统一替换成JDK
                System.out.println(s);

                //字符匹配(省去pattern)

                content="1388888888";
                if(content.matches("1(3|4|8)\\d{8}")){
                    System.out.println("成功");
                }
                content="hello#abc-jack12sim~cao";
                String S[]=content.split("#|,|-|~");
                  for (String a:S) {
                System.out.println(a);

        }
    }
}

特殊字符

在这里插入图片描述

牛刀小试

正则表达式在字符串中的应用：部分匹配

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.math.BigInteger;
class Solution {
    public int myAtoi(String str) {
        String pattern = "^\\s*([+-]?\\d+)";
        //以零个或多个空格开头(*),后跟零个或一个+-号，再跟一个以上的数字
        Pattern r = Pattern.compile(pattern);

        Matcher m = r.matcher(str);
        if (!m.find( ))  return 0;
        
        BigInteger ans = new BigInteger(m.group(1));//实现开头的去零操作
       if(ans.compareTo(new BigInteger(String.valueOf(Integer.MIN_VALUE)))<0){//数据溢出
            return Integer.MIN_VALUE;
        }
       if(ans.compareTo(new BigInteger(String.valueOf(Integer.MAX_VALUE)))>0){//数据溢出
            return Integer.MAX_VALUE;
        }
        return ans.intValue();
        
    }
}

正则表达式：整体匹配

import java.util.regex.Pattern;

class Solution {
    private static final Pattern PATTERN = Pattern.compile("^(([a-z]+[-]?[a-z]+)|([a-z]*))[!.,]?$");

    public int countValidWords(String sentence) {
        int cnt = 0;
        String[] tokens = sentence.split(" ");
        for (String token : tokens) {
            if (PATTERN.matcher(token).matches() && token.length() != 0) {
                cnt++;
            }
        }
        return cnt;
    }
}

import java.util.regex.Pattern;
class Solution {
 public static String validIPAddress(String queryIP) {
        Pattern pattern = Pattern.compile("([0-9a-fA-F]{1,4}[:]){7}[0-9a-fA-F]{1,4}");
        Pattern pattern1=Pattern.compile("([0-9]{1,3}[.]){3}[0-9]{1,3}");

        if (pattern1.matcher(queryIP).matches()) {
            String arr[]=queryIP.split("\\.");
            for (int i = 0; i <arr.length ; i++) {
                if(Integer.valueOf(arr[i])<0||Integer.valueOf(arr[i])>255){
                    return "Neither";
                }
                else if(arr[i].length()>1&&arr[i].charAt(0)=='0'){
                    return "Neither";
                }
            }
          return "IPv4";
        }
        else {
            if (pattern.matcher(queryIP).matches()) {
                return "IPv6";
            }

            return "Neither";
        }

    }
}