Find the Number of Occurrences of a Substring in a String

Apache Commons Lang to the rescue

For cleaner and more understandable code, use StringUtils.countMatches from Apache Commons Lang. This existing method strips the complexities:

public int countOccurrences(String str, String sub) {
    //Put StringUtils to work. Let's save those keystrokes.
    return StringUtils.countMatches(str, sub);
}


Before leaping into this, remember to include the Apache Commons library in your project dependencies.

Fancy Stream and regex approach

Exploit Java Streams and regular expressions to gain more fine control:

public long countOccurrencesWithStream(String str, String regex) {
    Pattern pattern = Pattern.compile(regex);
    // Streams and regex - the dynamic duo
    return pattern.splitAsStream(str).count() - 1;
}


With this approach, double-check that the regex is formatted and escaped.

Always update your index

Properly updating the index after each match ensures that you avoid infinite loops and keep away from the stormy seas of errors. If the lastIndex is -1, throw a lifebuoy, and don't proceed.

The split trick

The split method with a negative limit is an undercover agent:

public int countOccurrencesWithSplit(String str, String sub) {
    // Split's got your back 🕵️‍
    return str.split(Pattern.quote(sub), -1).length - 1;
}


Manual iteration, who? Not with split. Subtract one because the initial split isn't a match.

Accurate algorithm validation

Ensure your method hits the target every single time. Test it with different cases: edge cases, no matches, empty strings, substrings at the start or end of the string – everything.

Performance deliberations

Spaghetti code isn't the tastiest. Find a method that balances simple, readable and performant. Sure, StringUtils and regex solutions are often more digestible, but large strings or complex patterns may slow them down.

Efficiency meets readability

Writing your algorithm, remember that built-in methods can provide the perfect mix of readability and efficiency, starving off unnecessarily complex loops.