¿Cómo comprobar si un determinado Regex es válido?

Tengo un pequeño progtwig que permite a los usuarios escribir algunas expresiones regulares. después me gusta comprobar si esta entrada es una expresión regular válida o no.

Me pregunto si hay un método incorporado en Java, pero no podría encontrar ese tipo de jet.

¿Me puedes dar algún consejo?

Aquí hay un ejemplo.

 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" luego emite "Unclosed group" , por ejemplo.

Puede simplemente Pattern.compile la cadena de Pattern.compile regulares y ver si Pattern.compile la 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!"); } 

Este en particular produce el siguiente resultado:

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

Respecto a las miradas

Aquí hay una cita de la antigua trusty regular-expressions.info :

Notas importantes sobre Lookbehind

Java lleva las cosas un paso más allá al permitir la repetición finita. Aún no puede usar la estrella o más, pero puede usar el signo de interrogación y las llaves con el parámetro máximo especificado. Java reconoce el hecho de que la repetición finita se puede reescribir como una alternancia de cadenas con longitudes diferentes pero fijas .

Creo que la frase contiene un error tipográfico, y probablemente debería decir “longitudes diferentes, pero finitas”. En cualquier caso, Java parece permitir la alternancia de diferentes longitudes en la mirada.

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

También hay un error en el que realmente puedes tener una mirada infinita y hacer que funcione , pero no confiaría en tales comportamientos.

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

Lo más obvio sería usar el método de comstackción en java.util.regex.Pattern y capturar PatternSyntaxException

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

Esto lanzará una PatternSyntaxException si myRegEx no es válido.

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