HashMap Implementation to Count the Occurrences of Each Character in Java

1. Overview

Counting how many times each character appears in a string is a common and practical task in Java. Whether we’re processing user input, analyzing text, or solving algorithm problems, tracking character frequency is often a key step.

In this tutorial, we’ll explore a straightforward HashMap-based implementation to count the occurrences of each character in a given string.

2. Why Use HashMap?

The HashMap class in Java is a key-value data structure that allows constant-time retrieval and insertion in most cases.

For counting character frequencies, we can treat each unique character in a string as a key and its number of occurrences as the value. As we iterate through the string, we check if the character already exists in the map. If it does, we increment the value by one. If not, we add it with an initial count of one. This method provides an efficient way to record the occurrence of all characters in the string.

3. Implementation in Java

This section demonstrates two ways to count character occurrences in a string using a HashMap: one with a classic for-loop and another using Java Streams. Both approaches use a map internally to store and count characters, but differ in coding style and API usage.

3.1. Using a Simple for Loop

The most straightforward way is to iterate through each character in the string and update its count in a HashMap. This approach is easy to understand and efficient:

public static Map<Character, Integer> countCharactersWithLoop(String input) {
    Map<Character, Integer> characterCountMap = new HashMap<>();

    for (char ch : input.toCharArray()) {
        characterCountMap.put(ch, characterCountMap.getOrDefault(ch, 0) + 1);
    }

    return characterCountMap;
}

Our method takes a String input and returns a Map linking each character to its frequency. We start by initializing an empty HashMap where the keys are characters and the values are their counts.

Next, we convert the string to a character array and iterate over it. For each character, we use the map’s getOrDefault() method to get its current count (or 0 if absent), increment it by one, and update the map. Once the iteration is complete, the method returns the populated map with all character frequencies.

This straightforward and efficient approach counts every character, including spaces and punctuation, while treating uppercase and lowercase letters as distinct. It can also be easily adapted to ignore case or filter characters as needed.

3.2. Using Java Streams

Java Streams offer a more declarative way to count character occurrences by converting the string into a stream of characters and then grouping and counting them using Collectors. This approach can be more concise and expressive:

public static Map<Character, Integer> countCharactersWithStreams(String input) {
    return input.chars()
      .mapToObj(c -> (char) c)
      .collect(Collectors.groupingBy(
        Function.identity(),
        Collectors.collectingAndThen(Collectors.counting(), Long::intValue)
      ));
}

This method first converts the string into an IntStream of character codes using input.chars(), then maps each code to its corresponding Character object. The Collectors.groupingBy() operation groups identical characters together, while Collectors.counting() counts how many times each character appears.

Since counting() produces a Long, we apply collectingAndThen() with Long::intValue to convert the result to Integer, making the return type consistent with the loop-based method. Like the previous approach, this implementation treats uppercase and lowercase characters as distinct and includes all characters, including spaces and punctuation.

The Stream API provides a clean and functional alternative to traditional iteration, especially useful when working with larger pipelines or more complex data transformations.

4. Verifying With a Unit Test

Let’s look at two JUnit tests to verify that both countCharactersWithLoop() and countCharactersWithStreams() methods produce the correct output for a simple input string:

@Test
public void givenSimpleInput_whenCountingCharactersWithLoop_thenReturnsCorrectFrequencies() {
    String input = "test";
    Map<Character, Integer> result = CharacterFrequencyCounter.countCharactersWithLoop(input);

    assertEquals(Integer.valueOf(2), result.get('t'));
    assertEquals(Integer.valueOf(1), result.get('e'));
    assertEquals(Integer.valueOf(1), result.get('s'));
    assertEquals(3, result.size());
}

@Test
public void givenSimpleInput_whenCountingCharactersWithStreams_thenReturnsCorrectFrequencies() {
    String input = "test";
    Map<Character, Integer> result = CharacterFrequencyCounter.countCharactersWithStreams(input);

    assertEquals(Integer.valueOf(2), result.get('t'));
    assertEquals(Integer.valueOf(1), result.get('e'));
    assertEquals(Integer.valueOf(1), result.get('s'));
    assertEquals(3, result.size());
}

Both tests use the same input string “test” and verify that each character is counted correctly. They confirm that the character ‘t’ appears twice, while ‘e’ and ‘s’ appear once each. Additionally, both maps contain exactly three entries, ensuring no extra characters are included.

These tests validate the core functionality of both approaches, demonstrating that they produce equivalent and accurate results.

5. Conclusion

In this article, we learned two ways to count the frequency of characters in a string using a HashMap in Java: a classic for-loop approach and a more concise solution using Java Streams. Both methods efficiently map each character to its number of occurrences and handle all characters, including spaces and punctuation.

These approaches offer a solid foundation for character frequency analysis and can be adapted to suit various text-processing needs.