Question

As part of an ongoing class project, we were asked to implement Maps for better object linking.

In short, we currently have four arraylists which hold objects

// Array Lists used for sorting.
private static ArrayList<Party> partyList = new ArrayList<Party>();
private static ArrayList<Creature> creatureList = new ArrayList<Creature>();
private static ArrayList<Treasure> treasureList = new ArrayList<Treasure>();
private static ArrayList<Artifact> artifactList = new ArrayList<Artifact>();

Each class has their own fields (ie, Party has “index”,”name”, Creature has “index”, “name”, “age”, height”, etc…but they all have a unique index)

This week we are to implement hashmaps, where the key of an object, is its index.

so, as an exmaple:

creatureMap.put(creature.index, creature)
...

Our program also allows searching. So i understand that now when we search by an index, we just search the appropriate hashmap for the index we want, and work with the object that is its value.

However, our program also allows the user to search by name, height, weight, etc. So, how are hashmaps being used efficiently here if it only helps when searching by index? What happens if i want to search a creature by name? I would have to loop through every value in the hashmap, look at its ‘name’ field..which is exactly what i am doing with the arraylist.

Our professor said this when someone asked a similar question:

The idea is that in the first project, the simple approach was to
insert all items into array lists and when one needed to link a
creature to a party, or an item to a creature, one would have to
search the ArrayList linearly until the index of the item was found.
This is O(n) operation if the ArrayList is not sorted, and an O(log n)
operation if the list is sorted, but the sorting is typically O(n*n)
or O(n log n) depending on the sorting operation used.

This week, I am asking you to implement an O(1) searching system based
on a map data structure. Thus, we should use the index of a item as
its key to generate the links. This is used once during processing of
the input file.

Thus, I am not sure i am understanding the concept of Maps / key-value pairs correctly.

Answer 1

Your understanding is correct: if your key is an index, you can only use the map to efficiently lookup by index. If you wanted to search by name, then you would have to key on the name.

I’m not too sure on what your professor meant by this:

Thus, we should use the index of a item as its key to generate the links.

(I think he refers to linking objects by index, as in “link a creature to a party” – maybe he did not refer to the use of hashmaps for searching)

On a side note, it’s good practice to declare variables based on interfaces rather than concrete types. In your example, you should define your list fields as List instead of ArrayList:

private static List<Party> partyList = new ArrayList<Party>();