一文搞懂正则表达式基础语法以及如何应用

public class regtheory {
    public static void main(string[] args) {
        //目标：匹配所有四个数字
        string content = "2002fsd ke ire i2222 ";
 
        //1. \\d 表示一个任意的数字
        string regstr = "(\\d\\d)(\\d\\d)";
 
        //2. 创建模式对象[即正则表达式对象]
        pattern pattern = pattern.compile(regstr);
 
        //3. 创建匹配器
        //说明：创建匹配器 matcher， 按照 正则表达式的规则 去匹配 content 字符串
        matcher matcher = pattern.matcher(content);
 
        //4. 开始匹配
        while (matcher.find()) {
            system.out.println("找到: " + matcher.group(0));
            system.out.println("第 1 组()匹配到的值=" + matcher.group(1));
            system.out.println("第 2 组()匹配到的值=" + matcher.group(2));
        }
    }
}

public string group(int group) {
    if (first < 0){
        throw new illegalstateexception("no match found");
    }
 
    if (group < 0 || group > groupcount()){
        throw new indexoutofboundsexception("no group " + group);
    }
 
    if ((groups[group*2] == -1) || (groups[group*2+1] == -1)){
        return null;
    }
 
    return getsubsequence(groups[group * 2], groups[group * 2 + 1]).tostring();
}

string content = "a11c8abc _abcy @";
 
string regstr = "[a-z]"; //匹配 a-z 之间任意一个字符
 
string regstr = "[a-z]"; //匹配 a-z 之间任意一个字符
 
string regstr = "abc"; //匹配 abc 字符串[默认区分大小写]
 
string regstr = "(?i)abc"; //匹配 abc 字符串[不区分大小写]
 
string regstr = "[0-9]"; //匹配 0-9 之间任意一个字符
 
string regstr = "[^a-z]"; //匹配 不在 a-z 之间任意一个字符
 
string regstr = "[^0-9]"; //匹配 不在 0-9 之间任意一个字符
 
string regstr = "[abcd]"; //匹配 在 abcd 中任意一个字符
 
string regstr = "\\d"; //匹配 不在 0-9 的任意一个字符
 
string regstr = "\\w"; //匹配 大小写英文字母, 数字，下划线
 
string regstr = "\\w"; //匹配 等价于 [^a-za-z0-9_]
 
// \\s 匹配任何空白字符(空格,制表符等)
string regstr = "\\s";
 
// \\s 匹配任何非空白字符 ,和\\s 刚好相反
string regstr = "\\s";
 
//. 匹配出 \n 之外的所有字符,如果要匹配.本身则需要使用 \\.
string regstr = ".";

//当创建 pattern 对象时，指定 pattern.case_insensitive, 表示匹配是不区分字母大小写. 
pattern pattern = pattern.compile(regstr, pattern.case_insensitive);

string content = "study hard"; 
string regstr = "t|a|r";

string content = "a211111aaaaaahello";
 
string regstr = "a{3}"; // 表示匹配 aaa
string regstr = "1{4}"; // 表示匹配 1111
string regstr = "\\d{2}"; // 表示匹配 两位的任意数字字符
 
//细节：java 匹配默认贪婪匹配，即尽可能匹配多的
string regstr = "a{3,4}"; //表示匹配 aaa 或者 aaaa
string regstr = "1{4,5}"; //表示匹配 1111 或者 11111
string regstr = "\\d{2,5}"; //匹配 2 位数或者 3,4,5
 
//1+
string regstr = "1+"; //匹配一个 1 或者多个 1
string regstr = "\\d+"; //匹配一个数字或者多个数字
 
//1*
string regstr = "1*"; //匹配 0 个 1 或者多个 1
 
//遵守贪婪匹配
string regstr = "a1?"; //匹配 a 或者 a1

string content = "123-abc sldkjfs s dfsjf";
 
string content = "123-abc";
 
//以至少 1 个数字开头，后接任意个小写字母的字符串
string regstr = "^[0-9]+[a-z]*";
 
//以至少 1 个数字开头, 必须以至少一个小写字母结束
string regstr = "^[0-9]+\\-[a-z]+$";
 
//表示匹配边界的 han[这里的边界是指：被匹配的字符串最后,也可以是空格的子字符串的后面]
string regstr = "han\\b";
 
//和\\b 的含义刚刚相反
string regstr = "han\\b";

string content = "hello world s7789 nn1189han";
 
//命名分组： 即可以给分组取名
string regstr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";//匹配 4 个数字的字符串
 
pattern pattern = pattern.compile(regstr);
matcher matcher = pattern.matcher(content);
 
while (matcher.find()) {
    system.out.println("找到=" + matcher.group(0));
    system.out.println("第 1 个分组内容=" + matcher.group(1));
    system.out.println("第 1 个分组内容[通过组名]=" + matcher.group("g1"));
    system.out.println("第 2 个分组内容=" + matcher.group(2));
    system.out.println("第 2 个分组内容[通过组名]=" + matcher.group("g2"));
}

public class patternmethod {
    public static void main(string[] args) {
        string content = "hello abc hello, 努力学习";
 
        //string regstr = "hello";
 
        string regstr = "hello.*";
 
        boolean matches = pattern.matches(regstr, content);
 
        system.out.println("整体匹配= " + matches);
    }
}

public class matchermethod {
    public static void main(string[] args) {
        string content = "hello edu jack edutom hello smith hello edu edu";
 
        string regstr = "hello";
 
        pattern pattern = pattern.compile(regstr);
 
        matcher matcher = pattern.matcher(content);
 
        while (matcher.find()) {
            system.out.println(matcher.start());
            system.out.println(matcher.end());
            system.out.println("找到: " + content.substring(matcher.start(), matcher.end()));
        }
 
        //整体匹配方法，常用于，去校验某个字符串是否满足某个规则
        system.out.println("整体匹配=" + matcher.matches());
 
        //完成如果 content 有 edu 替换成 努力学习
        regstr = "edu";
        pattern = pattern.compile(regstr);
        matcher = pattern.matcher(content);
 
        //注意：返回的字符串才是替换后的字符串 原来的 content 不变化
        string newcontent = matcher.replaceall("努力学习");
 
        system.out.println("newcontent=" + newcontent);
        system.out.println("content=" + content);
    }
}

public class regexp13 {
    public static void main(string[] args) {
        string content = "我....我要....学学学学....编程 java!";
 
        //1. 去掉所有的.
        pattern pattern = pattern.compile("\\.");
        matcher matcher = pattern.matcher(content);
        content = matcher.replaceall("");
 
        //2. 去掉重复的字 我我要学学学学编程 java！
        //(1) 使用 (.)\\1+
        //(2) 使用 反向引用$1 来替换匹配到的内容
        // 注意：因为正则表达式变化，所以需要重置 matcher
 
        pattern = pattern.compile("(.)\\1+");//分组的捕获内容记录到$1
 
        matcher = pattern.matcher(content);
 
        //使用 反向引用$1 来替换匹配到的内容
        content = matcher.replaceall("$1");
 
        system.out.println("content=" + content);
    }
}

string content = "2000 年 5 月，jdk1.3、jdk1.4 和 j2se1.3 相继发布。";
 
//使用正则表达式方式，将 jdk1.3 和 jdk1.4 替换成 jdk
content = content.replaceall("jdk1\\.3|jdk1\\.4", "jdk");
 
system.out.println(content);

//要求 验证一个 手机号， 要求必须是以 138 139 开头的
content = "13888889999";
 
if (content.matches("1(38|39)\\d{8}")) {
    system.out.println("验证成功");
} else {
    system.out.println("验证失败");
}

//要求按照 # 或者 - 或者 ~ 或者 数字 来分割
content = "hello#abc-jack12smith~北京";
 
string[] split = content.split("#|-|~|\\d+");
 
for (string s : split) {
    system.out.println(s);
}