Java regular expression: A-Z and - or _, but only once

Question

I've only dabbled in regular expressions and was wondering if someone could help me make a Java regex, which matches a string with these qualities:

1. It is 1-14 characters long
2. It consists only of A-Z, a-z and the letters _ or -
3. The symbol - and _ must be contained only once (together) and not at the start

It should match

• Hello-Again
• ThisIsValid
• AlsoThis_

but not

• -notvalid
• Not-Allowed-This
• Nor-This_thing
• VeryVeryLongStringIndeed

I've tried the following regex string

[a-zA-Z^\\-_]+[\\-_]?[a-zA-Z^\\-_]*

and it seems to work. However, I'm not sure how to do the total character limiting part with this approach. I've also tried

[[a-zA-Z]+[\\-_]?[a-zA-Z]*]{1,14}

but it matches (for example) abc-cde_aa which it shouldn't.

Answer 1

This ought to work:

(?![_-])(?!(?:.*[_-]){2,})[A-Za-z_-]{1,14}

The regex is quite complex, let my try and explain it.

• (?![_-]) negative lookahead. From the start of the string assert that the first character is not _ or -. The negative lookahead "peeks" of the current position and checks that it doesn't match [_-] which is a character group containing _ and -.
• (?!(?:.*[_-]){2,}) another negative lookahead, this time matching (?:.*[_-]){2,} which is a non capturing group repeated at least two times. The group is .*[_-], it is any character followed by the same group as before. So we don't want to see some characters followed by _ or - more than once.
• [A-Za-z_-]{1,14} is the simple bit. It just says the characters in the group [A-Za-z_-] between 1 and 14 times.

The second part of the pattern is the most tricky, but is a very common trick. If you want to see a character A repeated at some point in the pattern at least X times you want to see the pattern .*A at least X times because you must have

zzzzAzzzzAzzzzA....

You don't care what else is there. So what you arrive at is (.*A){X,}. Now, you don't need to capture the group - this just slows down the engine. So we make the group non-capturing - (?:.*A){X,}.

What you have is that you only want to see the pattern once, so you want not to find the pattern repeated two or more times. Hence it slots into a negative lookahead.

Here is a testcase:

public static void main(String[] args) {
    final String pattern = "(?![_-])(?!(?:.*[_-]){2,})[A-Za-z_-]{1,14}";
    final String[] tests = {
            "Hello-Again",
            "ThisIsValid",
            "AlsoThis_",
            "_NotThis_",
            "-notvalid",
            "Not-Allow-This",
            "Nor-This_thing",
            "VeryVeryLongStringIndeed",
    };
    for (final String test : tests) {
        System.out.println(test.matches(pattern));
    }
}

Output:

true
true
true
false
false
false
false
false

Things to note:

1. the character - is special inside character groups. It must go at the start or end of a group otherwise it specifies a range
2. lookaround is tricky and often counter-intuitive. It will check for matches without consuming, allowing you to test multiple conditions on the same data.
3. the repetition quantifier {} is very useful. It has 3 states. {X} is repeated exactly X times. {X,} is repeated at least X times. And {X, Y} is repeated between X and Y times.

Answer 2

To check if string is in form XXX-XXX where -XXX or _XXX part is optional you can use

[a-zA-Z]+([-_][a-zA-Z]*)?

which is similar to what you already had

[[a-zA-Z]+[\\-_]?[a-zA-Z]*]

but you made crucial mistake and wrapped it entirely in [...] which makes it character class, and that is not what you wanted.

To check if matched part has only 1-14 length you can use look-ahead mechanism. Just place

(?=.{1,14}$)

at start of your regex to make sure that part from start of match till end of it (represented by $) contains of any 1-14 characters.

So your final regex can look like

String regex = "(?=.{1,14}$)[a-zA-Z]+([-_][a-zA-Z]*)?";

---

Demo

String [] data = {
    "Hello-Again",
    "ThisIsValid",
    "AlsoThis_",

    "-notvalid",
    "Not-Allowed-This",
    "Nor-This_thing",
    "VeryVeryLongStringIndeed",
};

for (String s : data)
    System.out.println(s + " : " + s.matches(regex));

Output:

Hello-Again : true
ThisIsValid : true
AlsoThis_ : true
-notvalid : false
Not-Allowed-This : false
Nor-This_thing : false
VeryVeryLongStringIndeed : false