Write a Java program to count the frequency of each character in a String.

public static Map<Character, Integer> charFrequency(String str) {
    Map<Character, Integer> freq = new LinkedHashMap<>();  // preserves insertion order

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

Map<Character, Integer> result = charFrequency("programming");
result.forEach((c, count) ->
    System.out.println("'" + c + "' → " + count));
// 'p' → 1, 'r' → 2, 'o' → 1, 'g' → 2, 'a' → 1, 'm' → 2, 'i' → 1, 'n' → 1

public static void printFrequencySorted(String str) {
    char[] chars = str.toCharArray();
    Arrays.sort(chars);

    int i = 0;
    while (i < chars.length) {
        int count = 1;
        while (i + count < chars.length && chars[i + count] == chars[i]) {
            count++;
        }
        System.out.println("'" + chars[i] + "' : " + count);
        i += count;
    }
}

public static Map<Character, Long> charFrequencyStream(String str) {
    return str.chars()
              .mapToObj(c -> (char) c)
              .collect(Collectors.groupingBy(c -> c, Collectors.counting()));
}

// Sort by frequency descending
str.chars()
   .mapToObj(c -> (char) c)
   .collect(Collectors.groupingBy(c -> c, Collectors.counting()))
   .entrySet().stream()
   .sorted(Map.Entry.<Character, Long>comparingByValue().reversed())
   .forEach(e -> System.out.println("'" + e.getKey() + "': " + e.getValue()));

public static char mostFrequentChar(String str) {
    Map<Character, Integer> freq = new HashMap<>();
    for (char c : str.toCharArray()) {
        freq.put(c, freq.getOrDefault(c, 0) + 1);
    }

    return freq.entrySet().stream()
               .max(Map.Entry.comparingByValue())
               .map(Map.Entry::getKey)
               .orElseThrow();
}

System.out.println(mostFrequentChar("aabbccddeeea")); // 'a' (appears 4 times)

public static char firstNonRepeating(String str) {
    Map<Character, Integer> freq = new LinkedHashMap<>();
    for (char c : str.toCharArray()) {
        freq.put(c, freq.getOrDefault(c, 0) + 1);
    }

    for (Map.Entry<Character, Integer> entry : freq.entrySet()) {
        if (entry.getValue() == 1) {
            return entry.getKey();  // first character with count 1
        }
    }
    return '\0';  // no non-repeating character
}

System.out.println(firstNonRepeating("aabcddee")); // 'b'
System.out.println(firstNonRepeating("aabb"));     // '\0' (none found)

public static String removeDuplicates(String str) {
    Set<Character> seen = new LinkedHashSet<>();
    for (char c : str.toCharArray()) {
        seen.add(c);  // Set auto-deduplicates
    }
    StringBuilder sb = new StringBuilder();
    seen.forEach(sb::append);
    return sb.toString();
}

System.out.println(removeDuplicates("programming")); // "progamin"

@Test
public void testCharFrequency() {
    Map<Character, Integer> freq = charFrequency("aabb");
    assertEquals(2, (int) freq.get('a'));
    assertEquals(2, (int) freq.get('b'));

    assertEquals('a', mostFrequentChar("aabbc")); // a appears most
    assertEquals('b', firstNonRepeating("aabcdd")); // b is first non-repeating
    assertEquals("abc", removeDuplicates("aabbcc")); // unique chars preserved
}