Java 8 – Find the First Non-Repeated Character in a String

Introduction

Finding the first non-repeated character in a string is a common problem in programming, especially in scenarios like parsing text or analyzing data streams. Identifying the first unique character can help in tasks such as detecting errors in input data, improving data processing efficiency, or even in developing algorithms for natural language processing. Java 8 provides an elegant and efficient way to solve this problem using streams.

In this guide, we will walk through creating a Java program that identifies the first character in a string that does not repeat, leveraging Java 8’s powerful Stream API.

Problem Statement

The task is to create a Java program that:

• Accepts a string as input.
• Uses Java 8 Streams to find the first character that does not repeat in the string.
• Displays the first non-repeated character or a message if all characters are repeated.

Example:

• Input: "swiss"
• Output: First Non-Repeated Character: w

Example 2:

• Input: "success"
• Output: First Non-Repeated Character: u

Solution Steps

1. Input String: Start with a string containing characters. This string can be provided by the user or hardcoded.
2. Count Character Occurrences: Use Java 8 Streams to create a frequency map of all characters in the string.
3. Find the First Non-Repeated Character: Iterate over the string and use the frequency map to identify the first character with a count of one.
4. Display the Result: Output the first non-repeated character or indicate if there is none.

Java Program

Java 8 Program to Find the First Non-Repeated Character in a String

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

/**
 * Java 8 Program to Find the First Non-Repeated Character in a String
 * Author: https://www.rameshfadatare.com/
 */
public class FirstNonRepeatedCharacter {

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

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

        // Step 3: Find the first non-repeated character
        Character firstNonRepeated = characterCount.entrySet().stream()
                .filter(entry -> entry.getValue() == 1)
                .map(Map.Entry::getKey)
                .findFirst()
                .orElse(null);

        // Step 4: Display the result
        if (firstNonRepeated != null) {
            System.out.println("First Non-Repeated Character: " + firstNonRepeated);
        } else {
            System.out.println("All characters are repeated.");
        }
    }
}

Explanation of the Program

• Input Handling: The input string "swiss" is used as an example to demonstrate finding the first non-repeated character.

• Counting Character Occurrences: The chars() method converts the string into an IntStream of character ASCII values. These are converted into a stream of Character objects using mapToObj. The groupingBy collector, along with Collectors.counting(), is used to create a frequency map of each character.

• LinkedHashMap: We use a LinkedHashMap to maintain the order of characters as they appear in the string. This ensures that the first non-repeated character is found in the correct order.

• Finding the First Non-Repeated Character: The stream is filtered to find characters with a count of one, and findFirst() is used to retrieve the first such character.

• Output: The program outputs the first non-repeated character, or a message indicating that all characters are repeated if no unique character is found.

Output Example

Example 1:

Input: swiss
Output: First Non-Repeated Character: w

Example 2:

Input: success
Output: First Non-Repeated Character: u

Advanced Considerations

1. Case Sensitivity: The program is case-sensitive by default. To make it case-insensitive, you can convert the input string to lower case using input.toLowerCase() before processing.

2. Handling Special Characters: The program considers all characters, including spaces and punctuation, in the count. You can filter out non-alphabetic characters if required.

3. Performance Considerations: The use of a LinkedHashMap ensures that the order of characters is preserved, which is crucial for finding the first non-repeated character efficiently.

Conclusion

This Java 8 program provides a clear and efficient method for finding the first non-repeated character in a string. By leveraging streams and functional programming techniques, the solution is both concise and powerful, making it a great tool for text processing tasks. Whether you’re working on a small utility or a larger text analysis project, understanding how to efficiently find unique characters is a valuable skill in Java development.