Check if a String Is All Uppercase or Lowercase in Java

1. Overview

When working with strings in Java, determining whether a string consists entirely of uppercase or lowercase characters is often necessary.

In this tutorial, we’ll explore different approaches to performing the check.

2. Introduction to the Problem

First, let’s prepare three input strings:

static final String UPPER_INPUT = "1: COOL!";
static final String LOWER_INPUT = "2: cool!";
static final String MIXED_INPUT = "3: Cool!";

As we can see, each string above contains a space and two punctuation characters. Whether non-letter characters, such as digits and punctuation, belong to upper/lowercase depends on the requirement. In this tutorial, we consider non-letter characters are both uppercase and lowercase characters.

We’ll create static checking methods in the CaseCheck class:

class CaseChecker {
    static boolean allUpperX(String input){...}
    static boolean allLowerX(String input){...}
    ...
}

We can easily perform these checks and handle various use cases by leveraging the power of Java’s String class and character manipulation.

For simplicity, we’ll use unit test assertions to verify whether each approach returns the expected result.

Now, let’s dive in!

3. Converting and Comparing

We know that the String class offers us two methods: toUpperCase() and toLowerCase(). If a string’s (s) characters are in uppercase, then the string (s) must equal the result of s.toUpperCase(). Therefore, following this idea, let’s create two check methods, one for uppercase check and the other one for lowercase check:

static boolean allUpper1(String input) {
    return input.equals(input.toUpperCase());
}

static boolean allLower1(String input) {
    return input.equals(input.toLowerCase());
}

Next, let’s test the methods using our prepared input strings:

assertTrue(CaseChecker.allLower1(LOWER_INPUT));
assertFalse(CaseChecker.allLower1(UPPER_INPUT));
assertFalse(CaseChecker.allLower1(MIXED_INPUT));

assertFalse(CaseChecker.allUpper1(LOWER_INPUT));
assertTrue(CaseChecker.allUpper1(UPPER_INPUT));
assertFalse(CaseChecker.allUpper1(MIXED_INPUT));

The test passes if we execute it. So the check methods solved the problem.

4. Checking Each Character

Although we successfully addressed the problem using the converting and comparing approach, such as input.equals(input.toUpperCase()), this method may not be optimal when dealing with long input strings. It converts each character’s case. Consequently, this process can become time-consuming and potentially unnecessary for lengthy input strings.

Another idea is walking through the characters in the input string. We can determine the result once we detect a character that isn’t upper/lowercase. So we can skip any further checking.

We can use String.toCharArray() to break a string into a char array. Also, the Character.isLowerCase() and Character.isUpperCase() methods can tell us if a char is a lower/uppercase character.

Next, let’s combine these two methods and create our check methods:

static boolean allUpper2(String input) {
    for (char c : input.toCharArray()) {
        //  don't write in this way: if (!Character.isUpperCase(c))
        if (Character.isLowerCase(c)) {
            return false;
        }
    }
    return true;
}

static boolean allLower2(String input) {
    for (char c : input.toCharArray()) {
        //  don't write in this way: if (!Character.isLowerCase(c))
        if (Character.isUpperCase(c)) {
            return false;
        }
    }
    return true;
}

The implementation isn’t hard to understand. However, one may wonder about the comments in the code above. For example, in allUpper2(), why shouldn’t we write “if (!Character.isUpperCase(c)) return false;”?

This is because given any non-letter character, such as ‘.’ or ‘7’, both Character.isUpperCase() and isLowerCase() return false. But in accordance with the requirement, we need to disregard non-letter characters in our upper/lowercase checking logic. Thus, it’s more appropriate to employ “if (Character.isLowerCase(c)) return false;” instead of “if (!Character.isUpperCase(c)) return false;”

The test shows that our checking methods do the job too:

assertTrue(CaseChecker.allLower2(LOWER_INPUT));
assertFalse(CaseChecker.allLower2(UPPER_INPUT));
assertFalse(CaseChecker.allLower2(MIXED_INPUT));

assertFalse(CaseChecker.allUpper2(LOWER_INPUT));
assertTrue(CaseChecker.allUpper2(UPPER_INPUT));
assertFalse(CaseChecker.allUpper2(MIXED_INPUT));

Alternatively, we can implement the same logic using the Stream API:

static boolean allUpper3(String input) {
    return input.chars().noneMatch(Character::isLowerCase);
}

static boolean allLower3(String input) {
    return input.chars().noneMatch(Character::isUpperCase);
}

5. A Word About the StringUtils From the Apache Commons Lang 3 Library

Apache Commons Lang 3 provides the convenient StringUtils class. This utility class has two methods: isAllLowerCase() and isAllUpperCase().

It’s worth noting that these methods consider non-letter characters, neither uppercase nor lowercase:

assertFalse(StringUtils.isAllLowerCase(LOWER_INPUT));
assertFalse(StringUtils.isAllLowerCase(UPPER_INPUT));
assertFalse(StringUtils.isAllLowerCase(MIXED_INPUT));

assertFalse(StringUtils.isAllLowerCase("a b"));
assertTrue(StringUtils.isAllLowerCase("ab"));

assertFalse(StringUtils.isAllUpperCase(LOWER_INPUT));
assertFalse(StringUtils.isAllUpperCase(UPPER_INPUT));
assertFalse(StringUtils.isAllUpperCase(MIXED_INPUT));

assertFalse(StringUtils.isAllUpperCase("A B"));
assertTrue(StringUtils.isAllUpperCase("AB"));

We should keep it in mind when we use them.

6. Conclusion

In this article, we’ve explored different approaches to check if a string is all uppercase or lowercase in Java. The converting and comparing approach is straightforward. But we may want to check through the characters and bail out earlier to gain better performance if the input string is long.