正则表达式 - 捕获重复数字（不是数字）

Question

I'm trying to write a method in Java that checks a String and allows it to only contain numbers and comma. Besides, there can be no repeating numbers.

For instance:

• 11,22,33 - this is ok
• 22,22,33 - this is NOT ok

I've done a first draft of it using a combination of regex and Set<String> (below), but was looking for something better, preferably using regex only.

public boolean isStringOk(String codes) {
    if(codes.matches("^[0-9,]+$")){ 
        Set<String> nonRepeatingCodes = new LinkedHashSet<String>();
        for(String c: codigoRoletas.split(",")){
            if(nonRepeatingCodes.contains(c)){
                return false;
            }
            else{
                nonRepeatingCodes.add(c);
            }
        }
        return true;
     }
    return false;
}

Does anyone know if this is possible using regex only?

Answer 1

I doubt that it is advisable (as Jarrod Roberson mentioned), since it is hard to understand for any fellow coder on your project. But it is definitely possible with regex only:

^(?:(\d+)(?!.*,\1(?!\d)),)*\d+$

The double-negative lookahead makes it a bit difficult to understand. But here is an explanation:

^                # anchor the regex to the beginning of the string
(?:              # subpattern that matches all numbers, but the last one and all commas
    (\d+)        # capturing group \1, a full number
    (?!          # negative lookahead, that asserts that this number does not occur again
        .*       # consume as much as you want, to look through the whole string
        ,        # match a comma
        \1       # match the number we have already found
        (?!\d)   # make sure that the number has ended (so we don't get false negatives)
    )            # end of lookahead
    ,            # match the comma
)*               # end of subpattern, repeat 0 or more times
\d+              # match the last number
$                # anchor the regex to the beginning of the string

Note that this up there is just the general regex, not specific to Java. In Java you need to escape every backslash, otherwise it won't get through to the regex engine:

^(?:(\\d+)(?!.*,\\1(?!\\d)),)*\\d+$

Answer 2

Be warned that using regular expressions for what's technically a non-regular language can be dangerous, especially for large, non-matching strings. You can introduce exponential time complexity if you're not careful. Also, regular expression engines have to do some back-door tricks that can also slow down the engine.

If you try the other solutions and they give you problems, you can try it this way using a capture group along with the Pattern and Matcher classes to make your code cleaner:

private static final Pattern PATTERN = Pattern.compile("([\\d]+),?");

public static boolean isValid(String str) {
    Matcher matcher = PATTERN.matcher(str);
    Set<Integer> found = new HashSet<Integer>();
    while (matcher.find()) {
        if (!found.add(Integer.parseInt(matcher.group(1)))
            return false;
    }
    return true;
}

Answer 3

Here's the least-ugly regex I could come up with:

return codes.matches("^(?:,?(\\d+)(?=(?:,(?!\\1\\b)\\d+)*$))+$");

breakdown:

• ,? consumes the next comma if there is one (ie, it's not the beginning of the string).

• (\\d+) captures the next number in group #1

• (?=(?:,(?!\\1\\b)\\d+)*$) tries to match the remaining numbers, checking each one to make sure it's not the same as the one that was just captured.

The \\b after the backreference prevents false positives on strings like 11,111 . It isn't needed anywhere else, but you can tack one onto each \\d+ if you want, and it might make the regex slightly more efficient. But if you need to tweak the regex for maximum performance, making all the quantifiers possessive will have more effect:

"^(?:,?+(\\d++)(?=(?:,(?!\\1\\b)\\d++)*+$))++$"

Answer 4

This regex would do

^(?=^\d+(?:,\d+)*$)(?!^.*?((?<=(?:^|,))\d+(?=[,$])).*?\1(?:$|,.*?)).*?$

(?=^\\d+(?:,\\d+)*$) checks for valid format like 45 or 55,66,88,33

(?!^.*?((?<=(?:^|,))\\d+(?=[,$])).*?\\1(?:$|,.*?)) doesnt match if there are any repeating digits..

.*? matches everything provided the above negative lookahead returns true

works here