1. Overview
When working with String types in Java, it’s often necessary to analyze the composition of the characters within them. One common task is counting the number of uppercase and lowercase letters in a given String.
In this tutorial, we’ll explore several simple and practical approaches to achieve this using Java.
2. Introduction to the Problem
Before diving into the code, let’s first clarify the problem at hand. We want to create a Java method that takes a String as input and counts the number of uppercase and lowercase letters simultaneously. In other words, the solution will produce a result containing two counters.
For example, we’ll take the following String as the input:
static final String MY_STRING = "Hi, Welcome to Baeldung! Let's count letters!";
Uppercase letters are characters from ‘A‘ to ‘Z‘, and lowercase letters are characters from ‘a‘ to ‘z‘. That is to say, special characters such as ‘,’ and ‘!’ within the example String are considered neither uppercase nor lowercase letters.
Looking at the example, we have four uppercase letters and 31 lowercase letters in MY_STRING.
Since we’ll calculate two counters simultaneously, let’s create a simple result class to carry the two counters so that we can verify the outcome more easily:
class LetterCount {
private int uppercaseCount;
private int lowercaseCount;
private LetterCount(int uppercaseCount, int lowercaseCount) {
this.uppercaseCount = uppercaseCount;
this.lowercaseCount = lowercaseCount;
}
public int getUppercaseCount() {
return uppercaseCount;
}
public int getLowercaseCount() {
return lowercaseCount;
}
// ... counting solutions come later ...
}
Later, we’ll add counting solutions as static methods to this class.
So, if an approach correctly counts the letters, it should produce a LetterCount object with uppercaseCount = 4 and lowercaseCount = 31.
Next, let’s count letters.
3. Using Character Ranges
To solve this problem, we’ll iterate through each character in the given String and determine whether it’s an uppercase or lowercase letter by checking if it falls in one of the corresponding character ranges:
static LetterCount countByCharacterRange(String input) {
int upperCount = 0;
int lowerCount = 0;
for (char c : input.toCharArray()) {
if (c >= 'A' && c <= 'Z') {
upperCount++;
}
if (c >= 'a' && c <= 'z') {
lowerCount++;
}
}
return new LetterCount(upperCount, lowerCount);
}
As the code above shows, we maintain separate counters for uppercase and lowercase letters and increment them accordingly during iteration. After walking through the input String, we create the LetterCount object using the two counters and return it as the result:
LetterCount result = LetterCount.countByCharacterRange(MY_STRING);
assertEquals(4, result.getUppercaseCount());
assertEquals(31, result.getLowercaseCount());
It’s worth noting that this approach is only applicable to String inputs consisting of ASCII characters.
4. Using the isUpperCase() and isLowerCase() Methods
In the previous solution, we determine if a character is an uppercase or lowercase letter by checking its range. Actually, the Character class has provided the isUpperCase() and isLowerCase() methods for this check.
It’s important to highlight that isUpperCase() and isLowerCase() also work with Unicode characters:
assertTrue(Character.isLowerCase('ä'));
assertTrue(Character.isUpperCase('Ä'));
So, let’s replace the range checks with the case-checking methods from the Character class:
static LetterCount countByCharacterIsUpperLower(String input) {
int upperCount = 0;
int lowerCount = 0;
for (char c : input.toCharArray()) {
if (Character.isUpperCase(c)) {
upperCount++;
}
if (Character.isLowerCase(c)) {
lowerCount++;
}
}
return new LetterCount(upperCount, lowerCount);
}
As we can see, the two case-checking methods make the code easier to understand, and they produce the expected result:
LetterCount result = LetterCount.countByCharacterIsUpperLower(MY_STRING);
assertEquals(4, result.getUppercaseCount());
assertEquals(31, result.getLowercaseCount());
5. Using the Stream API’s filter() and count() Methods
The Stream API stands out as a significant feature introduced in Java 8.
Next, let’s solve this problem using filter() and count() from the Stream API:
static LetterCount countByStreamAPI(String input) {
return new LetterCount(
(int) input.chars().filter(Character::isUpperCase).count(),
(int) input.chars().filter(Character::isLowerCase).count()
);
}
As the count() method returns a long value, we must cast it to an int to instantiate the LetterCount object.
It may appear at first glance that this solution is straightforward and much more compact than the other loop-based approaches. However, it’s worth noting that this approach walks through the characters in the input String twice.
Finally, let’s write a test to verify if this approach yields the expected result:
LetterCount result = LetterCount.countByStreamAPI(MY_STRING);
assertEquals(4, result.getUppercaseCount());
assertEquals(31, result.getLowercaseCount());
6. Conclusion
In this article, we’ve explored different approaches to counting uppercase and lowercase letters in a given String.
These simple yet effective approaches provide a foundation for more complex String analysis tasks in real-world work.
As always, the complete source code for the examples is available over on GitHub.
