Java 8 – Count Duplicate Characters in a String

Introduction

Counting duplicate characters in a string is a fundamental task in programming, particularly in text processing and data analysis. Whether you’re dealing with user input, parsing text files, or analyzing data streams, identifying characters that appear more than once can provide valuable insights. With the introduction of Java 8, counting these duplicates has become more efficient and concise, using the power of Stream API.

In this guide, we’ll walk you through creating a Java program that counts how often each character appears in a string and identifies those that occur more than once. This approach is efficient and leverages the modern features of Java 8 to make your code more readable and maintainable.

Problem Statement

The goal is to create a Java program that performs the following tasks:

• Accepts a string as input – hardcode or read from the console.
• Utilizes Java 8 Streams to process the string and count the occurrences of each character.
• Filters the results to display only the characters that appear more than once, along with their respective counts.

Example:

• Input: "programming"
• Output: Character: g, Count: 2; Character: r, Count: 2; Character: m, Count: 2

Example 2:

• Input: "Java programming language"
• Output: Character: a, Count: 4; Character: g, Count: 3; Character: r, Count: 2; Character: m, Count: 2

Solution Steps

To solve this problem, we’ll break down the solution into a few clear steps:

1. Input String: Start with a string that can either be hard-coded or provided by the user at runtime. This string will contain the characters you want to analyze.
2. Stream Processing: Convert the string into a stream of characters using the chars() method. This stream allows you to leverage the Collectors.groupingBy method, which groups the characters and counts their occurrences.
3. Filtering Results: Once you have a map of characters and their counts, filter out the characters that appear only once. Display the characters that have a count greater than one.
4. Displaying the Output: Finally, present the results to the user in a readable format, showing each duplicate character and its count.

Java 8 Program to Count Duplicate Characters in a String

Here is the complete Java program that accomplishes the task:

import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Java 8 Program to Count Duplicate Characters in a String
 * Author: https://www.rameshfadatare.com/
 */
public class DuplicateCharacterCount {

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

        // Step 2: Count characters using Java 8 streams
        Map<Character, Long> characterCount = input.chars()
                .mapToObj(c -> (char) c)
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        // Step 3: Filter and display duplicate characters
        characterCount.entrySet().stream()
                .filter(entry -> entry.getValue() > 1)
                .forEach(entry -> System.out.println("Character: " + entry.getKey() + ", Count: " + entry.getValue()));
    }
}

Explanation of the Program

• Input Handling: The program uses a predefined string, "programming", as input. You can modify this to accept user input if needed.
• Stream Processing: The chars() method is used to create an IntStream from the string. Each integer in this stream represents a character’s ASCII value. The stream is then converted into a stream of Character objects using mapToObj.
• Grouping and Counting: The Collectors.groupingBy method groups each character and uses Collectors.counting() to count how many times each character appears.
• Filtering and Output: The filter method removes characters that appear only once. The remaining characters, those that are duplicates, are printed along with their counts.

Output Example

Running the program with different input strings will produce the following results:

Example 1:

Input: programming
Output:
Character: g, Count: 2
Character: r, Count: 2
Character: m, Count: 2

Example 2:

Input: Java programming language
Output:
Character: a, Count: 4
Character: g, Count: 3
Character: r, Count: 2
Character: m, Count: 2

Advanced Usage and Considerations

1. Case Sensitivity: The program is case-sensitive, meaning A and a are considered different characters. To make it case-insensitive, you can convert the string to lowercase using input.toLowerCase() before processing.
2. Handling Special Characters: The program counts all characters, including spaces and punctuation. You can modify the code to exclude non-alphabetic characters by adding a filter step in the stream processing.
3. Performance Considerations: For very large strings, the performance of the program remains efficient due to the use of streams, which can be parallelized if needed using parallelStream().

Conclusion

This Java 8 program efficiently counts and identifies duplicate characters in a string. By leveraging Java 8’s stream API, the solution is concise and powerful, suitable for a wide range of applications in text processing and data analysis. Whether you’re building a simple utility or a more complex system, understanding and implementing character frequency analysis is a valuable skill. This approach also highlights the importance of functional programming in modern Java development, providing clarity and code efficiency.

By following this guide, you now have a solid foundation for counting duplicate characters in a string using Java 8. This method can be easily adapted to various use cases, making your applications more robust and feature-rich.