Local variables or class fields?

The performance is down to the number of steps required to get the variable. Local variable addresses are known at compile time (they are a known offset on the stack), to access a member you load the object 'this' to get the address of the actual object, before you can get the address of the member variable.

In C# another minor difference is the number of generated MSIL instructions (I guess it's similar in Java).

It takes two instructions to load an instance field:

ldarg.0                 // load "this" reference onto stack
ldfld   MyClass.myField // find the field and load its value

...but it only takes one instruction to load a local variable:

ldloc.0                 // load the value at index 0 from the list of local variables

1. Stack faster then Heap.

   void f()
   {
       int x = 123; // <- located in stack
   }
   
   int x; // <- located in heap
   void f()
   {
       x = 123  
   }
   

2. Do not forget the principle of locality data. Local data should be better cached in CPU cache. If the data are close, they will loaded entirely into the CPU cache, and the CPU does not have to get them from memory.

Even if it will be, there will be almost non measurable difference in this cases. Probabbly in first case, there is some optimization done on processor registry level, but again:

• it's almost irrelevant
• and what is more important, often unpredictable.

In terms of memory, it's exactly the same, there is no any difference.

The first case it generaly better: as you declare variable there were it's imediately used, which is commonly used good pattern, as it's

• easy to understand (scopes of responsibilities)
• easy refactor