Java Check a String for Lowercase/Uppercase Letter, Special Character and Digit

1. Overview

In this quick tutorial, we’ll illustrate how we can check if a String is containing at least one of each of the following: uppercase letter, lowercase letter, digit or special character in Java.

2. Using Regular Expressions

One of the ways to perform our check is by using regular expressions. To get familiar with regular expressions, please check out this article.

First of all, let’s define the regular expression for each of the required character groups. Since regular expressions are fixed, there is no need to evaluate them at each run, so we’ll compile them before we compare against them:

private static final Pattern[] inputRegexes = new Pattern[4];

static {
    inputRegexes[0] = Pattern.compile(".*[A-Z].*");
    inputRegexes[1] = Pattern.compile(".*[a-z].*");
    inputRegexes[2] = Pattern.compile(".*\\d.*");
    inputRegexes[3] = Pattern.compile(".*[`~!@#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",<.>/?].*");
}

Also, we should create a simple method that we’re going to use to test if our String matches the conditions:

private static boolean isMatchingRegex(String input) {
    boolean inputMatches = true;
    for (Pattern inputRegex : inputRegexes) {
        if (!inputRegex.matcher(input).matches()) {
            inputMatches = false;
        }
    }
    return inputMatches;
}

2.1. Single Regular Expression

The previous example is pretty readable and allows us to use only some of the patterns easily if necessary. But, in a case where we care only about fulfilling all of the conditions, it is much more efficient to use a single regular expression.

That way we wouldn’t need a static block to initialize and compile all of our multiple expressions. Also, there would be no need to iterate over all of them and find which matches and which don’t.

All we need to do is to declare our regex:

String regex = "^(?=.*?\\p{Lu})(?=.*?\\p{Ll})(?=.*?\\d)" +
    "(?=.*?[`~!@#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",<.>/?]).*$";

And then compile and compare it:

@Test
public void givenSingleRegex_whenMatchingCorrectString_thenMatches() {
    String validInput = "Ab3;";
    assertTrue(Pattern.compile(regex).matcher(validInput).matches());
}

There are a few things we should point out regarding our regular expression.

First, we’ve used positive lookahead (?=X) for every group of characters. That means that we expect X to be found after the beginning of the String (marked with ^) in order to match, but we don’t want to go to the end of X, rather we want to stay at the beginning of the line.

Another thing to notice is that this time we didn’t use [A-Z] or [a-z] for letter groups, but \p{Lu} and \p{Ll} instead. These will match any kind of letter (in our case, uppercase and lowercase respectively) from any language, not only English.

3. Using Core Java

Let’s now see how we can perform the same check if we don’t want to use regular expressions. We’ll take advantage of Character and String classes and their methods to check if all required characters are present in our String:

private static boolean checkString(String input) {
    String specialChars = "~`!@#$%^&*()-_=+\\|[{]};:'\",<.>/?";
    char currentCharacter;
    boolean numberPresent = false;
    boolean upperCasePresent = false;
    boolean lowerCasePresent = false;
    boolean specialCharacterPresent = false;

    for (int i = 0; i < input.length(); i++) {
        currentCharacter = input.charAt(i);
        if (Character.isDigit(currentCharacter)) {
            numberPresent = true;
        } else if (Character.isUpperCase(currentCharacter)) {
            upperCasePresent = true;
        } else if (Character.isLowerCase(currentCharacter)) {
            lowerCasePresent = true;
        } else if (specialChars.contains(String.valueOf(currentCharacter))) {
            specialCharacterPresent = true;
        }
    }

    return
      numberPresent && upperCasePresent && lowerCasePresent && specialCharacterPresent;
}

We should note a few things here. Basic idea is that we iterate through our String and check if its characters are of required types. By using Character class, we can easily check if a certain character is a digit, an uppercase or a lowercase character.

Unfortunately, there is no similar method that would tell us if we’re dealing with one of the special characters. So, it means that we need to take another approach.

We’ve created a String containing all special characters we need and then checked if it contains our specific character.

4. Conclusion

In this quick article, we’ve shown how to check if a String contains required characters. In the first scenario, we used regular expressions while in the second we took advantage of core Java classes.