Java 8 – Count the Occurrences of Each Character Using HashMap

Introduction

Counting the occurrences of each character in a string is a fundamental task in text processing, useful in scenarios like data analysis, text compression, and cryptography. A HashMap is an ideal data structure for this task, as it allows us to store characters as keys and their counts as values. With Java 8, you can use Streams to make this process even more concise and efficient. In this guide, we’ll explore how to count the occurrences of each character in a string using a HashMap in both the traditional approach and with Java 8 features.

Problem Statement

The task is to create a Java program that:

• Accepts a string as input.
• Uses a HashMap to count the occurrences of each character in the string.
• Outputs the character counts.

Example 1:

• Input: "hello world"
• Output: h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1

Example 2:

• Input: "Java"
• Output: J: 1, a: 2, v: 1

Solution Steps

1. Input String: Start with a string that can either be hardcoded or provided by the user.
2. Count Character Occurrences (Traditional Approach): Use a HashMap to store characters and their counts by iterating over the string.
3. Count Character Occurrences (Java 8 Streams): Use Java 8 Streams to create and populate the HashMap.
4. Display the Result: Print the character counts stored in the HashMap.

Java Program

Traditional Approach: Count the Occurrences of Each Character Using HashMap

import java.util.HashMap;
import java.util.Map;

/**
 * Traditional Approach: Count the Occurrences of Each Character Using HashMap
 * Author: https://www.rameshfadatare.com/
 */
public class CharacterCountTraditional {

    public static void main(String[] args) {
        // Step 1: Take input string
        String input = "hello world";

        // Step 2: Count character occurrences using traditional approach
        Map<Character, Integer> characterCountMap = countCharactersTraditional(input);

        // Step 3: Display the result
        characterCountMap.forEach((character, count) -> 
            System.out.println(character + ": " + count)
        );
    }

    // Method to count the occurrences of each character in a string (traditional approach)
    public static Map<Character, Integer> countCharactersTraditional(String str) {
        Map<Character, Integer> characterCountMap = new HashMap<>();

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

        return characterCountMap;
    }
}

Java 8 Approach: Count the Occurrences of Each Character Using HashMap

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Java 8: Count the Occurrences of Each Character Using HashMap
 * Author: https://www.rameshfadatare.com/
 */
public class CharacterCountJava8 {

    public static void main(String[] args) {
        // Step 1: Take input string
        String input = "Java";

        // Step 2: Count character occurrences using Java 8 Streams
        Map<Character, Long> characterCountMap = countCharactersJava8(input);

        // Step 3: Display the result
        characterCountMap.forEach((character, count) -> 
            System.out.println(character + ": " + count)
        );
    }

    // Method to count the occurrences of each character in a string (Java 8 Streams approach)
    public static Map<Character, Long> countCharactersJava8(String str) {
        return str.chars()
                  .mapToObj(c -> (char) c)
                  .collect(Collectors.groupingBy(c -> c, Collectors.counting()));
    }
}

Explanation of the Programs

• Traditional Approach: The first program uses a for loop to iterate over the characters in the string. For each character, it checks if the character is already present in the HashMap. If it is, the program increments the count. If it isn’t, it adds the character to the map with a count of one.

• Java 8 Approach: The second program uses the Stream API. The chars() method converts the string into an IntStream of character codes. The mapToObj() method converts these codes back to Character objects. The Collectors.groupingBy() method groups the characters and counts their occurrences, collecting the result into a HashMap.

Output Example

For both methods, the output will be:

Example 1:

Input: hello world
Output: 
h: 1
e: 1
l: 3
o: 2
 : 1
w: 1
r: 1
d: 1

Example 2:

Input: Java
Output: 
J: 1
a: 2
v: 1

Advanced Considerations

1. Case Sensitivity: The programs treat uppercase and lowercase characters as distinct. For example, ‘a’ and ‘A’ would be counted separately. If you want case-insensitive counting, you can convert the string to lowercase using str.toLowerCase() before processing.

2. Handling Special Characters: Both methods count all characters, including spaces and punctuation. If you want to exclude certain characters, you can add additional filtering logic.

3. Performance Considerations: Both methods are efficient for typical string lengths. The traditional method is straightforward and easy to understand, while the Java 8 approach offers a more concise and functional solution.

Conclusion

This guide provides two methods for counting the occurrences of each character in a string using a HashMap: the traditional approach using loops and a more modern approach using Java 8 Streams. Both methods are effective, but the Java 8 approach offers a more functional and concise solution. Depending on your needs and the style of your codebase, either method can be used to achieve the desired result.