Wojtek wrote:
I have a Person object. It contains a pKey (unique) and a name (may
repeat, ie John Smith). The Person object will be held in a collection.
New (or old) people will be added in any order, however I want the
output to be sorted by name. Since the name can repeat I cannot use it
as a key, instead I want to use the pKey.
Normally (sorted on the key) I would use a TreeMap, but I want to use
the key to find a Person, yet sort on the Perons name:
TreeMap<String,Person> people = new TreeMap<String,Person>(); ...
Person addPerson(String pKey, String name) {
Person person = people.get(pKey);
if ( person == null )
{
person = new Person(pKey,name);
people.put(pKey,person);
}
return person;
}
I thought of creating my own Comparitor, however the TreeMap insists
that the comparitor needs to sort on the String (pKey) rather than the
value (Person).
I know I can:
- use two collections, one which is used for lookup the other for
sorting - ignore the TreeMap and use a simple Map, then array sort the
values().toArray(). (Thanks Roedy)
- make a key which is the (name + pKey) but this would create large
keys.
I was hoping there was a more elegant way.
Yes, a Google search turned this up with solutions, however most of
those did not use Generics :-(
I would use two structures, but firmly hide the fact from the rest of
the program.
Step 1: Define an interface that does exactly what you need. It may
simply extend Iterable<Person> and have additional methods:
void insert(Person person);
Person get(String pKey);
void remove(Person person);
Step 2: Write a simple, straightforward implementation using java.util
to do the real work. For example, the get by pKey function could use a
HashMap<String,Person>. The Iterable<Person> iterator method would be
delegated to a TreeSet<Person> with a Comparator<Person> that sorts on
name as primary key, pKey as tie-breaker for equal name.
Step 3: Measure the result. If it works well enough, go on to something
else. If not, look at alternative implementation ideas.
Patricia