CODEWITHSUNDEEP
java
Ben P
Ben P

Reputation: 115

Memory/Performance differences of declaring variable for return result of method call versus inline method call

Are there any performance or memory differences between the two snippets below? I tried to profile them using visualvm (is that even the right tool for the job?) but didn't notice a difference, probably due to the code not really doing anything.

Does the compiler optimize both snippets down to the same bytecode? Is one preferable over the other for style reasons?

boolean valid = loadConfig();
if (valid) {
    // OK
} else {
    // Problem
}

versus

if (loadConfig()) {
    // OK
} else {
    // Problem
}

Upvotes: 2

Views: 425

Answers (2)

GhostCat
GhostCat

Reputation: 140623

The real answer here: it doesn't even matter so much what javap will tell you how the corresponding bytecode looks like!

If that piece of code is executed like "once"; then the difference between those two options would be in the range of nanoseconds (if at all).

If that piece of code is executed like "zillions of times" (often enough to "matter"); then the JIT will kick in. And the JIT will optimize that bytecode into machine code; very much dependent on a lot of information gathered by the JIT at runtime.

Long story short: you are spending time on a detail so subtle that it doesn't matter in practical reality.

What matters in practical reality: the quality of your source code. In that sense: pick that option that "reads" the best; given your context.

Given the comment: I think in the end, this is (almost) a pure style question. Using the first way it might be easier to trace information (assuming the variable isn't boolean, but more complex). In that sense: there is no "inherently" better version. Of course: option 2 comes with one line less; uses one variable less; and typically: when one option is as readable as another; and one of the two is shorter ... then I would prefer the shorter version.

Upvotes: 3

thomas.mc.work
thomas.mc.work

Reputation: 6474

If you are going to use the variable only once then the compiler/optimizer will resolve the explicit declaration.

Another thing is the code quality. There is a very similar rule in sonarqube that describes this case too:

Local Variables should not be declared and then immediately returned or thrown

Declaring a variable only to immediately return or throw it is a bad practice. Some developers argue that the practice improves code readability, because it enables them to explicitly name what is being returned. However, this variable is an internal implementation detail that is not exposed to the callers of the method. The method name should be sufficient for callers to know exactly what will be returned.

https://jira.sonarsource.com/browse/RSPEC-1488

Upvotes: 2

Related Questions