Java HashMap in methods

Question

Is it possible to have a method requiring a HashMap and be able to provide any HashMap with Strings as keys? Some kind of generic data Type to put instead of 'Value'?

public void example(HashMap<String, Value> hashMap) {
    //Stuff
}

example(new HashMap<String, Integer>);
HashMap<String, String> exampleMap = new HashMap<>();
example(exampleMap);

Alternatively, is it possible to check the key/value type of the map, other than looping through all the keys/value and check instanceof (without stopping it with return)?

public Boolean example(HashMap<String, Value> hashMap) {
    for (Value value : hashMap.values())) {
        if (value instanceof String) {
            return true; //<- Unwanted
        }
    }
}

EDIT: Let me explain my problem a bit further. I have a method:

public static Object getEIC(HashMap<String, Object> map, String key) {
    for (String keys : map.keySet()) {
        if (keys.equalsIgnoreCase(key)) {
            return map.get(keys);
        }
    }
    return null;
}

EIC stands for equalsIgnoreCase. So I need some generic return Type as well. Thanks for the answers so far, and thanks on forehand for the answers on this!

Well, you can have `public void example(HashMap hashMap)`; however I fail to see what you require a `HashMap` instead of a regular `Map` — fge, Oct 30 '14 at 21:15
Are you just trying to implement a Map where you want to have case-insensitive keys? If so have a look at http://stackoverflow.com/questions/8236945/case-insensitive-string-as-hashmap-key — David Brossard, Oct 30 '14 at 21:31

score 3 · Answer 1 · edited May 23 '17 at 10:25

You could do:

HashMap<String, Object>

But that's terrible though because then you end up doing instanceof all the time. What you really need to do is understand what the key problem is and then think of inheritance. Can you define an interface that all your value objects would implement? For instance GeometricShape which could be implemented by Rectangle and Circle.

Also, you can define a HashMap as follows:

HashMap<String, ? extends SomeClass>

And as others pointed out, it's best to use the interface Map rather than a specific implementation e.g. HashMap.

Lastly, as I pointed out in a comment, it seems you are just trying to implement a Map<key, value> where you want to have case-insensitive keys. If so have a look at www.stackoverflow.com/questions/8236945/

candied_orange · Answer 2 · 2014-10-31T09:09:51.293

Yes, but requiring Map<String, Value> is better. If you don't care what value is ask for Map<String, ?>. If you do but don't yet know what it will be, use Map<String, ? extends T>

Requiring HashMap is programing to an implementation rather than an interface. There is rarely a good reason to do that.

And no. If you don't trust whoever built the map and want to be sure the map contains only the types it's supposed to contain you have to loop and check each one. However, you can abstract that away in a method that will check for you so you don't have to look at it.

public class CheckedCast
{

    public static <K,V> Map<K,V> mapOf(Class<? extends K> classK, 
                                       Class<? extends V> classV, 
                                       Map<?,?> m)
    {
        for (Map.Entry<?, ?> e: m.entrySet())
        {
            classK.cast( e.getKey() );
            classV.cast( e.getValue() );
        }

        @SuppressWarnings("unchecked")
        Map<K,V> result = (Map<K,V>) m;
        return result;

    }
}

score 0 · Answer 3 · answered Oct 30 '14 at 21:37

0

The answer is to use a CaseInsensitiveMap. Thanks, everyone, for helping me and especially David Brossard for suggesting this.

answered Oct 30 '14 at 21:37

Anrza

11
2

score 0 · Answer 4 · edited May 23 '17 at 11:49

You can implement the static method you are looking for using generics:

public static <V> V getEIC(Map<String, V> map, String key) {
    for (String k : map.keySet()) {
        if (k.equalsIgnoreCase(key)) {
            return map.get(key);
        }
    }
    return null;
}

however, you may wish to consider an enhanced Map Is there a good way to have a Map<String, ?> get and put ignoring case?

Note, however, that there is a subtle difference between this solution and using case-less equals - an ordinary Map<String,V> could hold a value for "Key" and "key" while a case-less Map would not. This method would arbitrarily choose one of them while a case-less Map would choose the most recent addition.

Java HashMap in methods

4 Answers4