Looking for a "chained map" implementation in Java

Question

I need a mapping from a list of keys to a value. I know I could write my own code like this:

Map<Person, Map<Daytime, Map<Food, Integer>>> eaten = ...;

Now I want to have some get and put methods like these:

Integer numberOfEggsIAteInTheMorning = eaten.get(me, morning, scrambledEggs);
eaten.put(me, evening, scrambledEggs, 1);

Do you know of an existing class that has this kind of API? I'm too lazy of writing it myself. ;)

Answer 1

I once made a map using 3 keys just for fun.May be you can use it instead of using chained maps:

public class ThreeKeyMap<K1,K2,K3,V>{

class wrap{
    K1 k1;
    K2 k2;
    K3 k3;
    public wrap(K1 k1,K2 k2,K3 k3) {
        this.k1=k1;this.k2=k2;this.k3=k3;
    }
    @Override
    public boolean equals(Object arg0) {
        // TODO Auto-generated method stub
        wrap o=(wrap)arg0;
    if(!this.k1.equals(o.k1))
        return false;
    if(!this.k2.equals(o.k2))
        return false;
    if(!this.k2.equals(o.k2))
        return false;
    return true;

    }
    @Override
    public int hashCode() {
        int result=17;
        result=37*result+k1.hashCode();
        result=37*result+k2.hashCode();
        result=37*result+k3.hashCode();
        return result;
    }
}
HashMap<wrap,V> map=new HashMap<wrap, V>();

public V put(K1 k1,K2 k2,K3 k3,V arg1) {
    return map.put(new wrap(k1,k2,k3), arg1);
}


public V get(Object k1,Object k2,Object k3) {
    return map.get(new wrap((K1)k1,(K2)k2,(K3)k3));
}

public static void main(String[] args) {
    ThreeKeyMap<Integer,Integer,Integer,String> birthDay=new ThreeKeyMap<Integer, Integer, Integer, String>();
    birthDay.put(1, 1,1986,"Emil");
    birthDay.put(2,4,2009, "Ansih");
    birthDay.put(1, 1,1986,"Praveen");
    System.out.println(birthDay.get(1,1,1986));
}
}

UPDATE:

As @Arturs Licis suggested.I looked up in net for composite pattern and I wrote a sample using it.I guess this is composite..Please comment if it is not so.

Person class:

public class Person {
    private final String name;
    private Map<Time, Food> map = new HashMap<Time, Food>();

    public Person(String name) {
        this.name = name;
    }

    void addTimeFood(Time time, Food food) {
        map.put(time, food);
    }

    public String getName() {
        return name;
    }

    Food getFood(Time time) {
        Food tmp = null;
        return (tmp = map.get(time)) == null ? Food.NoFood : tmp;
    }
    // main to test the person class
    public static void main(String[] args) { 
        Person p1 = new Person("Jack");
        p1.addTimeFood(Time.morning, Food.Bread);
        p1.addTimeFood(Time.evening, Food.Chicken);

        Person p2 = new Person("Jill");
        p2.addTimeFood(Time.morning, Food.Egg);
        p2.addTimeFood(Time.evening, Food.Rice);

        Map<String, Person> map = new HashMap<String, Person>();
        map.put(p1.getName(), p1);
        map.put(p2.getName(), p2);
        System.out.println(map.get("Jack").getFood(Time.evening));
    }

    @Override
    public String toString() {
        StringBuilder b = new StringBuilder();
        b.append(name).append("\n");
        b.append(map);
        return b.toString();
    }
}

Food class:

public enum Food {
Rice,
Egg,
Chicken,
Bread,
NoFood;
}

Time class:

public enum Time {
morning,
evening,
night
}

Answer 2

If you look for a more generic approach, and you might have more than 2 or 3 'chain steps', I would suggest in applying some different structural approach, rather than sticking to using only basic collection classes. I have feeling that Composite Pattern could be the right choice if it's correctly applied.

EDIT: due to example requested

The full example would be somewhat time consuming, so let me just explain my idea with dirty Java/pseudocode mix (I'm not even sure if I've missed something!!!). Let's consider we have class BaseMap:

abstract class BaseMap { 
    public abstract Object getValue(Object.. keys);
    public abstract void putValue(Object value, Object.. keys);
}

Then we could have ObjectMap that would be the 'leaf' of our composite structure:

class ObjectsMap extends BaseMap {
    private Map<Object, Object> map = new [...]
    public Object getValue(Object.. keys) {
        // assert that keys.length == 1
        return map.get(keys[0]);
    }
    public void putValue(Object value, Object.. keys) {
        // assert that keys.length = 1
        map.put(keys[0], value);
    }
}

And the actual composite would be as such:

class CompositeMap extends BaseMap {
    private Map<Object, BaseMap> compositeMaps = new [...]
    public Object getValue(Object.. keys) {
        // assert that keys.length > 1
        return compositeMap.get(keys[0]).getValue(/* System.arrayCopy => subset of elements {keys_1, .. ,keys_max} */);
    }
    public void putValue(Object value, Object.. keys) {
        // assert keys.length > 1
        BaseMap newMap = null;
        if (keys.length = 2) -> newMap = new ObjectsMap()
        else newMap = new CompositeMap();
        newMap.putValue(value, /*subset of keys {keys_1, .. , keys_max}*/);

    }
}

Answer 3

You can use org.apache.commons.collections.keyvalue.MultiKey for that: Map<Multikey, Object>

Answer 4

It would be hard to implement a general chained map.

How would the declaration of the class look like? (You can't have a variable number of type parameters.

class ChainedMap<K1..., V>

---

Another option would be to have a ChainedMapUtil class that performs put / get recursively.

Here is an example of a recursive get. (Quite ugly solution though I must say.)

import java.util.*;

public class Test {

    public static Object chainedGet(Map<?, ?> map, Object... keys) {

        Object k = keys[0];

        if (!map.containsKey(k)) return null;

        if (keys.length == 1) return map.get(k);

        Object[] tailKeys = Arrays.copyOfRange(keys, 1, keys.length);
        return chainedGet((Map<?,?>) map.get(k), tailKeys);        
    }

    public static void main(String[] arg) {

        Map<String, String> m1 = new HashMap<String, String>();
        m1.put("ipsum", "dolor");

        Map<Integer, Map<String, String>> m2 =
                new HashMap<Integer, Map<String, String>>();
        m2.put(17, m1);

        Map<String, Map<Integer, Map<String, String>>> chained =
            new HashMap<String, Map<Integer, Map<String, String>>>();
        chained.put("lorem", m2);

        System.out.println(chainedGet(chained, "lorem", 17, "ipsum")); // dolor
        System.out.println(chainedGet(chained, "lorem", 19, "ipsum")); // null
    }
}

Answer 5

If you are going to write your own, I would suggest

eaten.increment(me, evening, scrambledEggs);

You could use a composite key

eaten.increment(Key.of(me, evening, scrambledEggs));

(TObjectIntHashMap supports increment and adjust)

You may not even need a custom key.

eaten.increment(me + "," + evening + "," + scrambledEggs);

It is fairly easy to decompose the key with split()