Question

I have a lookup table that should be accessed by two separate key values. One ugly way to do this is:

int[][] myArray = new int[256][256];
myArray[key1][key2] = 25;

where key1 and key2 are keys that were previously generated dynamically. But this is rather ugly. It seems that a better way to do this would be to use a Map, but those require a single key, not two. Java doesn’t natively support tuples, so what should I use instead? (It also seems awkward to use an array as the key).

EDIT: The reason I say that this isn’t particularly pretty is that my array is actually referenced by character values, not integers. They could be used interchangeably, but the responses to my previous question seem to suggest otherwise:

2D Array in Java, Indexed by Characters

Answer 1

What’s so ugly about that? That’s about as simple as 2D matrices can be in Java, and it’s quick, too.

If you really want to use a map, just defined your own Tuple class to use as a key – but be sure that you override equals() and hashCode() correctly! I’d recommend implementing an immutable Tuple class because using mutable objects as map keys can cause serious issues.

Tuple.java

package q5128376;

import java.util.Arrays;

public class Tuple<T>
{
    private T[] values;
    private int hashCode;

    private Tuple(T... values)
    {
        this.values = values;
        this.hashCode = hashCode(values);
    }

    public static <T> Tuple<T> create(T... values)
    {
        return new Tuple<T>(values);
    }

    private static <T> int hashCode(T... values)
    {
        return 31 * Arrays.hashCode(values);
    }

    @Override
    public int hashCode()
    {
        return hashCode;
    }

    @Override
    public boolean equals(Object obj) 
    {
        if (this == obj) return true;
        if (!(obj instanceof Tuple<?>)) return false;
        Tuple<?> other = (Tuple<?>) obj;
        if (!Arrays.equals(values, other.values)) return false;
        return true;
    }
}