How to implement a Map with multiple keys?

java

map-implementation

data-structures

concurrency

byNikita Barsukov·Jan 22, 2025

Apache Commons Collections' MultiKeyMap offers a plug-and-play solution:

MultiKeyMap multiKeyMap = new MultiKeyMap();
multiKeyMap.put("Key1", "Key2", "Value"); // Sweet! That's two keys right there!

Alternatively, embrace Guava's Table with its rich API functionalities:

Table<String, String, String> table = HashBasedTable.create();
table.put("RowKey", "ColumnKey", "Value"); // Row, column? We're playing chess now!

Or, unleash your inner craftsman by committing to your own CompositeKey class:

public class CompositeKey {
    private final Object part1;
    private final Object part2;
    // Feel free to add any Modifiers, Comparators, or Magical Creatures 
}

Map<CompositeKey, String> map = new HashMap<>();
map.put(new CompositeKey("Key1", "Key2"), "Value"); // Just like duct taping keys together

Choose the one that aligns with the gravity of your project's needs – from complexity to performance.

Two-maps approach: Simple and efficient

Handling dual keys can be managed via a "two separate maps" strategy, providing a mean for quick value retrieval. One handles the primary key to value mapping, the other the secondary key to primary key mapping.

Map<KeyType1, ValueType> primaryMap = new HashMap<>();
Map<KeyType2, KeyType1> secondaryMap = new HashMap<>(); // Like a remora fish to a shark!

Ensuring functions like getByKey1, getByKey2, containsKey1, and containsKey2 are in place keeps your map integrity in check while providing seamless access to values.

Key integrity: Say no to accidental clones!

In a perfect multi-keyed map, each key is unique. To ensure order, operations triggering key duplicity should return a validation error.

Performance implications? Time complexity can spike with two maps due to more raw memory use, but accessing values often becomes quicker – Speedy Gonzales would be proud!

Real-world applications: Where theory meets code

Identify a use case where this makes sense for your scenario - a caching system in a web service where resources are identifiable by multiple identifiers can be a viable option.

Advanced Scenarios: Thread safety and memory considerations

In concurrent access patterns, operations that alter the state of your maps should maintain its integrity. Implement synchronisation to ensure data consistency. For thread safety, consider using ConcurrentHashMap.

Analyse the memory footprint of your server for optimal performance. Two maps are hungrier than one for memory, but are also speedier at serving requests. A classic tortoise-and-hare situation!