Map with combination of enums as keys

Question

I was wondering if there exists any Map<K, V> implementation that takes a combination of 2 or more enums for its key.

I'll provide a simplified example.

Say I have two enums DiceEyes and CardSuit:

public enum DiceEyes {
    ONE, TWO, THREE, FOUR, FIVE, SIX
}

public enum CardSuit {
    HEARTS, DIAMONDS, SPADES, CLUBS
}

Now I have 6 * 4 = 24 images from which I would like to show exactly one, based on what a user selected in a GUI - he selects a DiceEyes and a CardSuit.

I have no control over the filenames of the images. So I cannot be smart by naming the images <DiceType>-<CardSuit>-.png or whatsoever. Therefore I need a mapping of the combination of a DiceType and a CardSuit to the filename.

I have already thought about a solution that operates on an EnumMap of EnumMaps:

EnumMap<DiceType, EnumMap<CardSuit, String>> ... = new ...;

But that looks overcomplicated to me. A colleague would then think that DiceType is more or less important than a CardSuit, looking at the order of the types.

Introducing a wrapper class for just this purpose also seems like overkill to me. When I have to use it in a Map, I would need to implement equals() and hashCode() which for this purpose seems just too much. With an enum you are already guaranteed of object equality, so I would like to stay with the enums.

How can this be achieved without introducing a specific class or too much overhead?

Answer 1

I would create a Pair<A, B> class and then you can use a map on that:

Map<Pair<DiceEyes, CardSuit>, String> = new HashMap<>();

Answer 2

I've been known to implement an ArrayKey object which allows me to use an array as a key in maps etc.

public class ArrayKey {
   private Object[] array;
   public ArrayKey(Object... array) {
       this.array = array;
   }
   public boolean equals(Object other) { ... }
   public int hashCode() { ...}
   public Object[] getArray() { return array; }
}

Then you could do:

Map<ArrayKey, String> map = new HashMap();
map.put(new ArrayKey(DiceEyes.ONE,CardSuit.HEARTS), "/path/to/file.jpg");
map.get(new ArrayKey(DiceEyes.ONE,CardSuit.HEARTS));

Of course, this could be extended to create an ArrayKeyMap for convenience

public class ArrayKeyMap<T> {
   private Map<ArrayKey, T> map = new HashMap();
   public T put(Object... key, T value) {
      return map.put(new ArrayKey(key), value);
   }
   public T get(Object... key) {
      return map.get(new ArrayKey(key));
   }
}

Answer 3

What about using the method Enum.name() to create Strings as keys?

String key=DiceEyes.ONE.name()+CardSuit.HEARTS.name(); //"ONEHEARTS".

Answer 4

Unfortunately this kind of flexibility is not possible. Map is defined as <K, V> and basically that's that. The only ways are what you've presented: create a key object or use a map of maps. (Alternatively I suppose you could also write your own Map implementation.)

Since you are using enum it's actually convenient to make a wrapper object, but I'd recommend a slight twist on it. You can make it immutable and only have a single instance for each pair. This will avoid object creation. You can override equals if you want but since there will only be one of each pair, identity would be sufficient. You can use == to compare them which also means you could use IdentityHashMap.

public final class DiceCardPair {
    private final DiceEyes eyes;
    private final CardSuit suit;

    private DiceCardPair(
        final DiceEyes eyes,
        final CardSuit suit
    ) {
        this.eyes = eyes;
        this.suit = suit;
    }

    @Override
    public int hashCode() {
        // very compact hash code
        // make shift bigger if more constants
        return eyes.ordinal() | suit.ordinal() << 3;
    }

    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof DiceCardPair)) {
            return false;
        }

        DiceCardPair pair = (DiceCardPair)obj;
        return eyes == pair.eyes && suit == pair.suit;
    }

    private static final DiceCardPair[][] values;
    static {
        DiceEyes[] eyes = DiceEyes.values();
        CardSuit[] suits = CardSuit.values();

        values = new DiceCardPair[eyes.length][suits.length];
        for(int i = 0; i < values.length; i++) {
            for(int k = 0; k < values[i].length; k++) {
                values[i][k] = new DiceCardPair(
                    eyes[i], suits[k]
                );
            }
        }
    }

    public static DiceCardPair valueOf(DiceEyes e, CardSuit s) {
        return values[e.ordinal()][s.ordinal()];
    }
}

You don't even really have to use the instances of a class like this directly either, for example:

Value v = map.get(DiceCardPair.valueOf(DiceEyes.ONE, CardSuit.SPADES));
if(v == null) {
    map.put(DiceCardPair.valueOf(DiceEyes.ONE, CardSuit.SPADES), new Value());
}

Answer 5

The actual question

How can this be achieved without introducing a specific class or too much overhead?

was already answered: Not at all.

So although it was explicitly excluded from the question, I'd like to throw in a generic Pair class that can come in handy for cases like this one.

final class Pair<T>
{
    public static <T, TT extends T> Pair<T> of(TT t0, TT t1)
    {
        return new Pair<T>(t0, t1);
    }

    private final T first;
    private final T second;

    private Pair(T first, T second)
    {
        this.first = first;
        this.second = second;
    }


    @Override
    public String toString()
    {
        return "(" + first + "," + second + ")";
    }

    @Override
    public boolean equals(Object object)
    {
        if(object instanceof Pair)
        {
            Pair<?> other = (Pair<?>) object;
            return 
                equal(this.first, other.first) && 
                equal(this.second, other.second);
        }
        return false;
    }

    private static <U> boolean equal(U a, U b)
    {
        if (a == null)
        {
            return b == null;
        }
        return a.equals(b);
    }


    @Override
    public int hashCode()
    {
        return
            ((first == null) ? 0 : first.hashCode()) ^ 
            ((second == null) ? 0 : second.hashCode());
    }

    public T getFirst()
    {
        return first;
    }

    public T getSecond()
    {
        return second;
    }
}

Answer 6

Use a Pair class for key. You can reuse it elsewhere, so it's not an overkill. Unfortunately, Java does not have built-in implementation like other languages (c++, c#), but there's a straight forward one in this post:

A Java collection of value pairs? (tuples?)