Question

Hi I am populating a Hashmap with a dictionary.txt file and I am splitting the hashmap into sets of word lengths.

Im having trouble searching the Hashmap for a pattern of “a*d**k”;

Can anyone help me?

I need to know how to search a Hashmap?

I would really appreciate if you could help me.
Thank you.

Answer 1

A HashMap is simply the wrong data structure for a pattern search.

You should look into technologies that feature pattern searching out of the box, like Lucene

---

And in answer to this comment:

Im using it for Android, and its the
fastest way of searching.

HashMaps are awfully fast, that’s true, but only if you use them as intended. In your scenario, hash codes are not important, as you know that all keys are numeric and you probably won’t have any word that’s longer than, say, 30 letters.

So why not just use an Array or ArrayList of Sets instead of a HashMap and replace map.get(string.length()) with list.get(string.length()-1) or array[string.length()-1]. I bet the performance will be better than with a HashMap (but we won’t be able to tell the difference unless you have a reaaaallly old machine or gazillions of entries).

I’m not saying my design with a List or Array is nicer, but you are using a data structure for a purpose it wasn’t intended for.

---

Seriously: How about writing all your words to a flat file (one word per line, sorted by word length and then by alphabetically) and just running the regex query on that file? Stream the file and search the individual lines if it’s too large, or read it as a String and keep that in memory if IO is too slow.

---

Or how about just using a TreeSet with a custom Comparator?

Sample code:

public class PatternSearch{

    enum StringComparator implements Comparator<String>{
        LENGTH_THEN_ALPHA{

            @Override
            public int compare(final String first, final String second){

                // compare lengths
                int result =
                    Integer.valueOf(first.length()).compareTo(
                        Integer.valueOf(second.length()));
                // and if they are the same, compare contents
                if(result == 0){
                    result = first.compareTo(second);
                }

                return result;
            }
        }
    }

    private final SortedSet<String> data =
        new TreeSet<String>(StringComparator.LENGTH_THEN_ALPHA);

    public boolean addWord(final String word){
        return data.add(word.toLowerCase());
    }

    public Set<String> findByPattern(final String patternString){
        final Pattern pattern =
            Pattern.compile(patternString.toLowerCase().replace('*', '.'));
        final Set<String> results = new TreeSet<String>();
        for(final String word : data.subSet(
            // this should probably be optimized :-)
            patternString.replaceAll(".", "a"),
            patternString.replaceAll(".", "z"))){
            if(pattern.matcher(word).matches()){
                results.add(word);
            }
        }
        return results;
    }

}