Как проверить, является ли данный Regex действительным?

Question

У меня есть небольшая программа, позволяющая пользователям вводить некоторые регулярные выражения. После этого мне нравится проверять, является ли этот вход действительным регулярным выражением или нет.

Мне интересно, есть ли в Java встроенный метод, но я не смог найти такой джет.

Можете ли вы дать мне совет?

Answer 1

Вот пример.

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class RegexTester {
    public static void main(String[] arguments) {
        String userInputPattern = arguments[0];
        try {
            Pattern.compile(userInputPattern);
        } catch (PatternSyntaxException exception) {
            System.err.println(exception.getDescription());
            System.exit(1);
        }
        System.out.println("Syntax is ok.");
    }
}

java RegexTester "(capture" затем выводит "Unclosed group", например.

Answer 2

Вы можете просто Pattern.compile строка регулярного выражения и посмотреть, если throws PatternSyntaxException.

    String regex = "***";
    PatternSyntaxException exc = null;
    try {
        Pattern.compile(regex);
    } catch (PatternSyntaxException e) {
        exc = e;
    }
    if (exc != null) {
        exc.printStackTrace();
    } else {
        System.out.println("Regex ok!");
    }

Этот, в частности, производит следующий вывод:

java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
***
^

---

Относительно взглядов за плечами

Вот цитата из старого верного регулярные-выражения.info :

Важные замечания о Lookbehind

Java делает шаг вперед, допуская конечное повторение. Вы по-прежнему не можете использовать звезду или плюс, но вы можете использовать знак вопроса и фигурные скобки с указанным параметром max. Java признает тот факт, что конечное повторение может быть переписано как чередование строк с различной, но фиксированной длины .

Я думаю, что фраза содержит опечатку и, вероятно, должна сказать "разные, но конечные длины". В любом случае, Java, кажется, допускает чередование различной длины в обратном направлении.

    System.out.println(
        java.util.Arrays.toString(
            "abracadabra".split("(?<=a|ab)")
        )
    ); // prints "[a, b, ra, ca, da, b, ra]"

Также есть ошибка, из-за которой вы можете иметь бесконечную длину взгляда , и она будет работать , но я бы не стал полагаться на такое поведение.

    System.out.println(
        "1234".replaceAll(".(?<=(^.*))", "$1!")
    ); // prints "1!12!123!1234!"

Answer 3

Самое очевидное, что нужно сделать, это использовать метод компиляции в java.util.regex.Pattern и catch PatternSyntaxException

String myRegEx;
...
...
Pattern p = Pattern.compile(myRegEx);

Это выдаст PatternSyntaxException, если myRegEx недопустим.

Answer 4

public class Solution {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int testCases = Integer.parseInt(in.nextLine());
        while(testCases>0){
            String pattern = in.nextLine();
            try{
                Pattern.compile(pattern);
                System.out.println("Valid");
            }catch(PatternSyntaxException exception){
                System.out.println("Invalid");
            }

        }
    }
}

Answer 5

new String (). Match (regEx) можно напрямую использовать с try-catch, чтобы определить, является ли regEx действительным.

boolean isValidRegEx = true;
try {
    new String().matches(regEx);
} catch(PatternSyntaxException e) {
    isValidRegEx = false;
}

Answer 6

 public class Solution
 {
 public static void main(String[] args){
  Scanner in = new Scanner(System.in);
  int testCases = Integer.parseInt(in.nextLine());
  while(testCases>0){
     String pattern = in.nextLine();
      try
      {
          Pattern.compile(pattern);
      }
      catch(Exception e)
      {
         // System.out.println(e.toString());
          System.out.println("Invalid");
      }
      System.out.println("Valid");
    }
 }
}