其輸入掩碼（200種）

Question

對於記錄替換正則表達式：

X意味着什麼

Ÿ意味着一年

中號意味着一個月

ñ表示數字

一個意味着字母

例如：

從數據庫中我輸入掩碼是這樣的：

XXXYMXXXXXA 

和我輸入的是：

39JY412345O 

我想檢查這個輸入有效或無效，但我不能用掩碼檢查它，我想用regul替換掩碼AR表達這樣它的輸入掩碼：

/^.{3}Y[0-9]{1}.{5}[a-zA-Z]{1}$/ 

我沒有正則表達式，我輸入掩碼only.I有輸入驗證和它使用正則表達式來檢查有效或無效的輸入。我應該用我的輸入掩碼（200種輸入掩碼）替換正則表達式，並使用其正則表達式進行驗證

我需要編寫一個方法，將輸入掩碼（例如「XXXYMXXXXXA」）轉換爲正則表達式以.lang.regex.Pattern格式（例如「。{3} Y [0-9] {1}。{5} [a-zA-Z] {1}」）

這是我的方法代碼：（但我希望這個解決方案的最佳實踐）

private String replaceAll(String pattern, String value, String replaceValue) { 
    String str = value; 
    str = str.replaceAll(pattern, replaceValue.concat("{").concat("1").concat("}")); 
    return str; 
} 

和方法調用：

String anything = "[Xx]"; 
String alphabet = "[Aa]"; 
String number = "[Nn]"; 
String word = getName(); 

word = replaceAll(anything, word, "."); 
word = replaceAll(alphabet, word, "[A-Za-z]"); 
word = replaceAll(number, word, "[0-9]"); 

Answer 1

假設一般的方法，掩碼中的一個字符（例如， 'X'）與正則表達式的一部分（例如'.'）相關聯，並且循環掩碼字符導致數字量詞（如{3}）。

所以我把一個輔助類和一個簡單的測試方法放在了一起，所以也許這是一個從頭開始的點。

Helper類：

import java.util.HashMap; 
import java.util.Map; 

public class PatternBuilder { 

    protected Map<Character, String> mappings = new HashMap<Character, String>(); 
    protected boolean caseSensitive = false; 

    public PatternBuilder() { 
    } 

    public PatternBuilder(boolean caseSensitive) { 
     this.caseSensitive = caseSensitive; 
    } 

    public PatternBuilder addDefinition(char input, String mapping) { 
     if (this.caseSensitive) { 
      this.mappings.put(input, mapping); 
     } else { 
      this.mappings.put(Character.toLowerCase(input), mapping); 
     } 
     return this; 
    } 

    public String buildRegexPattern(String mask) { 
     if ((mask == null) || (mask.length() == 0)) { 
      return ""; 
     } 
     StringBuilder patternBuffer = new StringBuilder(); 
     char lastChar = 0; 
     int count = 0; 
     for (int i = 0; i < mask.length(); i++) { 
      char c = mask.charAt(i); 
      if (this.caseSensitive == false) { 
       c = Character.toLowerCase(c); 
      } 
      if (c != lastChar) { 
       if (count > 0) { 
        String mapped = mappings.get(lastChar); 
        if (mapped == null) { 
         // mapping for char not defined 
         return ""; 
        } 
        patternBuffer.append(mapped); 
        patternBuffer.append("{").append(count).append("}"); 
       } 
       lastChar = c; 
       count = 1; 
      } else { 
       count++; 
      } 
     } 
     if (count > 0) { 
      String mapped = mappings.get(lastChar); 
      if (mapped == null) { 
       mapped = "."; 
      } 
      patternBuffer.append(mapped); 
      patternBuffer.append("{").append(count).append("}"); 
     } 
     return patternBuffer.toString(); 
    } 

} 

用法：

PatternBuilder patternBuilder = new PatternBuilder() 
     .addDefinition('X', ".") 
     .addDefinition('Y', "Y") 
     .addDefinition('M', "[0-9]") 
     .addDefinition('N', "\\d") 
     .addDefinition('A', "[a-zA-Z]"); 
String rePattern = patternBuilder.buildRegexPattern("XxxYMXXXXXA"); // case insensitive, x == X 
System.out.println("Pattern: '" + rePattern + "'"); 
Pattern p = Pattern.compile(rePattern); 

String[] tests = new String[]{ 
    "39JY412345O", // Original, match 
    "39JY41234FO", // replaced 5 with F, still matching 
    "39JY4123457", // replaced O with 7, no match 
    "A9JY4123457" // replaced 3 with A, no match 
};   
for (String s : tests) { 
    Matcher m = p.matcher(s); 
    System.out.println("Test '" + s + "': " + m.matches()); 
} 

我的輸出：

Pattern: '.{3}Y{1}[0-9]{1}.{5}[a-zA-Z]{1}' 
Test '39JY412345O': true 
Test '39JY41234FO': true 
Test '39JY4123457': false 
Test 'A9JY4123457': false