Java android optimization. Non-static or static method?

It depends on how you use static variables and method in your code.

Instance variables and objects are stored on the heap. Local variables are stored on the stack.

Static variables are stored in a permanent area on heap. The garbage collector works by marking and sweeping objects. Static variables cannot be elected for garbage collection while the class is loaded. They can be collected when the respective class loader (that was responsible for loading this class) is itself collected for garbage.

If i have a value to be passed to another activity i would use intents instead of static variables.

In a custom list adapter we use a static viewholder. So using static variables or methods depends on different situation.

You can analyze memory usage by objects using a tool called MAT Analyzer. The video in the below talks about memory management and how to detect and solve memory leaks

http://www.youtube.com/watch?v=_CruQY55HOk.

   MemoryInfo mi = new MemoryInfo();// current memory usage
  ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
  activityManager.getMemoryInfo(mi);
  long availableMegs = mi.availMem / 1048576L;

http://developer.android.com/training/articles/perf-tips.html. Have a look at this link for performance tips especially the topic under Prefer Static Over Virtual.

Memory availabilty is one of the criteria's to be considered using static variables and methods for performance and avoiding memory leaks.

This is really a question about trying to reuse objects. You can reuse objects in a static method too if you declare a static member. Separately: yes it's probably better to design this without static anything.

In any event, the upside to reuse is avoiding object creation. You still pay some cost of "clearing" the object's state. Or else, you risk memory leaks in the case of something like a Stack.

There is an ongoing maintenance issue: you add new state to the object, and, did you remember to update the method that clears it?

You also need to now synchronize access to this method or otherwise prevent two threads from using it at once. That could introduce a bottleneck as threads can't execute the method concurrently.

You also always pay the memory cost of this object living in memory for the entire runtime.

In the olden days, people would create object pool abstractions to avoid recreating objects. This has its own complexity and runtime overhead, and are generally well out of favor, since the cost of creating an object and GCing it is so relatively small now.

Trying to reuse objects solely for performance is rarely a performance win. It would have to be in a tight loop and not suffer from several possible problems above to be worth it.