soft

soft

正则正整数数值比较

package io.ants.common.utils;

import org.apache.commons.lang.StringUtils;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * function 正则工具类
 * auth zhanghu 2022 07 24
 */
public class RegExUtils {

    /**
     * 00:02:00-03:03:03==>时间范围正则表示
     * @param time_range_str
     * @return (00|01|02):(00|01):(00|01|03))
     */
    private static String get_time_range_rex(String time_range_str){
        String rt="";
        if (-1!=time_range_str.indexOf("-")){
            String[] r=time_range_str.split("-");
            if(r.length>=2){
                String[] s0=r[0].split(":");
                String[] s1=r[1].split(":");
                if(3==s0.length && 3==s1.length){
                    // 小时相同
                    if(Integer.parseInt(s0[0])==Integer.parseInt(s1[0])){
                        String f0="%s:[%s-%s]\\d:\\d{2}";
                        String m00=s0[1].substring(0,1);
                        String m10=s1[1].substring(0,1);
                        rt=String.format(f0,s0[0],m00,m10);
                    }else {
                        // 小时不同 :分三段 开始小时 中间小时  结束小时
                        String t0="",t1="",t2="";
                        if(true){
                            //开始相同时 正则
                            String f0="%s:[%s-6]\\d:\\d{2}";
                            String m00=s0[1].substring(0,1);
                            t0=String.format(f0,s0[0],m00);
                        }

                        if(Integer.parseInt(s1[0])-Integer.parseInt(s0[0])>1 ){
                            //中间相差的小时
                            String f1="(%s):\\d{2}:\\d{2}";
                            String h0=s0[0];
                            String h1=s1[0];
                            List<String> list=new ArrayList<>();
                            for (int i = Integer.parseInt(h0)+1; i <Integer.parseInt(h1) ; i++) {
                                String th=String.format("%02d",i);
                                if(!list.contains(th)){
                                    list.add(th);
                                }
                            }
                            String h_list=String.join("|",list);
                            t1=String.format(f1,h_list);
                        }

                        if (true){
                            //结束小时
                            String f2="%s:[0-%s]\\d:\\d{2}";
                            String m10=s1[1].substring(0,1);
                            t2=String.format(f2,s1[0],m10);
                        }
                        rt=String.format("(%s)|(%s)|(%s)",t0,t1,t2);
                    }

                }
            }
        }
        return  rt;
    }

    private static  String getAZaz09Reg(List<String> bi){
        int j=0;
        String buf="";
        char start_char=0;
        do{
            if(j+1<bi.size()-1){
                char j0=bi.get(j).charAt(0);
                char j1=bi.get(j+1).charAt(0);
                if(0==start_char){
                    buf+=String.valueOf(j0)+"-";
                }
                //System.out.println(j1-j0);
                if(1==j1-j0){
                    start_char=j0;
                }else {
                    //System.out.println("xx");
                    buf+=j0;
                    start_char=0;
                }
            }else {
                break;
            }
            j++;
        }while (true);
        buf+=bi.get(bi.size()-1);
        //System.out.println(buf);
        if (buf.equals("A-Za-z0-9")){
            return "^&";
        }
        return buf;
    }

    public static String p_char(Integer i){
        String s="_";
        for (int j = 0; j <i ; j++) {
            s+="_";
        }
        return  s;
    }

    private static String GetUnEqualRegx(String content){
        final String[] m={"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9"};
        String[] content_list_array=content.split("\\|");
        Integer maxLen=0;
        List<String> reg=new ArrayList<>();
        for (String content_i:content_list_array){
            if (content_i.length()>maxLen){
                maxLen=content_i.length();
            }
        }
        for (int i = 0; i <maxLen+1 ; i++) {
            if(0==i){
                //第一个不为首,则第2--n 可以任意
                Map<String,Object> firstMap=new HashMap();
                List<String> base_char_ls=new ArrayList<>()  ;
                base_char_ls.addAll(Arrays.asList(m));
                for (String content_i:content_list_array){
                    String is=content_i.substring(0,1);
                    base_char_ls.remove(is);
                    firstMap.put(is,null);

                }
                reg.add("(["+getAZaz09Reg(base_char_ls)+"][^&]*)");
                //包含自身直接结束且不在content组中
                for (String mKey:firstMap.keySet()){
                    if(!Arrays.asList(content_list_array).contains(mKey)){
                        reg.add("|("+mKey+")");
                    }
                }
            }else{
                //前 I 个字符 +非第(I+1)个字符
                List<String >content_0_i_list =new ArrayList<>();//取前I   个字符
                List<String >content_0_j_list =new ArrayList<>();//取前I+1 个字符
                Map<String,Object> midIMap=new HashMap(); //自身
                for (String content_i:content_list_array){
                    if(content_i.length()>=(i+1)){
                        String content_0_i=content_i.substring(0,i);
                        if(!content_0_i_list.contains(content_0_i)){
                            content_0_i_list.add(content_0_i);
                        }
                        String content_0_j=content_i.substring(0,i+1);
                        if(!content_0_j_list.contains(content_0_j)){
                            content_0_j_list.add(content_0_j);
                        }
                        midIMap.put(content_0_i,null);
                    }else{
                        //System.out.println(mi+" ->"+i);
                        if(content_i.length()<=i){
                            String is_ij=content_i;
                            if(!content_0_i_list.contains(is_ij)){
                                content_0_i_list.add(is_ij);
                            }
                            String is_ik=content_i+p_char(i-content_i.length());
                            if(!content_0_j_list.contains(is_ik)){
                                content_0_j_list.add(is_ik);
                            }
                        }
                    }
                }
                //System.out.println(ijs);
                //System.out.println(iks);
                //固定前I个字符串的ij
                for (String content_0_i:content_0_i_list){
                    List<String> bi=new ArrayList<>()  ;
                    bi.addAll(Arrays.asList(m));
                    Boolean in_next=false;
                    for (String mk:content_0_j_list){
                        if(-1!=mk.indexOf(content_0_i)){
                            String is=mk.substring(i,i+1);
                            bi.remove(is);
                            in_next=true;
                        }
                    }
                    String curl_reg="";
                    if(content_0_i.length()<i){
                        if(!in_next){
                            String mid_="[^&]*";
                            curl_reg="|("+content_0_i+mid_+"["+getAZaz09Reg(bi)+"][^&]*)";
                        }
                    }else {
                        curl_reg="|("+content_0_i+"["+getAZaz09Reg(bi)+"][^&]*)";
                        //包含自身直接结束且不在content组中
                        for (String  mKey:midIMap.keySet()){
                            if(!Arrays.asList(content_list_array).contains(mKey)){
                                reg.add("|("+mKey+")");
                            }
                        }
                    }
                    reg.add(curl_reg);
                }
            }

        }
        reg.add("|[^&]{"+(maxLen+1)+",64}");
        //对正则去重
        List newRegList = reg.stream().distinct().collect(Collectors.toList());
        return String.join("",newRegList);
    }

    public static  String createJavaPatternRegStr(String serchKey,String handle,String content){
        String line_rule="";
        final String[] time_range_key={"b1"};
        try{
            switch (handle){
                case "e":
                    // str 等于
                    line_rule+=serchKey+"=("+content+")&.*";
                    break;
                case "ue":
                    // str 不等于
                    //line_rule+=sk+"=(?!"+content+")&.*";
                    if (true){
                        line_rule+=serchKey+"=("+GetUnEqualRegx(content)+")&.*";
                    }
                    break;
                case "i":
                    // str 包含
                    if(Arrays.asList(time_range_key).contains(serchKey)){
                        //00:00:00-12:00:00
                        String r_regx=get_time_range_rex(content);
                        if(StringUtils.isNotBlank(r_regx)){
                            line_rule+=serchKey+"=[^&]*"+r_regx+"[^&]*&.*";
                        }
                    }else {
                        line_rule+=serchKey+"=[^&]*("+content+")[^&]*&.*";
                    }
                    break;
                case "ui":
                    // str 不包含
                    /*
                    //&cookies=[^&]*(v|v|v)(?!t_4b1|t_4b|t_4b3)[^&]*
//                    if(false){
//                        //?! 支持下的正则
//                        if(Arrays.asList(time_range_key).contains(sk)){
//                            ///b1=2022-07-04T16:36:41+08:00&
//                            String r_regx=get_time_range_rex(content);
//                            if(StringUtils.isNotBlank(r_regx)){
//                                line_rule+=sk+"=([^&]*T(?!"+r_regx+")[^&]*)&.*";
//                            }
//                        }else{
//                            if(content.length()>1){
//                                String[] ps=content.split("|");
//                                if(1==ps.length  ){
//                                    line_rule+=sk+"=[^&]*"+content.substring(0,1)+"(?!"+content.substring(1)+")[^&]*&.*";
//                                }else if(ps.length>=2){
//                                    List<String> h_list=new ArrayList<>();
//                                    List<String> t_list=new ArrayList<>();
//                                    for (String p:ps){
//                                        String h=p.substring(0,1);
//                                        String t=p.substring(1);
//                                        if(!h_list.contains(h)){
//                                            h_list.add(h);
//                                        }
//                                        if(!t_list.contains(t)){
//                                            t_list.add(t);
//                                        }
//                                    }
//                                    line_rule+=sk+"=([^&]*("+String.join("|",h_list)+")(?!"+String.join("|",t_list)+")[^&]*)&.*";
//                                }
//                            }
//                        }
//                    }

                     */
                    if (true){
                        line_rule+=serchKey+"=("+GetUnEqualRegx(content)+")&.*";
                    }
                    break;
                case "lge":
                    // 长度长于
                    line_rule+=serchKey+"=[^&]{"+content+",128}&"+".*";
                    break;
                case "le":
                    // 长度等于
                    line_rule+=serchKey+"=[^&]{"+content+"}&"+".*";
                    break;
                case "lle":
                    // 长度小于
                    line_rule+=serchKey+"=[^&]{1,"+content+"}&"+".*";
                    break;
                case "null":
                    //为空
                    line_rule+=serchKey+"=&"+".*";
                    break;
                case "ie":
                    //数值等于
                    line_rule+=serchKey+"="+content+"&.*";
                    break;
                case "ile":
                    //数值小于
                    if(true){
                        if(1==content.length()){
                            String reg="[0-"+content+"]";
                            line_rule+=serchKey+"="+reg+"&.*";
                        }else{
                            //多位数值生成
                            //23515
                            // \d{1,4}
                            List<String> regList=new ArrayList<>();
                            String reg0=String.format("(\\d{1,%d})",content.length()-1);
                            regList.add(reg0);
                            for (int i = 0; i <content.length() ; i++) {
                                String content_0_i=content.substring(0,i+1);
                                //char[] content_0_i_char_array=content_0_i.toCharArray();
                                Integer v_i=Integer.parseInt(content.substring(i,i+1)) ;
                                // String c_regx=String.valueOf(content_0_i_char_array);
                                //System.out.println(c_regx);
                                if (content_0_i.length()>1){
                                    Integer last_x_sum=content.length()-i-1;
                                    String last_0_i= content_0_i.substring(0,content_0_i.length()-1);
                                    String last_v="";
                                    if (v_i-1>0){
                                        last_v="[0-"+(v_i-1)+"]";
                                    }else if(0==v_i-1){
                                        last_v="0";
                                    }
                                    String reg=last_0_i+last_v;
                                    if (last_x_sum>0){
                                        reg+="\\d{"+last_x_sum+"}";
                                    }
                                    regList.add(reg);
                                }
                            }
                            List newRegList = regList.stream().distinct().collect(Collectors.toList());
                            String f_reg="";
                            for (int i = 0; i <newRegList.size() ; i++) {
                                f_reg+=newRegList.get(i);
                                if(i!=newRegList.size() -1){
                                    f_reg+="|";
                                }
                            }
                            line_rule+=serchKey+"=("+f_reg+")&.*";
                        }
                    }
                    break;
                case "ige":
                    //数值大于
                    if(true){
                        List<String> regList=new ArrayList<>();
                        String reg0=String.format("(\\d{%d,32})",content.length()+1);
                        regList.add(reg0);
                        for (int i = 0; i <content.length() ; i++) {
                            String content_0_i=content.substring(0,i+1);
                            //char[] content_0_i_char_array=content_0_i.toCharArray();
                            Integer v_i=Integer.parseInt(content.substring(i,i+1)) ;
                            // String c_regx=String.valueOf(content_0_i_char_array);
                            //System.out.println(c_regx);
                            if (content_0_i.length()>0){
                                Integer last_x_sum=content.length()-i-1;
                                String last_0_i= content_0_i.substring(0,content_0_i.length()-1);
                                String last_v="";
                                if ((v_i+1)<9){
                                    last_v="["+(v_i+1)+"-9]";
                                }else if(9==(v_i+1)){
                                    last_v="9";
                                }
                                String reg=last_0_i+last_v;
                                if (last_x_sum>0){
                                    reg+="\\d{"+last_x_sum+"}";
                                }
                                regList.add(reg);
                            }
                        }

                        List newRegList = regList.stream().distinct().collect(Collectors.toList());
                        String f_reg="";
                        for (int i = 0; i <newRegList.size() ; i++) {
                            f_reg+=newRegList.get(i);
                            if(i!=newRegList.size() -1){
                                f_reg+="|";
                            }
                        }
                        line_rule+=serchKey+"=("+f_reg+")&.*";
                    }
                    break;
                default:
                    break;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return  line_rule;
    }

    public static void main(String[] args) {
        //e ue i ui  lge le lle null ie ile ige
        String key="na";
        String handle="ige";
        String content="10349123";
        System.out.println(content);
        System.out.println("handle="+handle);
        String reg=createJavaPatternRegStr(key,handle,content);
        System.out.println(reg);
        Pattern r = Pattern.compile(reg);
        Long cv=Long.parseLong(content);
        switch (handle){
            case "ile":
                if(true){
                    Long i=1L;
                    for ( i = 1L; i <cv ; i++) {
                        Long new_cv=cv-i;
                        String str=key+"="+new_cv+"&";
                        Matcher m = r.matcher(str);
                        //System.out.println(str);
                        if (!m.matches()){
                            System.out.println(str);
                        }

                    }
                }
                break;
            case "ige":
                if (true){
                    Long i=1L;
                    for ( i = 1L; i <cv ; i++) {
                        Long new_cv=i+cv;
                        String str=key+"="+new_cv+"&";
                        Matcher m = r.matcher(str);
                        if (!m.matches()){
                            System.out.println(str);
                        }

                    }
                }
                break;

        }


    }
}


发表评论:

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

联系我 331434376    15629529961