Type-1:

 Let's create a Java program that finds and prints all duplicate characters in a given string. 

We'll also provide a detailed explanation of how the program works:

import java.util.HashMap; 
import java.util.Map;
public class DuplicateCharacterFinder { 
public static void main(String[] args) {
String input = "hello world"; 
 findAndPrintDuplicateCharacters(input); 
 } 
public static void findAndPrintDuplicateCharacters(String input) {
// Create a HashMap to store the frequency of each character in the string

        Map<Character, Integer> charFrequencyMap = new HashMap<>(); 
// Convert the input string to lowercase (if case-insensitive matching is desired)

        String lowercaseInput = input.toLowerCase(); 
// Iterate through each character in the lowercase input string

        for (char ch : lowercaseInput.toCharArray()) { 
// Skip non-alphabetic characters and spaces 
if (Character.isLetter(ch)) {
// Update the frequency count for the current character in the HashMap

                charFrequencyMap.put(ch, charFrequencyMap.getOrDefault(ch, 0) + 1);
 } 
 } 
// Print duplicate characters found in the input string

        System.out.println("Duplicate characters in the string:"); 
for (char ch : charFrequencyMap.keySet()) { 
int frequency = charFrequencyMap.get(ch); 
if (frequency > 1) { 
 System.out.println("'" + ch + "' appears " + frequency + " times.");
 } 
 } 
 } 
}

Explanation:

  1. The program starts with the main method, where we declare and initialize the input variable with the string in which we want to find duplicate characters. In this example, the input is set to "hello world".
  2. We call the findAndPrintDuplicateCharacters method, passing the input as an argument, to find and print all duplicate characters in the string.
  3. In the findAndPrintDuplicateCharacters method, we create a HashMap called charFrequencyMap to store the frequency of each character in the string. The key of the map represents the character, and the value represents the frequency (the number of occurrences) of that character in the string.
  4. To ensure case-insensitive matching, we convert the input string to lowercase using the toLowerCase() method. This step is optional and can be omitted if you want case-sensitive matching.
  5. We iterate through each character in the lowercase input string using a for-each loop.
  6. Inside the loop, we skip non-alphabetic characters and spaces using the Character.isLetter() method. This step ensures that we only consider alphabetic characters (letters) and exclude spaces or other non-alphabetic characters from the frequency count.
  7. We use the charFrequencyMap to update the frequency count for the current character. We use charFrequencyMap.getOrDefault(ch, 0) + 1 to get the current frequency of the character ch (if it exists in the map) or 0 if the character is not present in the map. We then increment the frequency by 1 and put the updated count back into the map.
  8. After processing all characters, the charFrequencyMap contains the frequency of each character in the string.
  9. We then print the duplicate characters found in the input string. We iterate through the keys of the charFrequencyMap using a for-each loop.
  10. For each character ch, we get its frequency using charFrequencyMap.get(ch). If the frequency is greater than 1, it means the character is duplicated in the string.
  11. We print the duplicate character and its frequency in a human-readable format.


By using this approach with a HashMap, we efficiently find and print all duplicate characters in a given string while handling case-insensitive matching and excluding non-alphabetic characters. The program correctly identifies and counts duplicate characters, making it useful for various applications involving character frequency analysis.

Type-2:

Another way to find and print all duplicate characters in a given string is by using a simple nested loop approach.

  Here's a Java program that achieves this:


public class DuplicateCharacterFinder { 
public static void main(String[] args) { 
String input = "hello world";
        findAndPrintDuplicateCharacters(input);
 }
public static void findAndPrintDuplicateCharacters(String input) { 
// Convert the input string to lowercase (if case-insensitive matching is desired)

        String lowercaseInput = input.toLowerCase();
// Iterate through each character in the string 
for (int i = 0; i < lowercaseInput.length(); i++) {
char currentChar = lowercaseInput.charAt(i);
// Skip non-alphabetic characters and spaces 
if (!Character.isLetter(currentChar)) { 
continue; 
 } 
// Check if the current character is a duplicate 
boolean isDuplicate = false; 
for (int j = i + 1; j < lowercaseInput.length(); j++) {
char compareChar = lowercaseInput.charAt(j); 
if (currentChar == compareChar) { 
 isDuplicate = true;
                    break;
                } 
 } 
// If the current character is a duplicate, print it 
if (isDuplicate) {
 System.out.println("'" + currentChar + "' is a duplicate."); 
 }
        } 
 }
}

Explanation:

  1. The code structure and the declaration of the main method are similar to the previous implementation.
  2. We call the findAndPrintDuplicateCharacters method, passing the input as an argument, to find and print all duplicate characters in the string.
  3. In the findAndPrintDuplicateCharacters method, we convert the input string to lowercase using the toLowerCase() method to ensure case-insensitive matching. This step is optional and can be omitted if you want case-sensitive matching.
  4. We then use a for loop to iterate through each character in the lowercaseInput string.
  5. Inside the loop, we get the current character at index i using lowercaseInput.charAt(i).
  6. We skip non-alphabetic characters and spaces using Character.isLetter() method. This ensures that we only consider alphabetic characters (letters) and exclude spaces or other non-alphabetic characters from being identified as duplicates.
  7. We use a nested for loop to compare the current character with all the characters that come after it (at indices j > i) in the lowercaseInput string.
  8. If we find a character that matches the current character, we set isDuplicate to true.
  9. If isDuplicate is true, it means the current character is a duplicate, and we print it.
  10. The loop continues to check for duplicates for all characters in the string.


By using this simple nested loop approach, we find and print all duplicate characters in a given string. This implementation is straightforward and works efficiently for shorter strings. However, for larger strings, the time complexity of the nested loop approach increases, and using a HashMap (as shown in the previous implementation) becomes more efficient for identifying duplicate characters.

Type-3:

Another way to find and print all duplicate characters in a given string is by using a Set data structure.

 We can iterate through the characters of the string and use the Set to keep track of characters that have been seen before.

 If a character is already in the Set, it is a duplicate, and we print it.  Let's implement this approach in Java:


import java.util.HashSet; 
import java.util.Set;
public class DuplicateCharacterFinder { 
public static void main(String[] args) { 
String input = "hello world"; 
 findAndPrintDuplicateCharacters(input); 
 } 
public static void findAndPrintDuplicateCharacters(String input) {
// Convert the input string to lowercase (if case-insensitive matching is desired)

        String lowercaseInput = input.toLowerCase(); 
// Create a set to store characters that have been seen before

        Set<Character> seenChars = new HashSet<>(); 
// Iterate through each character in the string 
for (char ch : lowercaseInput.toCharArray()) { 
// Skip non-alphabetic characters and spaces 
if (!Character.isLetter(ch)) {
continue;
 }
// If the character is already in the set, it is a duplicate, so print it

            if (seenChars.contains(ch)) {
 System.out.println("'" + ch + "' is a duplicate."); 
 } 
else {
// Otherwise, add the character to the set

                seenChars.add(ch);
 }
        }
 } 
}

Explanation:

  1. The code structure and the declaration of the main method are similar to the previous implementations.
  2. We call the findAndPrintDuplicateCharacters method, passing the input as an argument, to find and print all duplicate characters in the string.
  3. In the findAndPrintDuplicateCharacters method, we convert the input string to lowercase using the toLowerCase() method to ensure case-insensitive matching. This step is optional and can be omitted if you want case-sensitive matching.
  4. We create a HashSet called seenChars to store characters that have been seen before. The HashSet allows us to efficiently check if a character has been encountered before in constant time.
  5. We then use a for-each loop to iterate through each character in the lowercaseInput string.
  6. Inside the loop, we get the current character (ch) from the lowercaseInput using the enhanced for loop.
  7. We skip non-alphabetic characters and spaces using the Character.isLetter() method. This ensures that we only consider alphabetic characters (letters) and exclude spaces or other non-alphabetic characters from being identified as duplicates.
  8. We use the seenChars set to check if the current character is already in the set using the contains() method.
  9. If the character is already in the set, it means it is a duplicate, so we print it.
  10. If the character is not in the set, we add it to the seenChars set using the add() method.
  11. The loop continues to check for duplicates for all characters in the string.


By using this approach with a Set, we efficiently find and print all duplicate characters in a given string while handling case-insensitive matching and excluding non-alphabetic characters. The Set ensures that we do not print duplicates more than once, even if they occur multiple times in the string. This implementation is straightforward and performs well for both short and long strings.