java正则表达式的各种用法

package com.amx.正则表达式;

import org.junit.jupiter.api.Test;

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

/**
 * @Author: amxing
 * @Desc:
 * @Date: Created in 18:28 2018/7/28
 */
public class Demo {

    @Test
    public void invoke() {

        //判断是否为数字或者小数
        match("^\\d+$|^\\d+\\.\\d+$", "123.32");

        group("测试([0-9]+)", "dada测试1打打测试2dccada", 1);

        a();

        b();

        c();

    }

    /**
     * 进行格式匹配
     * @param regex
     * @param target
     */
    private void match(String regex, String target) {
        if (target.matches(regex)) {
            System.out.println("成功匹配");
        }
    }

    /**
     * 表达式捕获
     * @param regex
     * @param target
     * @param index
     */
    public void group(String regex, String target, int index) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(target);
        while (matcher.find()) {
            System.out.print(matcher.group(index) + "  ");
        }
    }

    /**
     * 元字符
     * \:转义字符
     * ^:匹配开始
     * $:匹配结束
     * \b:匹配字符边界
     * *:匹配前边的表达式出现0次或多次
     * +:匹配前边的表达式出现一次或多次
     * ?:匹配前边的表达式出现0次或一次
     * {n}:匹配前边的表达式出现n次，例如9{5}可以匹配99999
     * {n,}:匹配前边的表达式至少出现n次，例如9{2,},可以匹配99，9999,99999，...，等价于9*
     * {n,m}:匹配前边的表达式至少出现n次，至多出现m次，例如9{2,3}可以匹配99,999
     * {,m}:匹配前边的表达式至多出现m次
     * (?:abc):非捕获匹配
     * (?=abc):正向肯定预查
     * (?!abc):正向否定预查
     * (?<=abc):反向肯定预查
     * (?<!abc):反向否定预查
     * a|b:匹配a或者b
     * [abc]:字符集合
     * [^abc]:负字符集合，不匹配集合中的任意字符
     * \b:匹配一个单词边界
     * \B:匹配非单词边界
     */
    public void a() {
        //匹配整数或者浮点数
        if ("8.88".matches("^[0-9]+$|^[0-9]+\\.[0-9]+$")) {
            System.out.println("\n为数字");
        }
        if ("abb".matches("a{1,9}b{2}")) {
            System.out.println("匹配成功");
        }
        if ("him".matches("\\bhi\\b.*")) {
            System.out.println("匹配成功");
        } else {
            System.out.println("匹配不成功");
        }
        Pattern pattern = Pattern.compile("ab(?:c|d)");//可以匹配abc或abd，可以简化abc|abd，并且不提供缓存，后续不可以使用
        Matcher matcher = pattern.matcher("abc");
        if (matcher.find()) {
            //System.out.println(matcher.group(1));这里就不能通过group来访问了
            System.out.println("匹配成功");
        }

    }

    /**
     * 预查找，反向预查类似
     */
    public void b() {

        //正向预查,提取src
        String html = "<img src='a/b.png'/>";
        Pattern srcPattern = Pattern.compile("(?=src='([^'\"]+)')");
        Matcher srcMatcher = srcPattern.matcher(html);
        if (srcMatcher.find()) {
            System.out.println("提取的src:" + srcMatcher.group(1));
        } else{
            System.out.println("src匹配不成功");
        }
        //格式化金额字符串
        System.out.println("10000000.1".replaceAll("(\\d{1,3})(?=(\\d{3})+\\.)","$1,"));
        System.out.println("180831".replaceAll("(\\d{2})(?=(\\d{2})+)", "$1-"));

        //正向否定预查，可用来做否定匹配，常用的[^abc]可以用来匹配不包含a或b或c的其他字符，但是当我们匹配不包含abc这个字符串的时候，就要用到否定预查找了。
        Pattern noPattern = Pattern.compile("((?!abc).)*");//意思就是查找所有前边不包含abc字符串的字符
        Matcher noMatcher = noPattern.matcher("abd");
        if (noMatcher.matches()) {
            System.out.println("匹配不包含abc的字符串成功");
        } else {
            System.out.println("匹配不包含abc的字符串失败");
        }
    }

    /**
     * 贪婪匹配，懒惰匹配
     */
    public void c() {
        Pattern greedPattern = Pattern.compile("<(.*)>");//贪婪匹配
        Pattern lazyPattern = Pattern.compile("<(.*?)>");//懒惰匹配
        Matcher greedMatcher = greedPattern.matcher("<amx>>");
        Matcher lazyMatcher = lazyPattern.matcher("<amx>>");
        if (greedMatcher.find()) {
            System.out.println(greedMatcher.group(1));
        }
        if (lazyMatcher.find()) {
            System.out.println(lazyMatcher.group(1));
        }
    }

}