The first non-repeat character can be achieved in three ways. Method 1: Use HashMap to count the character frequency and traverse the string twice to find the first character with 1 occurrences, which is suitable for conventional scenarios; Method 2: Use LinkedHashMap to maintain the insertion order, and traverse the key-value pair to return the first character with 1 count. Although the string traversal is reduced, there are still two traversals; Method 3: Use array to count the frequency (limited ASCII characters), which has better performance and is suitable for long strings and limited character sets.

To find the first non-repetitive character in a string, Java provides multiple implementations. The most common thing is to use a hash table (such as HashMap ) to count the number of occurrences of each character, and then iterate over the string again to find the first character that only appears once.

Here is a simple and direct implementation method:

Method 1: Use HashMap to count the number of characters

This is the most common practice, applicable to most cases and is more intuitive to understand.

 import java.util.HashMap;

public class FirstNonRepeatedCharacter {
    public static char findFirstNonRepeated(String str) {
        HashMap<Character, Integer> charCount = new HashMap<>();

        // The first traversal: count the number of occurrences of each character for (char c : str.toCharArray()) {
            charCount.put(c, charCount.getOrDefault(c, 0) 1);
        }

        // The second traversal: find the first character with 1 occurrences for (char c : str.toCharArray()) {
            if (charCount.get(c) == 1) {
                return c;
            }
        }

        return &#39;\0&#39;; // If not found, return empty character}

    public static void main(String[] args) {
        String input = "swiss";
        char result = findFirstNonRepeated(input);
        System.out.println("The first non-repeat character is: " (result != &#39;\0&#39; ? result : "None"));
    }
}

In this example, we did two things:

• Use getOrDefault to simplify counting logic;
• The second round traversal of the original string, instead of the hash table's key collection, this ensures order.

Applicable scenarios:

• When the string length is not particularly large (such as within a few thousand);
• The code needs to be kept clear and easy to maintain.

Method 2: Use LinkedHashMap to maintain the insertion order

If you want to complete statistics and searches in one traversal, consider using LinkedHashMap .

 import java.util.LinkedHashMap;
import java.util.Map;

public class FirstNonRepeatedCharacter2 {
    public static char findFirstNonRepeated(String str) {
        Map<Character, Integer> map = new LinkedHashMap<>();

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

        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            if (entry.getValue() == 1) {
                return entry.getKey();
            }
        }

        return &#39;\0&#39;;
    }
}

advantage:

• Taking advantage of the orderliness of LinkedHashMap ;
• A second full traversal of the original string can be avoided.

shortcoming:

• If there are a large number of duplicate characters in the string, it may cause the final returned character to be not the earliest (because the previous duplicates were skipped);
• In fact, there are still two "traversals", but the objects are different.

Method 3: Use array optimization (ASCII characters only)

If you are sure that the input string contains only standard ASCII characters (i.e. up to 256 possibilities), you can replace the hash table with a fixed size array.

 public class FirstNonRepeatedCharacter3 {
    public static char findFirstNonRepeated(String str) {
        int[] count = new int[256];

        // First traversal: Statistical frequency for (int i = 0; i < str.length(); i ) {
            count[str.charAt(i)] ;
        }

        // The second traversal: find the first character with a frequency of 1 for (int i = 0; i < str.length(); i ) {
            if (count[str.charAt(i)] == 1) {
                return str.charAt(i);
            }
        }

        return &#39;\0&#39;;
    }
}

advantage:

• Better performance, especially when strings are very long;
• Array access is faster than hashing.

Notice:

• This method is only applicable to cases where the character set range is known;
• If there are Unicode characters, it is not suitable.

Let's summarize

• Recommended usage : If the data volume is not large, it is safest to use HashMap directly.
• Performance priority : Use arrays, provided that the character set is limited.
• Want to keep the order : Use LinkedHashMap .
• More modern writing : Java 8's Stream API can also be used, but the readability and efficiency may not be better.

Basically these are the methods. Which one you choose depends on your specific needs, but the above are relatively general and easy to understand.

The above is the detailed content of Find the first non-repeated character in a string in Java.. For more information, please follow other related articles on the PHP Chinese website!