
Baeldung Pro comes with both absolutely No-Ads as well as finally with Dark Mode, for a clean learning experience:
Once the early-adopter seats are all used, the price will go up and stay at $33/year.
There are many ways to count the number of occurrences of a char in a String in Java.
In this quick tutorial, we’ll focus on a few examples of how to count characters — first with the core Java library and then with other libraries and frameworks such as Spring and Guava.
Some developers may prefer to use core Java. There are many ways for counting the number of occurrences of a char in a String.
Let’s start with a simple/naive approach:
String someString = "elephant";
char someChar = 'e';
int count = 0;
for (int i = 0; i < someString.length(); i++) {
if (someString.charAt(i) == someChar) {
count++;
}
}
assertEquals(2, count);
Not surprisingly, this will work, but there are better ways to do this.
A less obvious but still interesting solution is to use recursion:
private static int useRecursion(
String someString, char searchedChar, int index) {
if (index >= someString.length()) {
return 0;
}
int count = someString.charAt(index) == searchedChar ? 1 : 0;
return count + useRecursion(
someString, searchedChar, index + 1);
}
We can invoke this recursive method in the following way: useRecursionToCountChars(“elephant”, ‘e’, 0).
Another way would be to use regular expressions:
Pattern pattern = Pattern.compile("[^e]*e");
Matcher matcher = pattern.matcher("elephant");
int count = 0;
while (matcher.find()) {
count++;
}
assertEquals(2, count);
Just note that this solution is technically correct but sub-optimal, as it’s overkill to use the very powerful regular expressions to solve such a simple problem as finding the number of occurrences of a character in a string.
New features available in Java 8 can be very helpful here.
Let’s use streams and lambdas to implement the count:
String someString = "elephant";
long count = someString.chars().filter(ch -> ch == 'e').count();
assertEquals(2, count);
long count2 = someString.codePoints().filter(ch -> ch == 'e').count();
assertEquals(2, count2);
So, this is clearly a cleaner and more readable solution using the core library.
Let’s now look at a few solutions that make use of utilities from external libraries.
In general, it is always better to use an existing solution instead of inventing our own. The commons.lang.StringUtils class provides us with the countMatches() method, which can be used for counting chars or even sub-strings in given String.
First, we need to include the appropriate dependency:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
We can find the latest version on Maven Central.
Let’s now use countMatches() to count the number of e characters in the “elephant” String literal:
int count = StringUtils.countMatches("elephant", "e");
assertEquals(2, count);
Guava can also be helpful in counting chars. We need to define the dependency:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>31.0.1-jre</version>
</dependency>
We can find the latest version on Maven Central.
Let’s see how Guava can quickly help us to count chars:
int count = CharMatcher.is('e').countIn("elephant");
assertEquals(2, count);
Naturally, adding the Spring Framework into our project just to count chars doesn’t make sense.
However, if we already have it in our project, we just need to use the countOccurencesOf() method:
int count = StringUtils.countOccurrencesOf("elephant", "e");
assertEquals(2, count);
In this article, we focused on various ways to count chars in the String. Some of them were designed purely in Java; some required additional libraries.
Our recommendation is to use already existing utilities from StringUtils, Guava or Spring. However, this article offers some possibilities to get it done with Java 8 if using only plain Java is preferred.