Is it inefficient to reference a hashmap in another class multiple times?

Question

Class A

Class A {
    public HashMap <Integer,Double> myHashMap;

public A(){
    myHashMap = new HashMap()
}
}

class B

Class B {
    private A anInstanceOfA;

public B(A a) {
    this.anInstanceOfA = a;
}


aMethod(){  
     anInstanceOfA.myHashMap.get(1); <--getting hashmap value for key = 1

      //proceed to use this value, but instead of storing it to a variable
      // I use anInstanceOfA.myHashMap.get(1) each time I need that value.
}

In aMethod() I use anInstanceOfA.myHashMap.get(1) to get the value for key = 1. I do that multiple times in aMethod() and I'm wondering if there is any difference in efficiency between using anInstanceOfA.myHashMap.get(1) multiple times or just assigning it to a variable and using the assigned variable multiple times.

I.E

aMethod(){
     theValue = anInstanceOfA.myHashMap.get(1);

     //proceed to use theValue in my calculations. Is there a difference in efficiency?
}

Answer 1

In theory the JVM can optimise away the difference to be very small (compared to what the rest of the program is doing). However I prefer to make it a local variable as I believe it makes the code clearer (as I can give it a meaningful name)

I suggest you do what you believe is simpler and clearer, unless you have measured a performance difference.

Answer 2

The question seems to be that you want to know if it is more expensive to call get(l) multiple times instead of just once.

The answer to this is yes. The question is if it is enough to matter. The definitive answer is to ask the JVM by profiling. You can, however, guess by looking at the get method in your chosen implementation and consider if you want to do all that work every time.

Note, that there is another reason that you might want to put the value in a variable, namely that you can give it a telling name, making your program easier to maintain in the future.

Answer 3

This seems like a micro-optimization, that really doesn't make much difference in the scheme of things.

As @peter already suggested, 'optimizing' for style/readability is a better rationale for choosing the second option over the first one. Optimizing for speed only starts making sense if you really do a lot of calls, or if the call is very expensive -- both are probably not the case in your current example.

Answer 4

Put it in a local variable, for multiple reasons:

• It will be much faster. Reading a local variable is definitely cheaper than a HashMap lookup, probably by a factor of 10-100x.
• You can give the local variable a good, meaningful name
• Your code will probably be shorter / simpler overall, particularly if you use the local variable many times.
• You may get bugs during future maintenance if someone modifies one of the get calls but forgets to change the others. This is a problem whenever you are duplicating code. Using a local variable minimises this risk.
• In concurrent situations, the value could theoretically change if the HashMap is modified by some other code. You normally want to get the value once and work with the same value. Although if you are running into problems of this nature you should probably be looking at other solutions first (locking, concurrent collections etc.)