Detecting if two strings are anagrams using TreeMap

1 Coding conventions

You abuse your code (a little bit) vertically. Instead of

public static boolean areAnagrams( String s1 , String s2 ) {

    if ( s1.length() != s2.length() ) {
        return false;
    }
    ...

I would write

public static boolean areAnagrams( String s1 , String s2 ) {
    if ( s1.length() != s2.length() ) {
        return false;
    }
    ...

Also, I would fix

... areAnagrams( String s1 , String s2) {

to

... areAnagrams(final String s1, final String s2) {

Like in natural languages, a space before commas is bad style.

2 Map data structure

You should use java.util.HashMap instead of java.util.TreeMap, and that is why: HashMap runs its non-bulk operations in \$\mathcal{O}(1)\$, whereas TreeMap does the same in \$\mathcal{O}(\log n)\$. TreeMap is a good choice whenever you need to traverse the key/value pairs in order by keys, which is not your use case.

Summa summarum

All in all, I had these in mind:

// Easy way: Sort characters and compare. Runs in O(n log n).
public static boolean areAnagrams1(final String s1, final String s2) {
    if (s1.length() != s2.length()) {
        return false;
    }

    final char[] chars1 = s1.toCharArray();
    final char[] chars2 = s2.toCharArray();

    Arrays.sort(chars1);
    Arrays.sort(chars2);

    return Arrays.equals(chars1, chars2);
}

// Runs in O(n).
public static boolean areAnagrams2(final String s1, final String s2) {
    if (s1.length() != s2.length()) {
        return false;
    }

    final Map<Character, Integer> frequencyMap = new HashMap<>();

    for (final char c : s1.toCharArray()) {
        frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1);
    }

    for (final char c : s2.toCharArray()) {
        if (frequencyMap.getOrDefault(c, 0) == 0) {
            return false;
        }

        frequencyMap.put(c, frequencyMap.get(c) - 1);
    }

    return true;
}

Hope that helps.

I think using Maps here goes just over the top. I would simply write:

private static boolean areAnagrams(String one, String  two) {
    if (one.length() != two.length()) {
        return false;
    }
    int[] sortedOne = one.chars().sorted().toArray();
    int[] sortedTwo = two.chars().sorted().toArray();
    return Arrays.equals(sortedOne, sortedTwo);
}

If this is an interview question, I would add something different to think about: Making your code pretty and performant will help, but as it stands this approach would be too slow for actual use on e.g. a website. So now think about the context of where this program might run. Probably on a server, and what are servers good at even though they are not high-speed? They can store large amounts of data in advance and look it up fast.

For a general answer to the problem, I would suggest:

• At the start of the program (or at some initialization time of the server) create a giant HashMap(?)* with key-list pairs.
• Sort every word from your natural language dictionary alphabetically,
• then store it as a key in your map. Also add the unsorted version to the list for that key.
• If the key already exists, just add the unsorted version of the word to the list.

This method will run a long time depending on the system and size of the word list, but once it is cached somewhere, the lookup time is constant.

When hiring programmers it's actually easy to find people who are good "craftsmen", because everybody can look up clean syntax and concrete problem solutions on the internet. A good way to stand out is to demonstrate problem solving skills that don't have to do anything with the programming language or concrete implementation.

*I'm unsure about which data structure would be the best, as it's implementation specific. In C# I've used a generic Dictionary.

Here is my version in C# just to show how I tackled the problem. There might be missing some error handling and there are probably faster algorithms for sorting, but this already fast enough for a real-life application.

/// <summary>
/// Retrieves all anagrams for a given input word from the buffer.
/// </summary>
public static List<string> GetAnagrams(string input, Dictionary<string, List<string>> buffer)
{
    return buffer[SortWord(input)];
}

/// <summary>
/// Given a list of words, creates a buffer of sorted word keys and all matching anagrams in the list.
/// </summary>
public static Dictionary<string, List<string>> CreateBuffer(List<string> words)
{
    var buffer = new Dictionary<string, List<string>>();
    foreach (var word in words)
    {
        string sorted = SortWord(word);
        if (buffer.ContainsKey(sorted))
            buffer[sorted].Add(word);
        else
            buffer.Add(sorted, new List<string>() { word });
    }
    return buffer;
}

public static string SortWord(string input)
{
    if (input == null)
        throw new ArgumentNullException(nameof(input));

    char[] output = input.ToArray();
    Array.Sort(output);
    return new string(output);
}