Java正则表达式

public static void main(String[] args) {
    String content = "abc$((abfs)($(123";
    // 正则表达式：匹配左括号，需要用到转义符
    String regex = "\\(";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

public static void main(String[] args) {
    String content = "a11c8abcABC _";
    // 匹配任意一个小写字母
    String regex1 = "[a-z]";
    // 匹配任意一个大写字母
    String regex2 = "[A-Z]";
    // 匹配小写abc，必须是abc连起来才能匹配上
    String regex3 = "abc";
    // 匹配不区分大小写abc
    Pattern pattern1 = Pattern.compile(regex3, Pattern.CASE_INSENSITIVE);
    // 匹配不区分大小写abc
    String regex4 = "(?i)abc";
    // 匹配数字
    String regex5 = "[0-9]";
    String regex6 = "\\d";
    // 匹配除小写字母其他所有字符
    String regex7 = "[^a-z]";
    // 匹配abcd中任意一个字符
    String regex8 = "[abcd]";
    // 匹配数字、字母、下划线中任意一个字符
    String regex9 = "\\w";
    // 匹配空格、制表符
    String regex10 = "\\s";
    // 匹配除\n以外的所有字符，匹配.本身的话使用\\.
    String regex = ".";
 
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

public static void main(String[] args) {
    String content = "a11c8abcABC _";
    // 匹配abc或者ABC再或者aaa
    String regex = "abc|ABC|aaa";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

public static void main(String[] args) {
    String content = "1111111aaaaaahello";
    // 匹配aaa
    String regex1 = "a{3}";
    // 匹配1111，只会匹配(0,3)，后面3个1不会被匹配到
    String regex2 = "1{4}";
    // 匹配两位连续的数字，这里会匹配到3个11
    String regex3 = "\\d{2}";
    // 匹配aaa或者aaaa，Java中默认会先匹配多的，因为只有6个a，所以是aaaa
    String regex4 = "a{3,4}";
    // 匹配连续2-5个数字的组合
    String regex5 = "\\d{2,5}";
    // 匹配一个1或者多个1，贪婪匹配，所以直接7个1
    String regex6 = "1+";
    // 匹配0个1或者多个1，贪婪匹配，所以直接7个1和一些没有1
    String regex7 = "1*";
    // 匹配1后面有个a，也可以没有
    String regex = "1a?";
    
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

public static void main(String[] args) {
    String content = "123abc";
    // 匹配至少一个数字开头，后面接任意小写字母，匹配的是整串
    String regex1 = "^[0-9]+[a-z]*";
    // 匹配至少一个数字开头，必须一个小写字母结尾，匹配的是整串
    String regex = "^[0-9]+[a-z]+$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

public static void main(String[] args) {
    String content = "huwenlong wlhu huhahahu";
    // 匹配在边界的hu，空格前的+字符串末尾的
    String regex1 = "hu\\b";
    // 匹配不在边界的hu，空格后的+字符串开头的
    String regex = "hu\\B";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

public static void main(String[] args) {
    String content = "huwenlong wl7787 huhaha1541hu";
    // 匹配四个数字
    String regex1 = "\\d\\d\\d\\d";
    // 非命名分组：
    // 匹配四个数字，其中每两个数字为一组
    // matcher.group(0)：匹配到的所有字符串
    // matcher.group(1)：匹配到的第一组的内容，也就是前两个数字
    // matcher.group(2)：匹配到的第二组的内容，也就是后两个数字
    String regex2 = "(\\d\\d)(\\d\\d)";
    String regex = "(?<g1>\\d\\d)(?<g2>\\d\\d)";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
        System.out.println("第一组：" + matcher.group(1));
        System.out.println("第二组：" + matcher.group(2));
        System.out.println("命名分组-第一组：" + matcher.group("g1"));
        System.out.println("命名分组-第二组：" + matcher.group("g2"));
        
    }
}

public static void main(String[] args) {
    String content = "hellohuwen arborhuwl huwonghello";
    // 正常匹配
    String regex1 = "huwen|huwl|huwong";
    // 非捕获分组，上面的等价于：
    String regex2 = "huw(?:en|l|ong)";
    // 非捕获分组，huw后面包含了以下两种情况才会被匹配，
    // 但是不包含下面两种字符，所以得到的结果是两个huw
    String regex3 = "huw(?=en|l)";
    // 非捕获分组，huw后面不包含以下两种情况才会被匹配，
    // 但是不包含下面两种字符，所以得到的结果是一个huw
    String regex = "huw(?!en|l)";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

public static void main(String[] args) {
    String content = "1111111aaaaaahello";
    // 匹配数字，贪婪匹配会匹配到1111111
    String regex1 = "\\d+";
    // 匹配数字，非贪婪匹配会匹配到七个1
    String regex = "\\d+?";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        System.out.println("截取到的字符串：" + matcher.group(0));
    }
}

匹配两个连续相同的数字：(\\d)\\1    // 先匹配一个数字，再反向引用一次，1表示分组1号也就是第一个括号
匹配五个连续相同的数字：(\\d)\\1{4}    // 先匹配一个数字，再反向引用四次
匹配四个数字，中间两个数相同，两边两个数相同，例如：1221,3553,2332
(\\d)(\\d)\\2\\1    // \\2表示第二组反向引用一次，\\1表示第一组反向引用一次

public static void main(String[] args) {
    String content = "https://space.bilibili.com/124536558?spm_id_from=333.1007.0.0";
    // 匹配多个汉字，整体匹配
    String regex1 = "^[\u0391-\uffe5]+$";
    // 匹配邮政编码，1-9开头的六位数字
    String regex2 = "^[1-9]\\d{5}$";
    // 匹配QQ，1-9开头的5-10位数字
    String regex3 = "^[1-9]\\d{4,9}$";
    // 匹配手机号码，必须是13 14 15 18开头的11位数字
    String regex4 = "^1[3|4|5|8]\\d{9}$";
    // 匹配url []中的 ? * . 表示的是本身，不是转义符，所以不用使用\\转义
    String regex = "^((http|https)://)([\\w-]+\\.)+[\\w-]+(/[\\w-?=&/%.#]*)?$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(content);
    if (matcher.find()) {
        System.out.println("满足格式");
    } else {
        System.out.println("不满足格式");
    }
}