java正则表达式工具类

主要功能有：

boolean find() 是否能匹配到至少一个

boolean match() 匹配整个字符串//这个方法其实可以用^$做到

int size() 匹配的字符串个数

String[] getAll() 获取所有匹配到的字符串

String get(int index) 获取匹配到的第N个字符串

String replaceAll(String replacement) 替换所有匹配到的字符串

String replaceFirst(String replacement) 替换第一个匹配到的字符串

String replaceTail(String replacement) 替换最后一个匹配到的字符串

String replace(int index,String replacement) 替换第N个匹配到的字符串

（常用的功能应该就这些了吧）

demo输出结果：

find–>true

size–>4

——下面是get相关——

请不要开玩笑

all–>null

all–>abc

all–>adc

all–>aac

all–>acc

并没有匹配到辣么多

all–>null

——下面是replace相关——

替换所有：诶嘿嘿 诶嘿嘿 诶嘿嘿 诶嘿嘿 abbc

替换第一个：诶嘿嘿 adc aac acc abbc

替换最后一个：abc adc aac 诶嘿嘿 abbc

替换第2个：abc 诶嘿嘿 aac acc abbc

替换第3个：abc adc 诶嘿嘿 acc abbc

替换第10个（并没有10个）：abc adc aac acc abbc

——下面是匹配整个字符串——

验证手机号18202020202：true

验证手机号1320202020：false

验证手机号20202020202：false

验证邮箱3164@qq.com：true

验证邮箱www.3164@163.com：true

验证邮箱www.baidu.com：false

测试类：

public class Test {
     
    public static void main(String[] arg){
        String res = "abc adc aac acc abbc";
        String pattern = "a\\wc";
        //String pattern = "awc";
        //简单用法的示范
        int size = ZZUtil.init(res, pattern).size();
        boolean find = ZZUtil.init(res, pattern).find();
        System.out.println("find-->"+find);
        System.out.println("size-->"+size);
        //获取匹配到的字符串
        System.out.println("------下面是get相关------");
        ZZUtil zz = ZZUtil.init(res, pattern);
        System.out.println("all-->"+zz.get(-1));
        System.out.println("all-->"+zz.get(0));
        System.out.println("all-->"+zz.get(1));
        System.out.println("all-->"+zz.get(2));
        System.out.println("all-->"+zz.get(3));
        System.out.println("all-->"+zz.get(4));
        //替换字符串
        System.out.println("------下面是replace相关------");
        String replacement = "诶嘿嘿";
        System.out.println("替换所有："+zz.replaceAll(replacement));
        System.out.println("替换第一个："+zz.replaceFirst(replacement));
        System.out.println("替换最后一个："+zz.replaceTail(replacement));
        System.out.println("替换第2个："+zz.replace(1, replacement));
        System.out.println("替换第3个："+zz.replace(2, replacement));
        System.out.println("替换第10个（并没有10个）："+zz.replace(9, replacement));
        //实用功能
        System.out.println("------下面是匹配整个字符串------");
        String p = "1\\d{10}";//验证手机号
        String e = ".+@\\w+.com";//验证邮箱
        System.out.println("验证手机号18202020202："+ZZUtil.init("18202020202", p).match());
        System.out.println("验证手机号1320202020："+ZZUtil.init("1820202020", p).match());
        System.out.println("验证手机号20202020202："+ZZUtil.init("20202020202", p).match());
        System.out.println("验证邮箱3164@qq.com："+ZZUtil.init("3164@qq.com", e).match());
        System.out.println("验证邮箱www.3164@163.com："+ZZUtil.init("www.3164@163.com", e).match());
        System.out.println("验证邮箱www.baidu.com："+ZZUtil.init("www.baidu.com", e).match());
    }
 
}

正则表达式工具类

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
/**
 * 正则表达式工具类
 * @author lu
 *
 */
public class ZZUtil {
     
    private static ZZUtil zz;
    public static ZZUtil init(CharSequence res,String pattern){
        if (zz==null||(!res.equals(zz.res)||!pattern.equals(zz.pattern))) {
            //在没有实例或内容不同的时候新建一个实例
            zz = new ZZUtil(res, pattern);
        }
        return zz;
    }
     
    private CharSequence res;
    private String pattern;
    private Pattern p;
    private Matcher m;
    private int size = 0;
    private String[] list;//所有匹配到的字符串
     
    private ZZUtil(CharSequence res,String pattern){
        this.res = res;
        this.pattern = pattern;
        p = Pattern.compile(pattern);
        m = p.matcher(res);
        while(m.find()){
            size++;
        }
        list = new String[size];
        m.reset();
        for (int i = 0; i < size; i++) {
            if(m.find())list[i] = m.group();
        }
    }
     
    /**是否能匹配到至少一个*/
    public boolean find(){
        return size>0;
    }
     
    /**匹配整个字符串，必须整个字符串满足正则表达式才算true*/
    public boolean match(){
        return find()&&get(0).equals(res);
    }
     
    /**获取所有匹配的字符串个数*/
    public int size(){
        return size;
    }
     
    /**获取所有匹配到的字符串*/
    public String[] getAll(){
        return list;
    }
     
    /**获取匹配到的第N个字符串*/
    public String get(int index){
        if (index<0) {
            System.out.println("请不要开玩笑");
            return null;
        }
        if (index>=size) {
            System.out.println("并没有匹配到辣么多");
            return null;
        }
        return list[index];
    }
     
    /**替换所有匹配到的字符串*/
    public String replaceAll(String replacement){
        return m.replaceAll(replacement);
    }
     
    /**替换第一个匹配到的字符串*/
    public String replaceFirst(String replacement){
        return m.replaceFirst(replacement);
    }
 
    /**替换最后一个匹配到的字符串*/
    public String replaceTail(String replacement){
        return replace(size-1, replacement);
    }
     
    /**替换第N个匹配到的字符串*/
    public String replace(int index,String replacement){
        m.reset();
        boolean isFind = false;
        while(index>=0){
            isFind = m.find();
            index--;
        }
        if(isFind){
            StringBuffer sb = new StringBuffer();
            m.appendReplacement(sb, replacement);
            m.appendTail(sb);
            return sb.toString();
        }
        return (String) res;
    }
 
}