//Returns the letter with the most occurrences first
    public static char[] frequency(char[] letters) {
        Map<Character, Integer> frequency;
        Map<Character, Integer> sorted;

        frequency = countOccurrences(letters);
        sorted = sortOnValue(frequency);

        return keysToArray(sorted);
    }

    //Checks if the HashMap contains the letter and add 1 to the count if it does, otherwise it adds the new letter
    private static Map<Character, Integer> countOccurrences(char[] letters) {
        Map<Character, Integer> frequency = new HashMap<>();

        for (int i = 0; i < letters.length; i++) {
            if (frequency.containsKey(letters[i])) {
                frequency.replace(letters[i], (frequency.get(letters[i]) + 1));
            } else {
                frequency.put(letters[i], 1);
            }
        }
        return frequency;
    }

    //Sorts the HashMap on the values, in descending order
    private static Map<Character, Integer> sortOnValue(Map<Character, Integer> frequency) {
        return frequency.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).collect(
                toMap(e -> e.getKey(), e -> e.getValue(), (e1, e2) -> e2,
                        LinkedHashMap::new));
    }

    //Turns the keys of the Character-HashMap into a char-array
    private static char[] keysToArray(Map<Character, Integer> sorted) {
        char[] result = new char[sorted.size()];
        int i = 0;

        for (char key : sorted.keySet()) {
            result[i] = key;
            i++;
        }
        return result;
    }