Gleichen Sie eine Zeichenfolge mit mehreren Regex-Mustern

Question

Ich habe eine Eingabezeichenfolge.

Ich denke darüber nach, wie diese Zeichenfolge mit mehr als einem regulären Ausdruck effektiv übereinstimmen.

Example Input: ABCD 

ich gegen diese reg-ex-Muster passen mag, und true zurück, wenn zumindest einer von ihnen übereinstimmt:

[a-zA-Z]{3} 

^[^\\d].* 

([\\w&&[^b]])* 

Ich bin nicht sicher, wie auf einmal gegen mehrere Muster entsprechen . Kann mir jemand sagen, wie wir es effektiv machen?

Answer 1

Wenn Sie nur ein paar reguläre Ausdrücke haben, und sie sind alle bekannten zur Kompilierzeit, dann kann dies genug sein:

private static final Pattern 
    rx1 = Pattern.compile("..."), 
    rx2 = Pattern.compile("..."), 
    ...; 

return rx1.matcher(s).matches() || rx2.matcher(s).matches() || ...; 

Wenn es mehr von ihnen gibt, oder sie geladen sind zur Laufzeit, dann verwenden Sie eine Liste von Mustern:

final List<Pattern> rxs = new ArrayList<>(); 


for (Pattern rx : rxs) if (rx.matcher(input).matches()) return true; 
return false; 

Answer 2

Ich bin mir nicht sicher, was effectively Mittel, aber wenn es um Leistung und Sie wollen eine Menge von Zeichenketten überprüfen, die ich für dieses

gehen würde

... 
static Pattern p1 = Pattern.compile("[a-zA-Z]{3}"); 
static Pattern p2 = Pattern.compile("^[^\\d].*"); 
static Pattern p3 = Pattern.compile("([\\w&&[^b]])*"); 

public static boolean test(String s){ 
    return p1.matcher(s).matches ? true: 
     p2.matcher(s).matches ? true: 
     p3.matcher(s).matches; 
} 

Ich bin nicht sicher, wie es beeinflussen Leistung, aber die Kombination aller in einem Regexp mit | könnte auch helfen.

Answer 3

Um das erneute Erstellen von Instanzen von Pattern- und Matcher-Klassen zu vermeiden, können Sie jeweils eine davon erstellen und sie erneut verwenden. Um die Klasse Matcher wiederzuverwenden, können Sie die Methode reset(newInput) verwenden. Warnung: Dieser Ansatz ist nicht threadsicher. Verwenden Sie es nur, wenn Sie garantieren können, dass nur ein Thread diese Methode verwenden kann, andernfalls erstellen Sie für jeden Methodenaufruf eine separate Instanz von Matcher.

Dies ist eines der möglichen Codebeispiele

private static Matcher m1 = Pattern.compile("regex1").matcher(""); 
private static Matcher m2 = Pattern.compile("regex2").matcher(""); 
private static Matcher m3 = Pattern.compile("regex3").matcher(""); 

public boolean matchesAtLeastOneRegex(String input) { 
    return  m1.reset(input).matches() 
      || m2.reset(input).matches() 
      || m3.reset(input).matches(); 
} 

Answer 4

Sie eine große regex aus den einzelnen diejenigen machen können:

[a-zA-Z]{3}|^[^\\d].*|([\\w&&[^b]])* 

Answer 5

Hier ist eine Alternative. Beachten Sie, dass dies in einer bestimmten Reihenfolge nicht zurückgegeben wird. Das könnte man aber tun, indem man zum Beispiel nach m.start() sortiert.

private static HashMap<String, String> regs = new HashMap<String, String>(); 

...

regs.put("COMMA", ","); 
    regs.put("ID", "[a-z][a-zA-Z0-9]*"); 
    regs.put("SEMI", ";"); 
    regs.put("GETS", ":="); 
    regs.put("DOT", "\\."); 

    for (HashMap.Entry<String, String> entry : regs.entrySet()) { 
     String key = entry.getKey(); 
     String value = entry.getValue(); 
     Matcher m = Pattern.compile(value).matcher("program var a, b, c; begin a := 0; end."); 
     boolean f = m.find(); 
     while(f) 
     { 
      System.out.println(key); 
      System.out.print(m.group() + " "); 
      System.out.print(m.start() + " "); 
      System.out.println(m.end()); 
      f = m.find(); 
     } 

    } 
} 

Answer 6

wie es in (Running multiple regex patterns on String) erklärt wurde es besser ist, jede Regex eine große regex zu verketten und als die Matcher laufen nur einen. Dies ist eine große Verbesserung, wenn Sie die Regex oft wiederverwenden.