本篇文章来学习下正则表达式，文章主要通过代码和代码中的注解进行展开，本文的结构如下：

1、认识正则表达式
2、匹配规则
3、复杂匹配规则
4、分组分配
5、非贪婪匹配
6、分割、查找、替换、反向引用

1、认识正则表达式

正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串，通常被用来检索、替换那些符合某个模式（规则）的文本。下面通过一个简单的例子来认识下正则表达式。

public class MatchesDemo1 {
    /**
     * 正则表达式简介
     * @param args
     */
    public static void main(String[] args) {
        /**
         * 判断用户输入的年份为20##年，规则如下：
         * 一共4个字符，分别是2，0，0-9任意数字，0-9任意数字
         * 对应的正则表达式就是：20\d\d,其中\d表示任意一个数字
         * 把正则表达式转化为java字符串就变成了“20\\d\\d”,java字符串用“\\”表示“\”
         */
        String regex = "20\\d\\d";
        System.out.println("2017".matches(regex)); //true
        System.out.println("2100".matches(regex)); //false
    }
}

2、匹配规则

public class 匹配规则 {
    /**
     * 正则表达式的匹配规则是从左到右匹配，
     * 如果正则表达式中有特殊字符，要用“\”来转义，如“\&”用来匹配特殊字符“&”
     *      要注意的是，正则表达式在Java中也是一个字符串，因此，对于正则表达式“a\&c”对应的Java字符串应该是“a\\&c”,
     * 因为“\”也是Java字符的转义字符，两个“\\”实际上表示的是“\”
     *      如果想要匹配非ASCII字符，例如中文，用Unicode编码如：你好 \u4f60\u597d
     * @param args
     */
    public static void main(String[] args) {
        test7();
    }
    static void test1(){
        String re1 = "abc";
        System.out.println("abc".matches(re1));//true
        System.out.println("Abc".matches(re1));//false
        System.out.println("ABC".matches(re1));//false

        String re2 = "a\\&c";
        System.out.println("a&c".matches(re2));//true
        System.out.println("a-c".matches(re2));//false
        System.out.println("a&&c".matches(re2));//false
        System.out.println("你好".matches("\u4f60\u597d"));//true
    }

    /**
     * 匹配任意字符
     * 用“.”匹配一个任意字符
     */
    static void test2(){
        System.out.println("a*9".matches("a.9"));//true

    }
    /**
     * 匹配数字
     * \d可以匹配0-9的任意数字
     */
    static void test3(){
        System.out.println("ab9".matches("ab\\d"));//true
    }

    /**
     * 匹配常用字符
     * \w可以匹配一个字母、数字、下划线，w的意思是word
     */
    static void test4(){
        System.out.println("a3".matches("\\w3"));//true
        System.out.println("A3".matches("\\w3"));//true
        System.out.println("03".matches("\\w3"));//true
        System.out.println("_3".matches("\\w3"));//true
    }
    /**
     * 匹配空格字符
     * \s匹配空格包括空格和tab字符（在Java中用\t表示）
     */
    static void test5(){
        System.out.println("a\tb".matches("a\\sb"));//true
        System.out.println("a b".matches("a\\sb"));//true
    }

    /**
     * 匹配非数字
     * \d匹配数字，\D匹配非数字
     * 类似的，\W可以匹配\w不能匹配的字符，\S可以匹配\s不能匹配的字符
     */
    static void test6(){
        System.out.println("a0".matches("a\\D")); //false
        System.out.println("ab".matches("a\\D"));//true
        System.out.println("aB".matches("a\\D"));//true
        System.out.println("a_".matches("a\\D"));//true
        System.out.println("a*".matches("a\\D"));//true
    }

    /**
     * 重复匹配
     * 修饰符”*“可以匹配任意个字符，包括0个、1个、多个,相当于{0，}
     * 修饰符”+“可以匹配至少一个字符 包括1个、多个
     * 修饰符”？“可以修饰0个或者1个字符
     * {n}精确指定几个字符
     * {n,m}指定匹配n~m个字符
     * {n,}为至少匹配n个字符
     */
    static void test7(){
        System.out.println("A234".matches("A\\d{2,}"));//true
    }
}

3、复杂匹配规则

public class 复杂匹配规则 {
    public static void main(String[] args) {
        test4();
    }

    /**
     * 匹配开头和结尾
     * 正则表达式多行匹配时，我们用"^"表示开头，”$“表示结尾
     */
    static void test1(){
        String str  = "A\\d{3}$";
        System.out.println("A009".matches(str));//true
        System.out.println("A123".matches(str));//true
    }

    /**
     * 匹配指定范围
     *
     * 使用[……]可以匹配范围内的字符，如[123456789]可以匹配1~9,但是把所有的字符全列出来有点麻烦，
     * [……] 还有一种写法，[1-9]
     * 要匹配大小写不限的十六进制数，如1A2b3c，我们可以这样写[0-9a-fA-F]
     * 匹配6位的16进制数可以写[0-9a-fA-F]{6}
     *
     * [...]还有一种排除法，即不包含指定范围的字符，假设我们要匹配任意字符，但不包含数字，可以写[^0-9]{3}
     */
    static void test2(){

    }

    /**
     * 或规则匹配
     *
     * 用"|"连接的两个正则规则是或规则，如ab|cd可以匹配ab或cd
     */
    static void test3() {
        String re = "html|css|js";
        System.out.println("html".matches(re)); //true
        System.out.println("css".matches(re));//true
        System.out.println("js".matches(re));//true

    }

    /**
     * 使用括号
     * 现在要进行匹配learn html、learn css 、learn js ,要是用learn\shtml|learn\scss|learn\sjs就太麻烦了，我们可以把公共部分提出来
     * 然后用（。。。）把子规则括起来表示成learn\s(java|php|go)
     */
    static void test4(){
        String re = "learn\\s(html|css|js)";
        System.out.println("learn html".matches(re));//true
        System.out.println("learn css".matches(re));//true
        System.out.println("learn js".matches(re));//true
    }

}

4、分组分配

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

public class 分组分配 {
    public static void main(String[] args) {
        test1();
    }

    /**
     * 问题：010-4657858这样的电话号码，如何判断后还方便将区号和号码分别提取出来呢？
     *引入java.util.regex包，用Pattern对象匹配，匹配后获得一个Matcher对象，如果匹配成功，就可以直接从Matcher.group(index)返回字串。
     *
     * Matcher.group(index)方法的参数用1表示第一个子串，2表示第二个子串。如果我们传入0会得到什么呢？答案是010-12345678，即整个正则匹配到的字符串。
     *
     * 使用Matcher时，必须首先用mather判断，为true时，才可以调用group获取字串
     * String。matches()方法内部调用的就是Pattern和Matcher类的方法
     */
    static void test1(){
        Pattern p = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
        Matcher m = p.matcher("010-1234567");
        if (m.matches()) {
            String group1 = m.group(1);
            String group2 = m.group(2);
            String group0 = m.group(0);
            System.out.println(group1); //010
            System.out.println(group2);  //1234567
            System.out.println(group0);  //010-1234567
        }else {
            System.out.println("匹配失败！");
        }

    }
}

5、非贪婪匹配

  匹配次数中的贪婪模式（匹配字符越多越好，默认）
  匹配次数中的非贪婪模式（匹配字符越少越好，修饰匹配次数的特殊符号后再加上一个“？”号）

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

/**
 * 本接任务：区分?的含义，\d??
 */
public class 非贪婪匹配 {
    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }

    /**
     * 下面的这个例子：
     * 我们是期望获得123 和00000这两个的，结果group1结构就是12300000而group2是空字符串，
     * 得到这个结果也可以理解吧，因为\d+把后面的0也包括进来了
     * 为了让\d+尽可能的少匹配，0*尽可能多的多匹配，我们使用非贪婪匹配，在\d后加上？
     */
    static void test1(){
        Pattern pattern = Pattern.compile("(\\d+)(0*)");
        Matcher matcher = pattern.matcher("12300000");
        if (matcher.matches()) {
            System.out.println("group1="+matcher.group(1)); //group1=12300000
            System.out.println("group2="+matcher.group(2)); //group2=
        }
    }
    static void test2(){
        Pattern pattern = Pattern.compile("(\\d+?)(0*)");
        Matcher matcher = pattern.matcher("12300000");
        if (matcher.matches()) {
            System.out.println("group1="+matcher.group(1)); //group1=123
            System.out.println("group2="+matcher.group(2)); //group2=00000
        }
    }
    static void test3(){
        Pattern pattern = Pattern.compile("(\\d??)(9*)");
        Matcher matcher = pattern.matcher("1999999999");
        if (matcher.matches()) {
            System.out.println("group1="+matcher.group(1)); //group1=1
            System.out.println("group2="+matcher.group(2)); //group2=999999999
        }
    }
}

6、分割、查找、替换、反向引用

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

public class SearchAndReplace {
    public static void main(String[] args) {
        test1();
        test2();
        test3();
        test4();
    }
    /**
     * 分割字符串
     * 使用正则表达式分割字符串可以实现更加灵活的功能，String.split()方法传入的是正则表达式，
     * 如果我们想让用户传入一组标签，然后将标签提取出来，因为用户的输入往往是不规范的，如果我们使用合适的
     * 正则表达式就可以消除多个空格、混合“，”“；”等不规范的输入，直接提取出规范的字符串
     */
    static void test1(){
        String[] split = "a b c".split("\\s"); //[a, b, c]
        System.out.println(Arrays.asList(split));
        String[] split1 = "a b    c".split("\\s"); //[a, b, , , , c]
        System.out.println(Arrays.asList(split1));
        String[] split2 = "a,b  ;; , c".split("[\\,\\;\\s]+");//[a, b, c]
        System.out.println(Arrays.asList(split2));
    }

    /**
     * 搜索字符串
     */
    static void test2(){
        String s = "the quick brown fox jumps over the lazy dog.";
        Pattern p = Pattern.compile("\\wo\\w");
        Matcher m = p.matcher(s);
        while (m.find()) {
            String substring = s.substring(m.start(), m.end());
            System.out.println(substring);
        }
        //row
        //fox
        //dog
    }
    /**
     * 替换字符串
     *
     * 正则表达式替换字符串可以直接调用String。replaceAll(),它的第一个参数是正则表达式，第二个参数式待替换的字符串
     */
    static  void test3(){
        String s = "The     quick\t\t brown   fox  jumps   over the  lazy dog.";
        String r = s.replaceAll("\\s+", " ");
        System.out.println(r); // "The quick brown fox jumps over the lazy dog."
    }

    /**
     * 反向引用
     * 如果我们要把搜索到的指定字符串按规则替换，比如前后各加一个<b>xxxx</b>，这个时候，使用replaceAll()的时候，我们传入的第二个参数可以使用$1、$2来反向引用匹配到的子串
     */
    static void test4(){
        String s = "the quick brown fox jumps over the lazy dog.";
        String r = s.replaceAll("\\s([a-z]{4})\\s", " <b>$1</b> ");
        System.out.println(r); //the quick brown fox jumps <b>over</b> the <b>lazy</b> dog.
    }
}

欢迎转载，转载请注明原文出处@hellotqq 个人公众号：hellotqq， gitee:hellotqq(常用) github:hellotqq(不常用) CSDN:hellotqq 稀土掘金：hellotqq 博客园：hellotqq 欢迎关注交流与您共同成长！