CODEWITHSUNDEEP
javahashmap
NoobEditor
NoobEditor

Reputation: 15891

Reset all values in hashmap without iterating?

I am trying reset all values in a HashMap to some default value if a condition fails.

Currently i am doing this by iterating over all the keys and individually resetting the values.
Is there any possible way to set a same value to all the keys without iterating?

Something like:

hm.putAll("some val")  //hm is hashmap object

Upvotes: 6

Views: 10200

Answers (6)

palako
palako

Reputation: 3470

Assuming that your problem is not with doing the iteration yourself, but with the fact that O(n) is going on at some point, I would suggest a couple of alternative approaches. Bear in mind I have no idea what you are using this for, so it might not make any sense to you.

Case A: If your set of keys is known and fixed beforehand, keep a copy (not a reference, an actual clone) somewhere with the values reset to the one you want. Then on that condition you mention, simply switch the references to use the default one.

Case B: If they keys change over time, use the idea from case A but add new entries with the default value for every new key added (or remove accordingly). Your updates should hardly notice but you can still switch back to the default in O(1).

Upvotes: 0

Alexis C.
Alexis C.

Reputation: 93842

You can't avoid iterating but if you're using , you could use the replaceAll method which will do that for you.

Apply the specified function to each entry in this map, replacing each entry's value with the result of calling the function's Function#map method with the current entry's key and value.

m.replaceAll((k,v) -> yourDefaultValue);

Basically it iterates through each node of the table the map holds and affect the return value of the function for each value.

@Override
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
    Node<K,V>[] tab;
    if (function == null)
        throw new NullPointerException();
    if (size > 0 && (tab = table) != null) {
        int mc = modCount;
        for (int i = 0; i < tab.length; ++i) {
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                e.value = function.apply(e.key, e.value); //<-- here
            }
        }
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }
}

Example:

public static void main (String[] args){ 
    Map<String, Integer> m = new HashMap<>();
    m.put("1",1);
    m.put("2",2);

    System.out.println(m);
    m.replaceAll((k,v) -> null);
    System.out.println(m);
}

Output:

{1=1, 2=2}
{1=null, 2=null}

Upvotes: 9

ganzux
ganzux

Reputation: 904

IMHO You must create your own Data Structure that extends from Map. Then you can write your method resetAll() and give the default value. A Map is a quick balanced tree that allows you to walk quick in the structure and set the value. No worries about the speed, because the tree will have the same structure before and after the reset. Only, be carefull with concurrent threads. Maybe you should use ConcurrentHashMap.

public class MyMap<K,V> extends ConcurrentHashMap<K, V>{

  public void resetAll(V value){
    Iterator<Entry<K, V>> it = this.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry pairs = (Map.Entry)it.next();
        pairs.setValue( value );
    }
  }

}

Regards

Upvotes: 1

dimo414
dimo414

Reputation: 48824

It is not possible to apply an operation to all values in a collection in less than O(n) time, however if your objection is truly with iteration itself, there are some possible alternatives, notably functional programming.

This is made most easy by the Guava library (or natively in Java 8), and their functional programming utilities. Their Maps.transformValues() provides a view of the map, with the provided function applied. This means that the function returns in O(1) time, unlike your iteration, but that the computation is done on the fly whenever you .get() from the returned map. This is obviously a tradeoff - if you only need to .get() certain elements from the transformed map, you save time by avoiding computing unnecessary values. On the other hand, if you know you'll later hit every element at least once, using this behavior means you'll actually waste time. In essence, this approach is O(k) where k is the number of lookups you plan to do. If k is always less than n, then using the transformation approach is optimal.

Read carefully however the caveat at the top of the page; iteration is a simple, easy, and generally ideally efficient way to work with the members of a map. You should only try to optimize past that when absolutely necessary.

Upvotes: 0

Khobar
Khobar

Reputation: 476

If you're willing to make a copy of it ( a hasmap with default values ) You can first clear your hashmap and then move over the default values 

hm.keySet().removeAll();
hm.putAll(defaultMap);

Upvotes: 0

Brian Agnew
Brian Agnew

Reputation: 272287

You can't avoid iterating in some fashion.

You could get the values via Map.values() and iterate over those. You'll bypass the lookup by key and it's probably the most efficient solution (although I suspect generally that would save you relatively little, and perhaps it's not the most obvious to a casual reader of your code)

Upvotes: 6

Related Questions