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

[email protected]:true

[email protected]: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("[email protected]:"+ZZUtil.init("[email protected]", e).match()); 
        System.out.println("[email protected]:"+ZZUtil.init("[email protected]", 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; 
    } 
  
}

原创文章,作者:ItWorker,如若转载,请注明出处:https://blog.ytso.com/10337.html

(0)
上一篇 2021年7月19日
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论