Java学习之正则表达式快速入门

Java学习-14-韩顺平老师 Java-正则表达式入门目录：

1. 正则表达式简介
2. 正则表达式语法
    2.1 字符匹配符
    2.2 选择匹配符
    2.3 限定符
    2.4 定位符
    2.4 分组
3. 正则表达式三个常用类
4. 反向引用
5. String类使用正则表达式

正则表达式简介

基本介绍：

1.一个正则表达式，就是用某种模式去匹配字符串的一个公式。
2.其实很多语言都支持正则表达式操作，例如 Javascript、python、php等

基本使用：

public class RegExp_ {
    public static void main(String[] args) {
        groupReg();
        normalReg();
    }
    // 正常匹配
    public static void normalReg(){
        // 用来匹配的内容
        String content = "我爱写代码1998，但是我不想掉头发2001";
        // 正则表达式
        String regStr ="\d{4}";
        // 创建一个匹配模式，传入正则表达式
        Pattern pattern = Pattern.compile(regStr);
        // 创建一个匹配器,按照pattern来匹配
        Matcher matcher = pattern.matcher(content);
        // 循环匹配，检索，如果没有检索到就返回false
        while (matcher.find()){
            // 返回按照匹配规则，因为没有分组,matcher.group(0)返回匹配到的字符
            System.out.println("找到 =" + matcher.group(0));
        }
    }
    // 采用分组匹配
    public static void groupReg(){
        // 用来匹配的内容
        String content = "我爱写代码1998，但是我不想掉头发2001";
        // 正则表达式,采用分组，
        // 匹配到的整段字符
        // 起始位置索引存放在groups[]数组中的groups[0]中  5
        // groups[1] 放的是整段字符索引的终止位置 + 1  9
        // groups[2] 放的是 第1个分组匹配字符的起始位置 5
        // groups[3] 放的是 第1个分组匹配字符的终止位置 7
        // groups[4] 放的是 第2个分组匹配字符的起始位置 7
        // groups[5] 放的是 第2个分组匹配字符的终止位置 9
        String regStr ="(\d{2})(\d{2})";
        // 创建一个匹配模式，传入正则表达式
        Pattern pattern = Pattern.compile(regStr);
        // 创建一个匹配器,按照pattern来匹配
        Matcher matcher = pattern.matcher(content);
        // 循环匹配，检索，如果没有检索到就返回false
        while (matcher.find()){
            // 返回按照匹配规则，因为没有分组,matcher.group(0)返回匹配到的字符
            System.out.println("找到 " + matcher.group(0)); //找到  2001
            // 采用分组，就可以取出分组的内容
            System.out.println("找到分组1 " + matcher.group(1)); // 找到分组1 20
            System.out.println("找到分组2 " + matcher.group(2)); // 找到分组1 01
        }
    }
}

正则表达式语法
基本介绍：

元字符从功能上大致分为一下几类：
1.字符匹配符
2.选择匹配符
3.限定符
4.定位符
5.特殊字符
6.分组组合和反向引用符
7.转义号：符号，在我们使用正则表达式去检索某些特殊字符的时候，需要用到转义字符，否则检索不出结果，甚至会报错。

字符匹配符

[xyz]     字符集。匹配包含的任一字符。例如，"[abc]“匹配"plain"中的"a”。
[^xyz]     反向字符集。匹配未包含的任何字符。例如，"[^abc]“匹配"plain"中"p”，“l”，“i”，“n”。
[a-z]     字符范围。匹配指定范围内的任何字符。例如，"[a-z]“匹配"a"到"z"范围内的任何小写字母。
[^a-z]     反向范围字符。匹配不在指定的范围内的任何字符。例如，”[^a-z]“匹配任何不在"a"到"z"范围内的任何字符。
b     匹配一个字边界，即字与空格间的位置。例如，“erb"匹配"never"中的"er”，但不匹配"verb"中的"er”。
B     非字边界匹配。“erB"匹配"verb"中的"er”，但不匹配"never"中的"er"。
d     数字字符匹配。等效于 [0-9]。
D     非数字字符匹配。等效于 [^0-9]
f     换页符匹配。
n     换行符匹配。
r     匹配一个回车符。
s     匹配任何空白字符，包括空格、>制表>符、换页符等。
S     匹配任何非空白字符。
t     制表符匹配。
v     垂直制表符匹配。
w     匹配任何字类字符，包括下划线。
W     与任何非单词字符匹配。
(?i)abc     表示abc都不区分大小写匹配
a(?i)ab     表示bc不区分大小写
a((?i)b)c     表示b不区分大小写
Pattern pat = Pattern.complie(regExp,Pattern.CASE.INSENSITIVE) 表示不区分大小写匹配

简单演示：

public class RegExp01 {
    public static void main(String[] args) {
        String content = "abc132 ABC_@";
        String regStr ="";
        // 返回多少字符 除n
        // String regStr = ".";
        // 返回abc其中一个 [abc]
        regStr = "[abc]*"; // adc
        // 返回非abc [^abc] ^取反的意思
        regStr = "[^abc]";
        // 返回数字 \d
        // regStr = "\d*"; // 132
        // 匹配空白字符 \s
        regStr = "\s";
        // 匹配非空白字符 \S
        regStr = "\S";
        // 匹配 任何字类字符类 \w
        regStr = "\w";
        // 匹配任何非字符 \W 例如 @ 空格
        regStr = "\W";
        // 匹配adc 不区分大小写
        regStr = "(?i)abc"; // 找到：abc 找到：ABC
        // 在这里添加 Pattern.CASE_INSENSITIVE 也表示不区分大小写匹配
        Pattern pattern = Pattern.compile(regStr,Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到：" + matcher.group(0));
        }
    }
}

选择匹配符

基本介绍:

在匹配某些字符串时候是选择性的，即：既可以匹配这个，也可以匹配那个，这时需要使用到匹配选择符
选择匹配符： |

简单演示:

public class RegExp02 {
    public static void main(String[] args) {
        String content = "https:123http:";
        // 表示既可以匹配 https 又可以匹配http
        String regStr = "https|http";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            // 输出
            // 找到：https
            // 找到：http
            System.out.println("找到：" + matcher.group(0));
        }
    }
}

限定符

基本介绍：

用于限定其前面的字符和组合项连续出现多次。
常用符号如下：
.     匹配除"rn"之外的任何单个字符。
*     零次或多次匹配前面的字符或子表达式。
+      一次或多次匹配前面的字符或子表达式。
?     零次或一次匹配前面的字符或子表达式。
{n}     n 是非负整数。正好匹配 n 次。
{n,}      n 是非负整数。至少匹配 n 次。
{n,m}     m 和 n 是非负整数，其中 n <= m,匹配至少 n 次，至多 m 次。

简单演示：

public class RegExp03 {
    public static void main(String[] args) {
        String content = "121233aabbccdd_eeefffgg";
        String regStr = null;
        // 匹配一个除rn外的所有字符
        regStr = "\d."; // 找到 12  找到 12  找到 33
        // 匹配 零次多次
        regStr = "(aa)*"; // 找到 aa
        // 匹配 一次或多次
        regStr = "(a)+"; // 找到 aa
        // 匹配 3 数字 \d{3}
        regStr = "\d{3}"; // 找到 121  找到 233
        // 匹配 4-6个字母 ,因为模式是贪婪模式，有的话，会尽量匹配6个
        regStr = "[a-z]{4,6}"; // 找到 aabbcc  找到 eeefff
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.print("找到 " + matcher.group(0) + "  ");
        }
    }
}

定位符

基本介绍：

定位符，规定要匹配的字符串出现的位置，比如在字符串的开始还是在结束的位置，这个也是相当有用的，必须掌握。
常见定位符：
^     匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"n"或"r"之后的位置匹配。
$     匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"n"或"r"之前的位置匹配。
b     匹配一个字边界，即字与空格间的位置。例如，“erb"匹配"never"中的"er”，但不匹配"verb"中的"er"。
B     非字边界匹配。“erB"匹配"verb"中的"er”，但不匹配"never"中的"er"。

简单演示：

public class RegExp04 {
    public static void main(String[] args) {
        String content = "hello mary 123";
        // 匹配以字母开头，数字结尾的字符串
        String regStr = "^[a-z]+\s\w+\s\d+$";
        // 下面是没有匹配结果的 ，因为 ar不在结尾 或者空格之间
        regStr = "\w+ar\b";
        // 下面
        regStr = "\w+ry\b"; // 找到 mary
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.print("找到 " + matcher.group(0) + "  ");
        }
    }
}

分组

基本介绍：

(pattern) 匹配 pattern 并捕获该匹配的子表达式

(?:pattern) 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。

(?=pattern) 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹>配，即不能捕获供以后使用的匹配。

(?!pattern) 执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非>捕获匹配，即不能捕获供以后使用的匹配。

简单演示：

public class RegExp {
    public static void main(String[] args) {
        String content = "张三是帅哥 张三是法外狂徒 张三是普通市民";
        // 匹配括号中内容作为一个子字符串
        String regStr = "张三是([u0391-uffe5]+)";
        // 上述也可以写成 采用 (?:pattern)
        regStr = "张三是(?:帅哥|法外狂徒|普通市民)";
        // 如果执行得到前面的一部分可以此阿勇 (?=pattern) ,下面只返回三个张三是
        regStr = "张三是(?=帅哥|法外狂徒|普通市民)";
        // 与上面的取反 ，下面不返回任何结果
        regStr = "张三是(?!=帅哥|法外狂徒|普通市民)";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到：" + matcher.group(0));
        }
    }
}

正则表达式三个常用类

基本介绍：

java.util.regex包主要包括下面三个类，Pattern类，Matcher类和PatternSyntaxException类

Pattern类：

pattern 对象是一个正则表达式对象。Pattern类没有公共构造方法。要创建一个Pattern对象，调用其公共静态方法，它返回一个Pattern对象，该方法接受一个正则表达式作为第一个参数例如：Pattern pattern = Pattern.compile(regStr);

Matcher类：

Matcher对象是输入字符串进行解释和匹配的引擎。与Pattern类一样，Matcher也没有公共的构造方法，需要调用Pattern对象的matcher的方法来获得一个Matcher对象。

Matcher类的常用方法：

public int start(int group）返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
public int end（返回最后匹配字符之后的偏移量)
public int end(int group)返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
public boolean lookingAt( 尝试将从区域开头开始的输入序列与该模式匹配)。
public boolean findQ尝试查找与该模式匹配的输入序列的下一个子序列。
public boolean find(int start)重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下
一个子序列。
public boolean matches()尝试将整个区域与模式匹配

简单演示：

public class RegExp02 {
    public static void main(String[] args) {
        String content = "http:/www.ease.center";
        // 表示既可以匹配 https 又可以匹配http
        String regStr = "^(https|http):/\w*\.\w*\.[a-z]*$";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        // 可以直接判断是否完全匹配， 使用matches()
        boolean matches = matcher.matches();
        if (matches){
            System.out.println("验证成功!");
        }else {
            System.out.println("验证失败！");
        }
        while (matcher.find()){
            System.out.println("找到：" + matcher.group(0));
            // 与上面输出一致
            System.out.println("找到：" + matcher.group(0).substring(matcher.start(),matcher.end()));
        }
    }
}

PatternSyntaxException类：

PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

反向引用

基本介绍：

圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用，这种引用既可以是在正则表达式内部，也可以是在正则表达式外部，内部反向引用11分组号，外部反向引用＄分组号。

简单演示：

public class RegExp05 {
    public static void main(String[] args) {

        String content = "1212123123";
        // 使用 反向引用匹配重复字符串
        // 每一个分组，可以使用 \1-9 来使用前面分组
        String regStr = "(\d{2})\1(\d{3})\2";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.print("找到 " + matcher.group(0) + "  ");
        }

        // 结巴案例
        content = "我我...爱爱爱..写写..代代码码!";
        // 将字符串中 ... 去除
        content = content.replaceAll("\.", "");
        regStr = "(.)\1+";
        pattern = Pattern.compile(regStr);
        Matcher matcher1 = pattern.matcher(content);
        // 匹配到了的所有group中的字符串，全部用(.)匹配到的替换，消除了重复
        content = matcher1.replaceAll("$1");
        System.out.println(content);
        //另种写法  直接按照模板匹配，然后直接替换
        content = Pattern.compile(regStr).matcher(content).replaceAll("$1");
        System.out.println(content);
    }
}

String类中使用正则表达式

基本介绍：

1.public String replaceAll(String regex, String replacement)：字符串替换
2.public String split(String regex) ：字符串拆分
3.public String matches(String regex) ：验证字符串

简单演示：

public class StringRexExp {
    public static void main(String[] args) {
        String content = "hello world1,i am fine";
        // 替换 world1 为 mary
        String mary = content.replaceAll("\w+\d$", "mary");
        System.out.println(mary);
        // 根据 空格 或者 , 分割
        String[] split = content.split(" |,");
        for (String s :split) {
            System.out.println(s);
        }
        // 判断格式是否正确
        String phoneNum ="13988889999";
        // 验证是否以138 或者 139开头
        if (phoneNum.matches("^(138|139)\d{8}")){
            System.out.println("验证通过");
        }else {
            System.out.println("验证失败");
        }

    }
}

正则表达式小结，欢迎大家交流学习！

Java学习之正则表达式快速入门

Java相关栏目本月热门文章