Which would you do ?
doThings(folder.getInstructions()) ;
for (Instruction instruction : folder.getInstructions()) {
// do things
}
functionCall(folder.getInstructions()) ;
Or this :
instructions = folder.getInstructions() ;
doThings(instructions)
for (Instruction instruction : instructions) {
// do things
}
functionCall(instructions) ;
Above all, I would like to know when it is more efficient to store a value in a local variable, and when it is better to make function calls.
More readable is more efficient. Temporary expressions and local variables need the same space and from CPU/JVM perspective it doesn't make much difference. JVM will do a better job optimizing/inling it.
However if getInstructions() method call is expensive, cache it in local variable. If it's just a plain getter, it will be inlined anyway. Also IMHO in your particular case local variable is more readable and maybe even more correct if getInstructions() may have different results over time.
That entirely depends on what getInstructions() does. If it's just returning the value of a field - and if you're confident that the field value won't change between calls - then you probably won't see any efficiency differences between the two snippets.
If, on the other hand, getInstructions() needs to make a dozen web requests, then clearly you want to avoid calling that several times.
Readability is more important than efficiency though. In this case I find the second option more readable anyway - it's clearer that you want to take three separate steps (two method calls and a loop) with the same value. On the other hand, I'm quite happy to write something like:
for (int i = 0; i < text.length(); i++) {
...
}
rather than breaking that out into a separate variable:
int length;
for (int i = 0; i < length; i++) {
...
}
It really depends on the context. Sometimes an extra variable helps, sometimes it doesn't, from a readability perspective. The efficiency perspective depends completely on what the method call is doing, and whether it's "inlinable" for the JIT.
My answer would be dependent on what type of application that I am trying to develop. For example,
The first code block is better if the values are changes rapidly during the application. This is good if you need accurate results.
The second one is good if you are sure that the values initially fetched would not affect the other parts of the code.
Whenever, you want to use the result of a method more than once, its better to store the result of method invocation in some temp variable.. This saves processing time of method invocation.. This will not affect as much in this case.. But may affect when there are many invocation..
Also, remember, your local variables are stored on stack. So, having a temporary local variable is occupying space on stack. Although this is not much of a concern in small cases like this one.. But unneccessary local variables, should be avoided..
So, there are pros and cons of both methods..
I believe it depends upon the situation. if it requires to make the same method call many times(and you are getting the same value) and better make one call and store it into some local variable.
and if you need to call the function only once. no need to go for local variables.
