如何检查给定的正则表达式是否有效?

时间:2010-04-24 14:49:59

标签: java regex

我有一个小程序,允许用户输入一些正则表达式。之后我想检查这个输入是否是有效正则表达式。

我想知道Java中是否有内置方法,但找不到这样的喷射。

你能给我一些建议吗?

7 个答案:

答案 0 :(得分:60)

这是一个例子。

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",例如。

答案 1 :(得分:12)

您只需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
***
^

关于lookbehinds

以下是旧可靠regular-expressions.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!"

答案 2 :(得分:3)

最明显的事情是在java.util.regex.Pattern和catch中使用compile方法 PatternSyntaxException

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

如果myRegEx无效,则会抛出PatternSyntaxException

答案 3 :(得分:2)

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

        }
    }
}

答案 4 :(得分:0)

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

答案 5 :(得分:0)

新的String()。matches(regEx)可以直接与try-catch一起使用,以识别regEx是否有效。

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

答案 6 :(得分:0)

尝试:

import java.util.Scanner;
import java.util.regex.*;

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();
        if(pattern != null && !pattern.equals("")){
            try{
                Pattern.compile(pattern);
                System.out.println("Valid");
            }catch(PatternSyntaxException e){
                System.out.println("Invalid");
            }
        }
        testCases--;
        //Write your code
     }
  }
 }

使用输入进行测试:
3
([A-Z])(。+)
[AZa-z
batcatpat(nat