Which is Good for Performance?

Question

Hi,
I am bit confused about this code from performance point of view, say If I write like this :
for(int i=0;i<1000;i++)
  //declaring variables in the loop
  int j, k;
  double d;
  CustomClassObj classObj = new CustomClassObj();
}And if I declare all the variables before the loop like this
//declaring variables before the loop
int j, k;
  double d;
  CustomClassObj classObj = new CustomClassObj();
for(int i=0;i<1000;i++)
}so which is faster from performnace point of view? As I have read some white papers and books, but some says the local variables (insode loops) are better as GC will deallocate those variables after loop.
And some suggest that dont create temporary objects inside loop... :(
Please help...!
Thanks in Advance.

Answer 1

Java_Cup wrote:
so which is faster from performnace point of view? As I have read some white papers and books, but some says the local variables (insode loops) are better as GC will deallocate those variables after loop.If they said that, then they were worthless. GC doesn't touch local variables. And if it did, it would be slower, because you'd have one GC task per loop iteration, rather than simply one at the end.
All the local variables used in a method are allocated in one shot when the method starts, by moving the stack pointer by an amount determined at compile time, and they are all released when the method ends by moving it back by the same amount.
It also looks like you may be confusing variables with objects.
>
And some suggest that dont create temporary objects inside loop... :(Well, that depends. If you need one object across the entire life of the loop, you might get better performance by creating it before the loop starts. I wouldn't generally do that though unless I knew that creating that object was expensive relative to the rest of the work being done in the loop. I'd stick with creating it inside the loop, where it's actually used. And of course if your logic dictates a different object for each iteration, then you have to do it inside the loop anyway.
At the end of the day, these microoptimizations don't become relevant until you observe a performance problem, profile it, and confirm by measurement, changing the code, and re-profiling, that it is in fact a problem.