Two keys mapped to the same value. Java

Question

Is there any solution which allows to avoid usage of two maps for case when two keys are mapped to the same value? The problem: we have a server that receives two types of requests - getDataByUserID(UserID userId) and getDataByNodeID(NodeID nodeId), where userId and nodeId have one-to-one mapping. No DB used, all data is stored in memory. There is straightforward solution - to use two maps one UserID/data and second NodeID/data, but I would like to avoid manipulations with two tables. The server interface is:

void put (InetSocketAddress nodeId, String clientId, Data data);
Data get (InetSocketAddress nodeId);
Data get (String clientId);

Any suggestions are welcome.

Answer 1

Maybe adding an interface to UserId and NodeId could work.

Something like this:

void test()
{
    UserId userId = new UserId();
    NodeId nodeId = new NodeId();
    String userData = "xyz";

    HashMap<IdValue, String> idToDataMap = new HashMap<>();
    idToDataMap.put(userId,userData);
    idToDataMap.put(nodeId,userData);
}

class UserId implements IdValue {
    //...
}

class NodeId implements IdValue {
    //...
}

interface IdValue {
}

Answer 2

There is no smart data structure to do this. As @JavaMan suggests, you could use one HashMap with keys of both types if the keys have a common supertype. However, this will be difficult to implement without race conditions if you need a concurrent solution. (You cannot add or remove two entries atomically ...)

There is a nasty solution that avoids this. You could redefine the NodeId and UserId classes to implement a common interface; say CommonId. Then you need to redefine the equals(Object) and hashCode() methods so that they treat the two kinds of identifier as equivalent.

For example:

UserId a = ...
NodeId b = ... // representing the same user as 'a'

Then

a.equals(b) => true
b.equals(a) => true
a.hashCode() == b.hashCode()

in addition to the other aspects of the equals / hashcode contract.

Important Note: this assumes that there is an efficient way to implement the above semantics that doesn't rely on the map that we are defining.

You can then change your map to a HashMap<CommonId, YourValueClass>, and put and get using either a UserId instance or NodeId instance as the key.

Why is this nasty?

• Because this redefinition of equals and hashCode applies for all uses of the two classes, not just this map.

• Because it is violating the documented semantics of equals(Object). The javadocs say that this.equals(other) should return false if this and other have different classes.

However, this does suggest some alternative solutions:

1. You could use a TreeMap instead of a HashMap, and supply a Comparator<CommonId> that provides a consistent ordering, AND treats equivalent identifiers of either type as equal.

   • It is not clear whether it would be feasible to implement the ordering.
   • TreeMap is O(logN) rather than O(1) for get and put operations.

2. You could try to find a 3rd-party hash map implementation that allows you to supply hash and equals functions; i.e. analogous to supplying a Comparator to a TreeMap.

Answer 3

Sure. Plenty of solutions.

Make your own class

Make a class. This class internally has 2 fields: Map<UserId, Data> userIdToData and Map<NodeId, Data> nodeIdToData. These are private fields. The class does not itself implement java.util.Map, but it has many of its methods, such as size() (which just does return userIdToData.size();). It also has:

public void put(UserId userId, NodeId nodeId, Data data) {
    userIdToData.put(userId, data);
    nodeIdToData.put(nodeId, data);
}

public Data getByUserId(UserId userId) {
    return userIdToData.get(userId);
}

// ... and getByNodeId, and getByUserIdOrDefault, etcetera.

THIS code will be messing with 2 maps and needs to ensure they remain in sync, but you can trivially write extensive tests for this code and all other code in your entire project doesn't need to worry about it then.

map UserId to NodeId, then NodeId to data

Have 2 maps:

Map<UserId, NodeId> userToNode;
Map<NodeId, Data> nodeToData;

and a method:

public Data getByUserId(UserId id) {
    NodeId node = userToNode.get(id);
    if (node == null) return null;
    return nodeToData.get(node);
}