Faire correspondre une chaîne à plusieurs modèles d'expressions régulières

J'ai une chaîne d'entrée.

Je pense à la façon de correspondre à cette chaîne de contre plus d'une expression régulière efficacement.

Example Input: ABCD

J'aimerais match contre ces reg-ex les modèles, et le retour true si au moins l'un d'entre eux correspond à:

[a-zA-Z]{3}

^[^\\d].*

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

Je ne suis pas sûr de la façon de correspondre à l'encontre de plusieurs modèles à la fois. Peut-on me dire comment le faire efficacement?

source d'informationauteur Patan

  1. 20

    Si vous avez quelques regexes, et ils sont tous connus au moment de la compilation, cela peut être suffisant:

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

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

    Si il y en a plus, ou qu'ils sont chargés lors de l'exécution, puis utiliser une liste de modèles:

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


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

    vous pouvez faire une grande regex de l'individu:

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

    Je ne suis pas sûr de ce que effectively moyens, mais si c'est au sujet de la performance et que vous voulez vérifier beaucoup de chaînes, j'irais pour ce

    ...
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;
}

    Je ne suis pas sûr de savoir comment il va affecter les performances, mais la combinaison de tous dans une regexp avec | pourrait aussi aider.

  4. 1

    Pour éviter de recréer des instances de Pattern et Matcher de classes, vous pouvez créer un de chaque et de les réutiliser. Pour réutiliser Matcher classe, vous pouvez utiliser reset(newInput) méthode.
    Avertissement: Cette approche n'est pas thread-safe. Utiliser seulement quand vous pouvez garantir qu'un seul thread sera en mesure d'utiliser cette méthode, autrement créer une instance distincte de Matcher pour chacune des méthodes d'appel.

    C'est l'un des possible des exemples de code

    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();
}
  5. 0

    Voici une alternative.
    Notez qu'une chose ce n'est pas faire est de retour dans un ordre spécifique. Mais on pourrait le faire par le tri par fusion.start() par exemple.

    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();
        }

    }   
}
  6. 0

    comme il a été expliqué dans ( L'exécution de plusieurs modèles regex sur la Chaîne ), il est préférable pour concaténer chaque regex pour un grand regex et que de courir le matcher un seul. C'est une grande amélioration est vous souvent la réutilisation de l'expression rationnelle.