If you are only concerned about matching the first few characters
(starts with JO) then would a TreeSet<String> (that I refer to a treeSet
below) work?

    SortedSet<String> tailSet = treeSet.tailSet("JO");
    TreeSet<String> matchingSet = new TreeSet<String>();
    for (String s : tailSet) {
      if (!s.startsWith("JO")) {
        break;
      }
      matchingSet.add(s);
    }
    return matchingSet;

Just and idea and not sure if it is what you need.

Cheers,

Dan Andrews
- - - - - - - - - - - - - - - - - - - - - - - - -
Ansir Development Limited http://www.ansir.ca
- - - - - - - - - - - - - - - - - - - - - - - - -

If you only need to match key prefixes, then use a radix tree (or one
of the many variants). In a radix tree, the key describes a path from
the root of the tree to the corresponding object.

When you follow the path described by a given prefix, you arrive at a
node whose key matches the prefix exactly, and whose entire subtree
consists of nodes whose keys start with that prefix.

/gordon

It's doable, but it wouldn't be pretty or efficient:

       Vector result = new Vector();

       Enumeration foo = hash.keys();

       while ( foo.hasMoreElements())
       {
               String bar = foo.nextElement().toString();

               if ( bar.indexOf( pattern) > -1)
               {
                       result.append( hash.het( bar);
               }
       }

       return result;

If you want to go down this route you lose all the benefits you got from
the hashtable in the first place. But if you do want to go down it I
suggest it would be more flexible if you allowed regular expression rather
than just substring matching.