Any difference in the performance of these two Java segments?

Question

I'm curious to know if either of these two Java method invocations will behave differently at all in terms of processor time, memory allocation and/or garbage collection.

SomeObject myObj = new SomeObject();
myObj.doSomething();

vs.

new SomeObject().doSomething();

Answer 1

No.    

Answer 2

Assuming that myObj doesn't get used for anything else, as I would infer from the nature of your question, you should see no difference. Either way, the only time you should worry about overhead like this would be if this code is in some loop that is executing it over and over, ad nauseum. If that is the case, Java's JIT optimization should take very good care of you and you should see no difference. I prefer to see this code written the way your second example is, but that's just me.

Answer 3

The only difference between the two is that as long as the myObj reference is not cleared and part of an object which has a path to root the allocated object will not be garbage collected.

Answer 4

The difference is exactly 2 JVM bytecodes, which translates to 1 extra machine instruction, which the JIT may optimize away (if you don't do anything else with the variable).

Answer 5

While the generated bytecode may be different, I think that this should be one of the easier things for a jit-compiler to optimize. Depending on what it actually does, even the object creation could be optimized away altogether.

Answer 6

Looking at the generated bytecode:

// code 1
new SomeObject().doSomething();

// bytecode 1
   0:   new #2; //class SomeObject
   3:   dup
   4:   invokespecial   #3; //Method SomeObject."<init>":()V
   7:   invokevirtual   #4; //Method SomeObject.doSomething:()V
   10:  return

You can clearly see that this one has two more instructions:

// code 2
SomeObject myObj = new SomeObject();
myObj.doSomething();

// bytecode 2
   0:   new #2; //class SomeObject
   3:   dup
   4:   invokespecial   #3; //Method SomeObject."<init>":()V
   7:   astore_1
   8:   aload_1
   9:   invokevirtual   #4; //Method SomeObject.doSomething:()V
   12:  return

Those instructions seem very redundant and easy to optimize-out. I'd bet the JIT compiler would handle them if needed.

Answer 7

The first example will be slightly less efficient. In the first example, the object reference will be held until the end of the function or enclosing block. In the second example, the object reference will be available for garbage collection once the call is complete. Of course, it may not actually be garbage collected.

I haven't checked the generated bytecode. There's probably a difference in how Java holds the reference, but in either case I suspect it's trivial.