Data Structures – Best Way to Store 2 Keys and 3 Values in Java

data structuresenumjava

Well, I am having two keys and 3 values for that. Say key1,key2,value1,value2,value3. In future may the values can be increased like value4, value5 so on.

I need to get the values(value1,value2,value3) either by key1 or key2. The key1 will be unique, and key2 is not.

Currently, I am using ENUM for this configuration as like below

public enum EnumClass { Object1(Key1,Key2,Value1,Value2,Value3); }

There will be more than 100 objects. As of now, I am using this ENUM class with 2 maps Map<key1,ENUM> and Map<key2,ENUM>

Is there any other solution that is better than the current solution?

Best Answer

If key2 is not unique, you can't use a Map to store a key2 -> (value1,value2,value3) relationship, since a Map asserts a 1-1 key/value relationship.

I would not worry about performance initially, since you have 100's of objects (as opposed to millions), and I would prefer simplicity/readability to begin with. Hide your lookup behind an interface (so that you can change your implementation later if you wish/need), and perhaps simply store a table of key1/key2/values, and perform your lookup against that simply by iterating through and building a list of matches.

Your repository methods would look something like:

ResultType byKey1(Key k);
Collection<ResultType> byKey2(Key k);

If key1 and key2 are distinct, you could implement a faster lookup by doing something like:

Map<Key,List<ResultType>>

so a lookup by key1 would give you a list of one (value1/value2/value3), whereas a lookup by key2 would give you a list of 'n' (value1/value2/value3). That would require a more complex initial data setup however. Hence I would suggest an initial simple table implementation behind a facade. You can implement optimisations later as required.

Related Solutions

Question, the best data structure and algorithm

Why not use balanced trees? You would need one tree at each store, mapping item ID to some internal information, and one global tree, mapping item ID to the list of the nodes having the given item. Your operations will be O(log n + log k).

Edit:
the operations in this case would look like the following: (I use the fact that std::map and std::set are tree-based in C++)

using namespace std;

typedef int itemid_t;
typedef int storeid_t;

map<itemid_t, set<storeid_t>> itemID2storeList;

class Store
{
    storeid_t Id;

    // insert requires one lookup in the map (O(log k))
    // plus one insert into a set (O(log n)).
    void insert(itemid_t item)
    {
        itemID2storeList[item].insert(Id);
    }

    // the same as for insert
    void delete(itemid_t item)
    {
        itemID2storeList[item].erase(Id);
    }

    // search in a store requires one lookup in a map (O(log k))
    // and one search in a set (O(log n)).
    bool have(itemid_t item)
    {
        const set<storeid_t>& storesForItem = itemID2storeList[item];
        return storesForItem.find(Id) != storesForItem.end();
    }
}

class Central
{
    // getting the list of stores having the given item requires
    // one lookup in a map (O(log k))
    const set<storeid_t>& storesForItem(itemid_t item)
    {
        return itemID2storeList[item];
    }
}

Should a String Constant Be Defined if Used Only Once?

Try this. The initial reflection is certainly expensive, but if you're going to use it many many times, which I think you will, this is most certainly a better solution what what you're proposing. I don't like using reflection, but I find myself using it when I don't like the alternative to reflection. I do think that this will save your team a lot of headache, but you must pass the name of the method (in lowercase).

In other words, rather than pass "name", you would pass "fullname" because the name of the get method is "getFullName()".

Map<String, Method> methodMapping = null;

public Object getNode(String name) {
    Map<String, Method> methods = getMethodMapping(contact.getClass());
    return methods.get(name).invoke(contact);
}

public Map<String, Method> getMethodMapping(Class<?> contact) {
    if(methodMapping == null) {
        Map<String, Method> mapping = new HashMap<String, Method>();
        Method[] methods = contact.getDeclaredMethods();
        for(Method method : methods) {
            if(method.getParameterTypes().length() == 0) {
                if(method.getName().startsWith("get")) {
                    mapping.put(method.getName().substring(3).toLower(), method);
                } else if (method.getName().startsWith("is"))) {
                    mapping.put(method.getName().substring(2).toLower(), method);
                }
            }
        }
        methodMapping = mapping;
    }
    return methodMapping;
}

If you need to access data contained within members of contact, you might consider building a wrapper class for contact which has all methods to access any information required. This would also be useful for guaranteeing that the names of the access fields will always remain the same (I.e. if wrapper class has getFullName() and you call with fullname, it will always work even if contact's getFullName() has been renamed -- it would cause compilation error before it would let you do that).

public class ContactWrapper {
    private Contact contact;

    public ContactWrapper(Contact contact) {
        this.contact = contact;
    }

    public String getFullName() {
        return contact.getFullName();
    }
    ...
}

This solution has saved me several times, namely when I wanted to have a single data representation to use in jsf datatables and when that data needed to be exported into a report using jasper (which doesn't handle complicated object accessors well in my experience).

Best Answer

Related Solutions

Question, the best data structure and algorithm

Should a String Constant Be Defined if Used Only Once?

Related Topic