How to use two numbers as a Map key

Question

I have two numbers and I want to use them together as a key in a Map. Currently, I'm concatenating their string representations. For example, suppose the key numbers are 4 and 12. I use:

String key = 4 + "," + 12;

The map is declared as Map<String, Object>.

I think this is so bad! I like to use something other than a String as the key! I want the fastest way to create these keys.

Who has a good idea?

Answer 1

Create an object that holds the two numbers and use it as the key. For example:

class Coordinates {

  private int x;
  private int y;

  public Coordinates(int x, int y) {
     ...
  }

  // getters

  // equals and hashcode using x and y
}

Map<Coordinates, Location> locations = new HashMap<Coordinates, Location>();

If you prefer a mathematical approach, see this StackOverflow answer.

Answer 2

You need write the right eqauls and hashcode methods , or produce some bugs.

Answer 3

You can store two integers in a long like this,

   long n = (l << 32) | (r & 0XFFFFFFFFL);

Or you can use following Pair<Integer, Integer> class,

public class Pair<L, R> {

    private L l;
    private R r;

    public Pair() {
    }

    public Pair(L l, R r) {
        this.l = l;
        this.r = r;
    }

    public L getLeft() {
        return l;
    }

    public R getRight() {
        return r;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair obj = (Pair) o;
        return l.equals(obj.l) && r.equals(obj.r);
    }

    @Override
    public int hashCode() {
        return l.hashCode() ^ r.hashCode();
    }
}

Answer 4

If you go with the object solution, make sure your key object is immutable.

Otherwise, if somebody mutates the value, not only will it no longer be equal to other apparently-identical values, but the hashcode stored in the map will no longer match the one returned by the hashCode() method. At that point you're basically SOL.

For instance, using java.awt.Point -- which looks, on paper, like exactly what you want -- the following:

  public static void main(String[] args) {
    Map<Point, Object> map = new HashMap<Point, Object>();

    Point key = new Point(1, 3);
    Object val = new Object();

    map.put(key, val);

    System.out.println(map.containsKey(key));
    System.out.println(map.containsKey(new Point(1, 3)));

    // equivalent to setLeft() / setRight() in ZZCoder's solution,
    // or setX() / setY() in SingleShot's
    key.setLocation(2, 4);

    System.out.println(map.containsKey(key));
    System.out.println(map.containsKey(new Point(2, 4)));
    System.out.println(map.containsKey(new Point(1, 3)));
  }

prints:

true
true
false
false
false

Answer 5

Another approach would be to use nested maps:

Map<Integer,Map<Integer,Object>>

Here you have no overhead to create keys. However you have more overhead to create and retrieve entries correctly and you need always to map-accesses to find the object you are looking for.

Answer 6

Why should writing all that extra code to make a full blown class that you don't need for anything else be better than using a simple String? Will computing the hash code for instances of that class be much faster than for the String? I don't think so.

Unless you are running in an extremely limited computing power environment, the overhead of making and hashing Strings should not be noticeably larger than that of instantiating your custom class.

I guess the fastest way would be to simply pack the ints into a single Long as ZZ Coder suggested, but in any case, I don't expect the speed gains to be substantial.

Answer 7

A practical answer to this questions is:

hashCode = a + b * 17;

... where a, b and hashCode are all ints. 17 is just an arbitrary prime number. Your hash will not be unique, but that's OK. That sort of thing is used all over the Java standard library.