正则表达式小结

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

正则表达式小结_第1张图片

 正则表达式小结_第2张图片

正则表达式小结_第3张图片

正则表达式小结_第4张图片

正则表达式小结_第5张图片

正则表达式常用符号使用 

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

在有+,*,?这些符号时,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="(?\\d\\d)(?\\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));
    }
}

正则表达式小结_第6张图片

正则表达式小结_第7张图片

正则表达式小结_第8张图片

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

        }
    }
}

特殊字符

正则表达式小结_第9张图片

 正则表达式小结_第10张图片

 正则表达式小结_第11张图片

 

牛刀小试

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

正则表达式小结_第12张图片

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

正则表达式:整体匹配 

正则表达式小结_第13张图片

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

正则表达式小结_第14张图片

 

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

    }
}

 

你可能感兴趣的:(正则表达式,前端,后端)