“ glob”类型模式是否具有等效的java.util.regex?


84

是否存在用于在Java中进行“全局”类型匹配的标准(最好是Apache Commons或类似的非病毒)库?当我不得不在Perl中执行类似的操作时,我只是将所有的“ .”更改为“ \.”,将“ *”更改为“ .*”,将“ ?”更改为“ .”,但是我想知道是否有人做了为我工作。

相似的问题:从全局表达式创建正则表达式


来自Jakarta ORO的GlobCompiler / GlobEngine看起来很有希望。它在Apache许可下可用。
史蒂夫·鳟鱼

您能举一个您想做的确切例子吗?
托尔比约恩Ravn的安徒生

我想做的(或我的客户想做的)是在URL中匹配“ -2009 /”或“ * rss ”之类的东西。通常,转换成正则表达式很简单,但我想知道是否有更简单的方法。
Paul Tomblin,2009年

我建议使用Ant样式文件globing,因为它似乎已成为Java世界中的规范性问题。请参阅我的答案以获取更多详细信息:stackoverflow.com/questions/1247772/…
亚当·根特

1
@BradMace,相关,但那里的大多数答案都假设您正在遍历目录树。不过,如果有人仍在寻找如何对任意字符串进行全局样式匹配,那么他们也可能也应该寻找该答案。
保罗·汤布林

Answers:


46

没有内置的东西,但是将类似glob的东西转换成正则表达式很简单:

public static String createRegexFromGlob(String glob)
{
    String out = "^";
    for(int i = 0; i < glob.length(); ++i)
    {
        final char c = glob.charAt(i);
        switch(c)
        {
        case '*': out += ".*"; break;
        case '?': out += '.'; break;
        case '.': out += "\\."; break;
        case '\\': out += "\\\\"; break;
        default: out += c;
        }
    }
    out += '$';
    return out;
}

这对我有用,但是我不确定它是否覆盖了“标准”,如果有的话:)

Paul Tomblin的更新:我发现了一个执行glob转换的perl程序,并将其适应Java,最终得到了:

    private String convertGlobToRegEx(String line)
    {
    LOG.info("got line [" + line + "]");
    line = line.trim();
    int strLen = line.length();
    StringBuilder sb = new StringBuilder(strLen);
    // Remove beginning and ending * globs because they're useless
    if (line.startsWith("*"))
    {
        line = line.substring(1);
        strLen--;
    }
    if (line.endsWith("*"))
    {
        line = line.substring(0, strLen-1);
        strLen--;
    }
    boolean escaping = false;
    int inCurlies = 0;
    for (char currentChar : line.toCharArray())
    {
        switch (currentChar)
        {
        case '*':
            if (escaping)
                sb.append("\\*");
            else
                sb.append(".*");
            escaping = false;
            break;
        case '?':
            if (escaping)
                sb.append("\\?");
            else
                sb.append('.');
            escaping = false;
            break;
        case '.':
        case '(':
        case ')':
        case '+':
        case '|':
        case '^':
        case '$':
        case '@':
        case '%':
            sb.append('\\');
            sb.append(currentChar);
            escaping = false;
            break;
        case '\\':
            if (escaping)
            {
                sb.append("\\\\");
                escaping = false;
            }
            else
                escaping = true;
            break;
        case '{':
            if (escaping)
            {
                sb.append("\\{");
            }
            else
            {
                sb.append('(');
                inCurlies++;
            }
            escaping = false;
            break;
        case '}':
            if (inCurlies > 0 && !escaping)
            {
                sb.append(')');
                inCurlies--;
            }
            else if (escaping)
                sb.append("\\}");
            else
                sb.append("}");
            escaping = false;
            break;
        case ',':
            if (inCurlies > 0 && !escaping)
            {
                sb.append('|');
            }
            else if (escaping)
                sb.append("\\,");
            else
                sb.append(",");
            break;
        default:
            escaping = false;
            sb.append(currentChar);
        }
    }
    return sb.toString();
}

我正在编辑此答案,而不是自己编写,因为此答案使我走上了正确的轨道。


1
是的,这几乎是我上次不得不这样做的解决方案(在Perl中),但是我想知道是否还有更优雅的方法。我想我会按照自己的方式去做。
Paul Tomblin,2009年


您不能使用正则表达式替换将全局转换为正则表达式吗?
蒂姆·西尔维斯特

1
对于Java,需要删除
顶部的开头

10
FYI:为“通配”的标准是POSIX shell语言- opengroup.org/onlinepubs/009695399/utilities/...
斯蒂芬ç

60

还计划在Java 7中实现Globbing 。

请参阅FileSystem.getPathMatcher(String)“查找文件”教程


23
奇妙。但是,为什么这种实现方式仅限于“路径”对象呢?就我而言,我想匹配URI ...
Yves Martin

3
从sun.nio的源头看,全局匹配似乎是由Globs.java实现的。不幸的是,这是专门为文件系统路径编写的,因此不能用于所有字符串(它对路径分隔符和非法字符进行了一些假设)。但这可能是一个有用的起点。
尼尔·特拉夫特

33

感谢这里的每个人的贡献。我写的转换比以前的任何答案都更全面:

/**
 * Converts a standard POSIX Shell globbing pattern into a regular expression
 * pattern. The result can be used with the standard {@link java.util.regex} API to
 * recognize strings which match the glob pattern.
 * <p/>
 * See also, the POSIX Shell language:
 * http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_13_01
 * 
 * @param pattern A glob pattern.
 * @return A regex pattern to recognize the given glob pattern.
 */
public static final String convertGlobToRegex(String pattern) {
    StringBuilder sb = new StringBuilder(pattern.length());
    int inGroup = 0;
    int inClass = 0;
    int firstIndexInClass = -1;
    char[] arr = pattern.toCharArray();
    for (int i = 0; i < arr.length; i++) {
        char ch = arr[i];
        switch (ch) {
            case '\\':
                if (++i >= arr.length) {
                    sb.append('\\');
                } else {
                    char next = arr[i];
                    switch (next) {
                        case ',':
                            // escape not needed
                            break;
                        case 'Q':
                        case 'E':
                            // extra escape needed
                            sb.append('\\');
                        default:
                            sb.append('\\');
                    }
                    sb.append(next);
                }
                break;
            case '*':
                if (inClass == 0)
                    sb.append(".*");
                else
                    sb.append('*');
                break;
            case '?':
                if (inClass == 0)
                    sb.append('.');
                else
                    sb.append('?');
                break;
            case '[':
                inClass++;
                firstIndexInClass = i+1;
                sb.append('[');
                break;
            case ']':
                inClass--;
                sb.append(']');
                break;
            case '.':
            case '(':
            case ')':
            case '+':
            case '|':
            case '^':
            case '$':
            case '@':
            case '%':
                if (inClass == 0 || (firstIndexInClass == i && ch == '^'))
                    sb.append('\\');
                sb.append(ch);
                break;
            case '!':
                if (firstIndexInClass == i)
                    sb.append('^');
                else
                    sb.append('!');
                break;
            case '{':
                inGroup++;
                sb.append('(');
                break;
            case '}':
                inGroup--;
                sb.append(')');
                break;
            case ',':
                if (inGroup > 0)
                    sb.append('|');
                else
                    sb.append(',');
                break;
            default:
                sb.append(ch);
        }
    }
    return sb.toString();
}

并通过单元测试证明其有效:

/**
 * @author Neil Traft
 */
public class StringUtils_ConvertGlobToRegex_Test {

    @Test
    public void star_becomes_dot_star() throws Exception {
        assertEquals("gl.*b", StringUtils.convertGlobToRegex("gl*b"));
    }

    @Test
    public void escaped_star_is_unchanged() throws Exception {
        assertEquals("gl\\*b", StringUtils.convertGlobToRegex("gl\\*b"));
    }

    @Test
    public void question_mark_becomes_dot() throws Exception {
        assertEquals("gl.b", StringUtils.convertGlobToRegex("gl?b"));
    }

    @Test
    public void escaped_question_mark_is_unchanged() throws Exception {
        assertEquals("gl\\?b", StringUtils.convertGlobToRegex("gl\\?b"));
    }

    @Test
    public void character_classes_dont_need_conversion() throws Exception {
        assertEquals("gl[-o]b", StringUtils.convertGlobToRegex("gl[-o]b"));
    }

    @Test
    public void escaped_classes_are_unchanged() throws Exception {
        assertEquals("gl\\[-o\\]b", StringUtils.convertGlobToRegex("gl\\[-o\\]b"));
    }

    @Test
    public void negation_in_character_classes() throws Exception {
        assertEquals("gl[^a-n!p-z]b", StringUtils.convertGlobToRegex("gl[!a-n!p-z]b"));
    }

    @Test
    public void nested_negation_in_character_classes() throws Exception {
        assertEquals("gl[[^a-n]!p-z]b", StringUtils.convertGlobToRegex("gl[[!a-n]!p-z]b"));
    }

    @Test
    public void escape_carat_if_it_is_the_first_char_in_a_character_class() throws Exception {
        assertEquals("gl[\\^o]b", StringUtils.convertGlobToRegex("gl[^o]b"));
    }

    @Test
    public void metachars_are_escaped() throws Exception {
        assertEquals("gl..*\\.\\(\\)\\+\\|\\^\\$\\@\\%b", StringUtils.convertGlobToRegex("gl?*.()+|^$@%b"));
    }

    @Test
    public void metachars_in_character_classes_dont_need_escaping() throws Exception {
        assertEquals("gl[?*.()+|^$@%]b", StringUtils.convertGlobToRegex("gl[?*.()+|^$@%]b"));
    }

    @Test
    public void escaped_backslash_is_unchanged() throws Exception {
        assertEquals("gl\\\\b", StringUtils.convertGlobToRegex("gl\\\\b"));
    }

    @Test
    public void slashQ_and_slashE_are_escaped() throws Exception {
        assertEquals("\\\\Qglob\\\\E", StringUtils.convertGlobToRegex("\\Qglob\\E"));
    }

    @Test
    public void braces_are_turned_into_groups() throws Exception {
        assertEquals("(glob|regex)", StringUtils.convertGlobToRegex("{glob,regex}"));
    }

    @Test
    public void escaped_braces_are_unchanged() throws Exception {
        assertEquals("\\{glob\\}", StringUtils.convertGlobToRegex("\\{glob\\}"));
    }

    @Test
    public void commas_dont_need_escaping() throws Exception {
        assertEquals("(glob,regex),", StringUtils.convertGlobToRegex("{glob\\,regex},"));
    }

}

感谢您提供此代码,尼尔!您愿意给它一个开源许可证吗?
史蒂文

1
我特此同意,此答案中的代码在公共领域中。
尼尔·特拉夫特

我还应该做其他事情吗?:-P
Neil Traft

9

有一些库进行类似于Glob的模式匹配,比列出的库更现代:

Theres蚂蚁目录扫描仪 和Springs AntPathMatcher

我推荐其他两种解决方案,因为Ant Style Globbing已经几乎成为Java世界中的标准glob语法(Hudson,Spring,Ant和我认为Maven)。


1
这是使用AntPathMatcher的工件的Maven坐标:search.maven.org/… 以及一些使用示例用法的测试:github.com/spring-projects/spring-framework/blob/master/…–
seanf

而且您可以自定义“路径”字符...因此它对路径以外的其他东西很有用...
Michael Wiles

7

最近,我不得不这样做,并使用\Q\E逃避glob模式:

private static Pattern getPatternFromGlob(String glob) {
  return Pattern.compile(
    "^" + Pattern.quote(glob)
            .replace("*", "\\E.*\\Q")
            .replace("?", "\\E.\\Q") 
    + "$");
}

4
如果字符串中的某个位置有\ E,就不会中断吗?
jmo 2011年

@jmo,是的,但是您可以通过glob使用glob = Pattern.quote(glob)预处理变量来规避这一点,我相信这种变量可以处理这种情况。但是,在这种情况下,您无需在第一个和最后一个\\ Q和\\ E之前和之后进行添加。
Kimball Robinson

2
@jmo我已经修复了使用Pattern.quote()的示例。
dimo414 '16

5

这是一个处理*和?的简单Glob实现。在模式中

public class GlobMatch {
    private String text;
    private String pattern;

    public boolean match(String text, String pattern) {
        this.text = text;
        this.pattern = pattern;

        return matchCharacter(0, 0);
    }

    private boolean matchCharacter(int patternIndex, int textIndex) {
        if (patternIndex >= pattern.length()) {
            return false;
        }

        switch(pattern.charAt(patternIndex)) {
            case '?':
                // Match any character
                if (textIndex >= text.length()) {
                    return false;
                }
                break;

            case '*':
                // * at the end of the pattern will match anything
                if (patternIndex + 1 >= pattern.length() || textIndex >= text.length()) {
                    return true;
                }

                // Probe forward to see if we can get a match
                while (textIndex < text.length()) {
                    if (matchCharacter(patternIndex + 1, textIndex)) {
                        return true;
                    }
                    textIndex++;
                }

                return false;

            default:
                if (textIndex >= text.length()) {
                    return false;
                }

                String textChar = text.substring(textIndex, textIndex + 1);
                String patternChar = pattern.substring(patternIndex, patternIndex + 1);

                // Note the match is case insensitive
                if (textChar.compareToIgnoreCase(patternChar) != 0) {
                    return false;
                }
        }

        // End of pattern and text?
        if (patternIndex + 1 >= pattern.length() && textIndex + 1 >= text.length()) {
            return true;
        }

        // Go on to match the next character in the pattern
        return matchCharacter(patternIndex + 1, textIndex + 1);
    }
}

5

类似托尼的Edgecombe答案,这里是一个简短的通配符处理支持*?不使用正则表达式,如果有人需要一个。

public static boolean matches(String text, String glob) {
    String rest = null;
    int pos = glob.indexOf('*');
    if (pos != -1) {
        rest = glob.substring(pos + 1);
        glob = glob.substring(0, pos);
    }

    if (glob.length() > text.length())
        return false;

    // handle the part up to the first *
    for (int i = 0; i < glob.length(); i++)
        if (glob.charAt(i) != '?' 
                && !glob.substring(i, i + 1).equalsIgnoreCase(text.substring(i, i + 1)))
            return false;

    // recurse for the part after the first *, if any
    if (rest == null) {
        return glob.length() == text.length();
    } else {
        for (int i = glob.length(); i <= text.length(); i++) {
            if (matches(text.substring(i), rest))
                return true;
        }
        return false;
    }
}

1
很好的答案!这很容易理解,可以快速阅读,而不会太困惑:-)
赎罪有限2015年

3

这可能是一个有点古怪的方法。我已经从NIO2的Files.newDirectoryStream(Path dir, String glob)代码中弄清楚了。请注意,Path将创建每个匹配的新对象。到目前为止,我只能在Windows FS上进行测试,但是,我认为它也应该在Unix上也可以工作。

// a file system hack to get a glob matching
PathMatcher matcher = ("*".equals(glob)) ? null
    : FileSystems.getDefault().getPathMatcher("glob:" + glob);

if ("*".equals(glob) || matcher.matches(Paths.get(someName))) {
    // do you stuff here
}

UPDATE 在Mac和Linux上均可使用。



0

很久以前,我进行了大量的glob驱动的文本过滤,所以我只写了一小段代码(15行代码,除了JDK外没有依赖项)。它仅处理“ *”(对我来说足够了),但可以轻松扩展为“?”。它比预编译的正则表达式快几倍,不需要任何预编译(本质上,每次匹配模式时,它都是字符串与字符串比较)。

码:

  public static boolean miniglob(String[] pattern, String line) {
    if (pattern.length == 0) return line.isEmpty();
    else if (pattern.length == 1) return line.equals(pattern[0]);
    else {
      if (!line.startsWith(pattern[0])) return false;
      int idx = pattern[0].length();
      for (int i = 1; i < pattern.length - 1; ++i) {
        String patternTok = pattern[i];
        int nextIdx = line.indexOf(patternTok, idx);
        if (nextIdx < 0) return false;
        else idx = nextIdx + patternTok.length();
      }
      if (!line.endsWith(pattern[pattern.length - 1])) return false;
      return true;
    }
  }

用法:

  public static void main(String[] args) {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    try {
      // read from stdin space separated text and pattern
      for (String input = in.readLine(); input != null; input = in.readLine()) {
        String[] tokens = input.split(" ");
        String line = tokens[0];
        String[] pattern = tokens[1].split("\\*+", -1 /* want empty trailing token if any */);

        // check matcher performance
        long tm0 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; ++i) {
          miniglob(pattern, line);
        }
        long tm1 = System.currentTimeMillis();
        System.out.println("miniglob took " + (tm1-tm0) + " ms");

        // check regexp performance
        Pattern reptn = Pattern.compile(tokens[1].replace("*", ".*"));
        Matcher mtchr = reptn.matcher(line);
        tm0 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; ++i) {
          mtchr.matches();
        }
        tm1 = System.currentTimeMillis();
        System.out.println("regexp took " + (tm1-tm0) + " ms");

        // check if miniglob worked correctly
        if (miniglob(pattern, line)) {
          System.out.println("+ >" + line);
        }
        else {
          System.out.println("- >" + line);
        }
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

此处复制/粘贴


由于只有15行,因此如果链接页面出现故障,则应在此处添加。
拉尼兹

0

以前的解决方案由文森特罗伯特/ dimo414依赖于Pattern.quote()在以下方面正在实施\Q...... \E,该API中没有记载,因此可能不适合其它/未来的Java实现的情况。以下解决方案通过转义所有出现的\E而不是使用来消除该实现依赖性quote()。万一要匹配的字符串包含换行符,它还会激活DOTALL模式((?s))。

    public static Pattern globToRegex(String glob)
    {
        return Pattern.compile(
            "(?s)^\\Q" +
            glob.replace("\\E", "\\E\\\\E\\Q")
                .replace("*", "\\E.*\\Q")
                .replace("?", "\\E.\\Q") +
            "\\E$"
        );
    }

-1

顺便说一句,似乎您在Perl中做得很艰难

这就是Perl的窍门:

my @files = glob("*.html")
# Or, if you prefer:
my @files = <*.html> 

1
仅当全局对象用于匹配文件时,此方法才有效。在perl情况下,这些glob实际上来自出于我不愿讨论的原因而使用glob编写的ip地址列表,而在我目前的情况下,这些glob则要匹配url。
Paul Tomblin'9
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.