java 正则表达式

底层保存的是匹配到的子字符串的 开始位置 和 结束位置+1

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 */
public class RegExp {
    public static void main(String[] args) {
        String content = "1998年12月8日，第二代Java平台的企业版J2EE发布。" +
                "1999年6月，Sun公司发布了第二代Java平台（简称为Java2）的3个版本" +
                "：J2ME（Java2 Micro Edition，Java2平台的微型版），应用于移动、" +
                "无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2平台的标准版），" +
                "应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2平台的企业版），" +
                "应用于基于Java的应用服务器。Java 2平台的发布，" +
                "是Java发展过程中最重要的一个里程碑，标志着Java的应用开始普及。9999";
        //匹配所有四个数字
        //说明:
        // \\d:表示任意0-9 的数字 ,此处4个,表示连续在一起的四个数,
        // 如果有超过连续4个的数字,只会截取前四位
        String regStr = "\\d\\d\\d\\d";
        //创建模式对象 正则表达式对象
        Pattern compile = Pattern.compile(regStr);
        //创建匹配器 matcher
        //按照正则表达式的规则去匹配content字符转
        Matcher matcher = compile.matcher(content);
        //开始匹配
        //matcher.find():会记录匹配到的字符串,开始位置索引 groups[0]=开始位置 与 结束位置索引+1 groups[1]=结束位置+1
        while (matcher.find()) {
            //matcher.group(0) 拿到开始位置与结束位置,去content字符串中截取
            //subString (0,4),(开始索引,结束索引+1)
            System.out.println(matcher.group(0));
        }
    }
}

 分组()

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 */
public class RegExp {
    public static void main(String[] args) {
        String content = "1998年12月8日，第二代Java平台的企业版J2EE发布。" +
                "1999年6月，Sun公司发布了第二代Java平台（简称为Java2）的3个版本" +
                "：J2ME（Java2 Micro Edition，Java2平台的微型版），应用于移动、" +
                "无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2平台的标准版），" +
                "应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2平台的企业版），" +
                "应用于基于Java的应用服务器。Java 2平台的发布，" +
                "是Java发展过程中最重要的一个里程碑，标志着Java的应用开始普及。999999";
        //匹配所有四个数字
        //说明:
        // \\d:表示任意0-9 的数字 ,此处4个,表示连续在一起的四个数,
        // 如果有超过连续4个的数字,只会截取前四位
        String regStr = "(\\d\\d)(\\d\\d)";
        //创建模式对象 正则表达式对象
        Pattern compile = Pattern.compile(regStr);

        Matcher matcher = compile.matcher(content);

        while (matcher.find()) {
            //如果正则表达式有()就表示分组
            //取出匹配规则如下
            //group[0],表示匹配到的子字符串(整体)
            //group[1]表示匹配到的子字符串(第一组)
            //group[2]表示匹配到的子字符串(第二组)
            //........
            System.out.println("整体"+matcher.group(0));
            System.out.println("第一组"+matcher.group(1));
            System.out.println("第二组"+matcher.group(2));
        }
    }
}

元字符-字符匹配

 

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 * 字符匹配符
 */
public class RegExp {
    public static void main(String[] args) {
        String content = "abcM12456ABC";
        //匹配a-z小写的任意 一个 字符  结果找到三个 a b d
        String regStr = "[a-z]";
        //java默认匹配区分大小写 结果 abc
        String abc = "abc";
        //不区分大小写结果abc 和ABC 
        String abcABC = "(?i)abc";
        //创建模式对象 正则表达式对象
        Pattern compile = Pattern.compile(abcABC);
        Matcher matcher = compile.matcher(content);
        while (matcher.find()) {
            System.out.println("找到"+matcher.group(0));
        }
    }
}

 选择匹配符

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 * 选择匹配符
 */
public class RegExp {
    public static void main(String[] args) {
        String content = "于124鱼56yu";
        //结果找打三个 于 鱼 yu
        String regStr = "于|鱼|yu";
        Pattern compile = Pattern.compile(regStr);
        Matcher matcher = compile.matcher(content);
        while (matcher.find()) {
            System.out.println("找到"+matcher.group(0));
        }
    }
}

 元字符-限定字符

如果没有() 限定符作用于前一个字符 

例如:abc?    -----?针对的只有c

 

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 * 限定符使用
 */
public class RegExp {
    public static void main(String[] args) {
        String content = "aaaabcddd111111131";
        //表示匹配3个d 等价于 ddd
        String regStr = "d{3}";
        //匹配4个1 1111
        String regStr1 = "1{4}";
        //陪陪两位任意数字 11,11,11,13
        String regStr2 = "\\d{2}";
        //匹配aa或者aaa
        //java默认是贪婪匹配,优先匹配多的
        //所以结果是aaa
        //如果字符串有5个a匹配的结果就是aaa和aa
        String regStr3 = "a{2,3}";
        String content1 = "abcd1234567";
        //匹配2位数字或者3位,4,5位
        //结果是12345,67
        //开始匹配位数是5位数,结束位数是2-5之间
        String regStr4 = "\\d{2,5}";
        //匹配a1或者a
        String content2 = "a1b1a";
        String regStr5 = "a1?";
        Pattern compile = Pattern.compile(regStr5);
        Matcher matcher = compile.matcher(content2);
        while (matcher.find()) {
            System.out.println("找到"+matcher.group(0));
        }
    }
}

元字符-定位符

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 * 定位符使用
 */
public class RegExp {
    public static void main(String[] args) {
        String content2 = "123-abc";
        //必须以一个数字开头 字母结尾,数字和字母之前用连接符号-
        String regStr5 = "^[0-9]+\\-[a-z]+$";
        Pattern compile = Pattern.compile(regStr5);
        Matcher matcher = compile.matcher(content2);
        while (matcher.find()) {
            System.out.println("找到"+matcher.group(0));
        }
    }
}

分组

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 * 分组
 */
public class RegExp {
    public static void main(String[] args) {
        String content2 = "abc1234符 5678";
        //非命名分组
        //说明
        //matcher.group(0)得到匹配中的子字符串,1234,5678
        //matcher.group(1)等到匹配字符串的第一个内容12和56
        //matcher.group(2)等到匹配字符串的第二个内容34和78
        String regStr5 = "(\\d\\d)(\\d\\d)";
        Pattern compile = Pattern.compile(regStr5);
        Matcher matcher = compile.matcher(content2);
        while (matcher.find()) {
            System.out.println("找到"+matcher.group(0));
            System.out.println("找到"+matcher.group(1));
            System.out.println("找到"+matcher.group(2));
        }
    }
}

 命名分组

 非捕获分组

 

public class Main {
    public static void main(String[] args) {
        String str = "于大王a于老大1于老师,于天使,于天师23456";
        //非捕获分组 注意:不可以用 matcher.group(1)去捕获
        //于大王,于老大,于老师,于天使,于天师
        String regExp = "于(?:大王|老大|老师|天使|天师)";

        //结果 于,于
        // 不显示括号中的大王,老大
        //非捕获
        String regExp1 = "于(?=大王|老大)";
        Pattern compile = Pattern.compile(regExp1);
        Matcher matcher = compile.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }

    }


}

 非贪婪匹配

/**
 * @param
 * @Method
 * @Author charsming
 * @Version 1.0
 * @Description 非贪婪匹配
 * @Return
 * @Date 2021/12/11 16:02
 */

public class Main {
    public static void main(String[] args) {
        String str = "hello111111abcd";
        //结果是111111
        //默认是贪婪匹配
        String regExp = "\\d+";

        //结果是获取到6次 一个1
        //1,1,1,1,1,1
        //加一个? 非贪婪匹配,尽可能匹配少的的字符
        String regExp1 = "\\d+?";
        Pattern compile = Pattern.compile(regExp1);
        Matcher matcher = compile.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }

    }


}

简单案例

/**
 * @param
 * @Method
 * @Author charsming
 * @Version 1.0
 * @Description 案例
 * @Return
 * @Date 2021/12/11 16:02
 */

public class Main {
    public static void main(String[] args) {
        String str = "天道酬勤";
        //^$ 开始结束表示整体匹配
        //匹配全是汉字
        //如果不用+号,只能匹配一个
        String regExp1 = "^[\u0391-\uffe5]+$";
        String str1 = "123456";
        //匹配1到9开头的一个 5到10位数字
        //^[1-9]匹配开头第一个字符,
        //\\d{4,9}匹配结尾后
        //注意不是{5,10}这样就是11位数了
        String regExp2 = "^[1-9]\\d{4,9}+$";

        //必须是13,14,15,18开头的11位数字
        ///匹配第一个,[3|4|5|8]匹配第二位数
        String regExp3 = "^1[3|4|5|8]\\d{9}+$";
        Pattern compile = Pattern.compile(regExp2);
        Matcher matcher = compile.matcher(str1);
        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }

    }


}

反向引用

 

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 * 反向引用
 */
public class RegExp {
    public static void main(String[] args) {
        String content2 = "abc1134符 55555678-1315";
        //找到两个联系相同的数字
        //结果11
        String regStr5 = "(\\d)\\1";
        //找到连续五个相同的数字 55555
        String regStr6 = "(\\d)\\1{4}";
        //找到第一位与第三位相同的四位数字
        //结果5555,和1315
        String regStr7 = "(\\d)(\\d)\\1(\\d)";
        Pattern compile = Pattern.compile(regStr7);
        Matcher matcher = compile.matcher(content2);
        while (matcher.find()) {
            System.out.println("找到" + matcher.group(0));
            ;
        }
    }
}

 案例去重利用反向引用

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author
 * @create 2021-12-06 21:02
 * 反向引用
 */
public class RegExp {
    public static void main(String[] args) {
        String content2 = "我我.....要要.....学学学...编编.程";
        //结果我我要要学学学编编程
        String regStr7 = "\\.";
        Pattern compile = Pattern.compile(regStr7);
        Matcher matcher = compile.matcher(content2);
        //matcher.replaceAll()替换匹配到的字符串,并返回新的字符串
        String newContent = matcher.replaceAll("");
        System.out.println(newContent);
        //去掉重复字
        //1.(.)\\1+
        //2.使用反向引用$1来替换匹配到的内容
        //譬如 匹配到我我, $1 是我我,字符串的开始位置 我,直接替换捕获的字符串 我我,最终把捕获的字符串变成我
        //结果 我要学编程
        String regStr8 = "(.)\\1+";
        compile = Pattern.compile(regStr8);
        Matcher matcher1 = compile.matcher(newContent);
        String newCon = matcher1.replaceAll("$1");
        System.out.println(newCon);
    }
}

字符串直接使用正则表达式

public class RegExp {
    public static void main(String[] args) {
        //按照-,#,~和数字分割字符串
        String content = "hello#abc~yu-haha88要发";
        String[] split = content.split("-|#|~|\\d+");
        System.out.println(Arrays.asList(split).toString());
    }
}