How to check if a String has at least one capital letter in Java

Checking if a string contains at least one capital letter is a common requirement in Java programming. This is especially relevant in scenarios like validating passwords, formatting user inputs, or implementing security checks. In Java 21, there are several efficient ways to achieve this, each with its own advantages.

In this article, we will explore different approaches to checking whether a string contains at least one uppercase letter, compare their performance, and discuss when to use each method.

Using Regular Expressions (Regex)

Regular expressions are a powerful tool for string pattern matching, and Java's String.matches() method makes it simple to check for capital letters.

public class CapitalLetterCheck {
    public static boolean hasCapitalLetter(String str) {
        return str.matches(".*[A-Z].*");
    }
    
    public static void main(String[] args) {
        System.out.println(hasCapitalLetter("hello")); // false
        System.out.println(hasCapitalLetter("Hello")); // true
        System.out.println(hasCapitalLetter("HELLO")); // true
    }
}

Pros:

• Concise and easy to understand.
• No need for loops or additional logic.

Cons:

• Uses regex, which can be less efficient for long strings.
• matches() checks the entire string, even if an uppercase letter is found early.

Using chars() and anyMatch() (Java Streams)

Java 8 introduced the chars() method, which allows us to process each character in a String as an IntStream. The anyMatch() method provides an efficient way to check for at least one uppercase letter.

public class CapitalLetterCheck {
    public static boolean hasCapitalLetter(String str) {
        return str.chars().anyMatch(Character::isUpperCase);
    }
    
    public static void main(String[] args) {
        System.out.println(hasCapitalLetter("hello")); // false
        System.out.println(hasCapitalLetter("Hello")); // true
        System.out.println(hasCapitalLetter("HELLO")); // true
    }
}

Pros:

• Stops processing as soon as an uppercase letter is found (efficient for long strings).
• Readable and functional-style.

Cons:

• Slightly less intuitive for beginners.
• Requires Java 8 or later.

Using a Traditional for Loop

If you prefer a straightforward, imperative approach, a simple for loop is an excellent choice.

public class CapitalLetterCheck {
    public static boolean hasCapitalLetter(String str) {
        for (char c : str.toCharArray()) {
            if (Character.isUpperCase(c)) {
                return true;
            }
        }
        return false;
    }
    
    public static void main(String[] args) {
        System.out.println(hasCapitalLetter("hello")); // false
        System.out.println(hasCapitalLetter("Hello")); // true
        System.out.println(hasCapitalLetter("HELLO")); // true
    }
}

Pros:

• More performant than regex.
• Easy to understand and does not require Java Streams.

Cons:

• Requires more boilerplate code compared to the chars().anyMatch() approach.

Using findAny() with Streams

An alternative to anyMatch() is filter().findAny(), which stops processing once a match is found.

public class CapitalLetterCheck {
    public static boolean hasCapitalLetter(String str) {
        return str.chars()
                  .filter(Character::isUpperCase)
                  .findAny()
                  .isPresent();
    }
    
    public static void main(String[] args) {
        System.out.println(hasCapitalLetter("hello")); // false
        System.out.println(hasCapitalLetter("Hello")); // true
        System.out.println(hasCapitalLetter("HELLO")); // true
    }
}

Pros:

• Stops execution early.
• More declarative than a for loop.

Cons:

• Slightly more verbose than anyMatch().

Using Pattern and Matcher

For situations where regex is preferred but performance is a concern, using Pattern and Matcher can be more efficient than matches() since it allows partial matching.

import java.util.regex.*;

public class CapitalLetterCheck {
    public static boolean hasCapitalLetter(String str) {
        Pattern pattern = Pattern.compile("[A-Z]");
        Matcher matcher = pattern.matcher(str);
        return matcher.find();
    }
    
    public static void main(String[] args) {
        System.out.println(hasCapitalLetter("hello")); // false
        System.out.println(hasCapitalLetter("Hello")); // true
        System.out.println(hasCapitalLetter("HELLO")); // true
    }
}

Pros:

• More efficient than matches() for large strings.

Cons:

• Requires knowledge of Java’s Pattern and Matcher APIs.

Performance Comparison

To compare these methods, let's test them with a long string:

public class PerformanceTest {
    public static void main(String[] args) {
        String testString = "a".repeat(1_000_000) + "Z"; // Long string with a capital letter at the end
        
        long startTime = System.nanoTime();
        boolean result = hasCapitalLetter(testString);
        long endTime = System.nanoTime();
        
        System.out.println("Result: " + result);
        System.out.println("Execution Time: " + (endTime - startTime) / 1_000_000.0 + " ms");
    }
    
    public static boolean hasCapitalLetter(String str) {
        return str.chars().anyMatch(Character::isUpperCase);
    }
}

Expected Results

Regex (matches()): Slowest due to scanning the entire string.

chars().anyMatch(): Fastest due to early termination.

for loop: Similar performance to anyMatch().

Pattern.matcher().find(): Faster than matches() but still slower than anyMatch().

Conclusion

• Best for Performance: chars().anyMatch(Character::isUpperCase).
• Best for Readability: matches(".*[A-Z].*").
• Best for Compatibility (Older Java versions): Traditional for loop.
• Best for Regex Enthusiasts: Pattern.matcher().find().

For most use cases, chars().anyMatch(Character::isUpperCase) is the recommended approach as it combines performance with readability. However, if regex is preferred, Pattern.matcher().find() is a better choice over matches() for large strings.

By choosing the right approach, you can ensure your code is both efficient and maintainable!