How to match special characters such as ^ and \ without using indexOf()?

I am trying to match a string if it is a valid "unit" in my program.

Valid units consists of:

At least one letter, optional / or -, at least one more letter if you did the optional / or -

Current attempt: str.matches("[a-zA-z]*[-\\/]?[a-zA-z]*")

Example:

Valid -> abc/abc
Valid -> abc
Invalid -> abc^abc
Invalid -> abc/abc

The invalid cases are showing as valid.

Try this:

str.matches("(?i)[a-z]+([-/][a-z]+)?")

Notes:

• (?i) switchs on case insensitive matching, so you can code [a-z] instead of [a-zA-Z], so it's easier to read
• + means "one or more"
• you do not ever need to escape /. It has no special regex meaning - it's just a plain old ordinary character
• (...)? means everythinig in the brackets is optional. That's how you make the "dash/slash plus letter(s)" expression optional as a whole

Try the following Regex:

"[a-zA-z]+[-|\\/]{1}[a-zA-z]+"

Try this to look for one and only one '-' or '/' character that is between at least one character on each side of it:

str.matches("[a-zA-z]{1,}[-\\/]{1}[a-zA-z]{1,}")

Answer to updated question (version 3):

str.matches("[a-zA-Z]+(?:[-/][a-zA-Z]+)?")

Explanation

> At least one letter

[a-zA-Z]+

> optional ... if you did the optional / or -

(?:X)? or (X)?

Both work, but the first is non-capturing, and since you don't need capturing, it is the more appropriate one to use.

> / or -

[-/]

> at least one more letter

[a-zA-Z]+

Test

public static void main(String[] args) {
    test("abc/abc", "abc", "abc^abc", "abc\\abc");
}
static void test(String... inputs) {
    for (String input : inputs)
        System.out.println((input.matches("[a-zA-Z]+(?:[-/][a-zA-Z]+)?") ? "Valid" : "Invalid") + " -> " + input);
}

Output

Valid -> abc/abc
Valid -> abc
Invalid -> abc^abc
Invalid -> abc\abc

From comment:

> That's better, but it's failing when I try: abc\abc or abc^abc as the string. I think it has to do with those characters being used by regex as well.

Well, those are supposed to fail according to the listed rule.

If you meant that you want to modify the rule to also allow \ and ^, then you need to add them inside the [ ].

But, you need to be aware of special characters inside [ ]:

• - is special, indicating a range, e.g. a-z, but not special if first or last. Escape with \ if not first or last. Double the \ when in a Java string literal to \\.

• ^ is special if first, meaning to reverse the list, e.g. [^a-z] means "not a lowercase letter`.

• \ is always special, since it is the escape character, so you need to escape it as \\, and doubling them when in a Java string literal to \\\\.

Which means:

str.matches("[a-zA-Z]+(?:[-/^\\\\][a-zA-Z]+)?")

Test Output

Valid -> abc/abc
Valid -> abc
Valid -> abc^abc
Valid -> abc\abc
Invalid -> abc#abc