Find Duplicate Characters in a String Using Java

---

---

Introduction:

In the realm of programming, there are often multiple ways to solve a problem. Today, we're going to delve into the task of finding duplicate characters in a string using Java. Duplicate characters can occur in a variety of contexts, from analyzing text to ensuring data integrity. We'll explore several approaches to tackle this common problem, each with its own advantages and considerations.

1. Using HashMap:

One of the most efficient ways to find duplicate characters in a string is by utilizing a HashMap. We can iterate through the characters of the string, storing each character as a key in the map and incrementing its corresponding value. If a character already exists in the map, we've found a duplicate.

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

public class DuplicateFinder {
    public static void findDuplicateCharacters(String str) {
        Map<Character, Integer> charCountMap = new HashMap<>();

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

        for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
            if (entry.getValue() > 1) {
                System.out.println(entry.getKey() + " : " + entry.getValue());
            }
        }
    }

    public static void main(String[] args) {
        String input = "hello world";
        findDuplicateCharacters(input);
    }
}

---

---

2. Using HashSet:

Another approach involves utilizing a HashSet to keep track of characters we've encountered. We iterate through the string and add each character to the set. If adding the character fails (meaning it's already in the set), we've encountered a duplicate.

import java.util.HashSet;
import java.util.Set;

public class DuplicateFinder {
    public static void findDuplicateCharacters(String str) {
        Set<Character> set = new HashSet<>();
        Set<Character> duplicates = new HashSet<>();

        for (char c : str.toCharArray()) {
            if (!set.add(c)) {
                duplicates.add(c);
            }
        }

        for (char c : duplicates) {
            System.out.println(c);
        }
    }

    public static void main(String[] args) {
        String input = "hello world";
        findDuplicateCharacters(input);
    }
}

3. Using Arrays:

For a more basic approach, we can use arrays to track character occurrences. We create an array of boolean values corresponding to ASCII characters. As we iterate through the string, we mark characters as encountered. If we encounter a character already marked, it's a duplicate.

public class DuplicateFinder {
    public static void findDuplicateCharacters(String str) {
        boolean[] charSet = new boolean[256];

        for (int i = 0; i < str.length(); i++) {
            int val = str.charAt(i);
            if (charSet[val]) {
                System.out.println((char)val);
            } else {
                charSet[val] = true;
            }
        }
    }

    public static void main(String[] args) {
        String input = "hello world";
        findDuplicateCharacters(input);
    }
}

Conclusion:

In this blog post, we explored multiple approaches to find duplicate characters in a string using Java. Each solution has its own merits and may be more suitable depending on the specific requirements of your project. Whether you opt for HashMaps, HashSets, or simple arrays, understanding these techniques empowers you to write efficient and robust code to tackle similar challenges in your programming journey.

---

---