Java reusing (static?) objects as temporary objects for performance

Question

I need to call methods of a class with multiple methods very often in a simulation loop.

Some of these methods need to access temporary objects for storing information in them. After leaving the method the stored data is not needed anymore. For example:

Class class {      
  method1() {
        ...
        SomeObject temp = new SomeObject();
       ...
  }

  method2() {
        ...
        SomeObject temp = new SomeObject();
        SomeObject temp2 = new SomeObject();
        ...
  }
}

I need to optimize as much as possible. The most expensive (removable) problem is that too many allocations happen. I assume it would be better not to allocate the space needed for those objects every time so I want to keep them.

Would it be more efficient to store them in a static way or not? Like:

Class class {
  private (static?) SomeObject temp;
  private (static?) SomeObject temp2;

  methods...
}

Or is there even a better way? Thank you for your help!

Edit based on answers: Not the memory footprint is the actual problem but the garbage collection cleaning up the mess. SomeObject is a Point2D-like class, nothing memory expensive (in my opinion). I am not sure whether it is better to use (eventually static) class level objects as placeholder or some more advanced method which I am not aware of.

Answer 1

I would be wary in this example of pre-mature optimization. There are downsides, typically, that it makes the code more complex (and complexity makes bugs more likely), harder to read, could introduce bugs, may not offer the speedup you expected, etc. For a simple object such as representing a 2D point coordinate, I wouldn't worry about re-use. Typically re-use gains the most benefit if you are either working with a large amount of memory, avoid lengthy expensive constructors, or are pulling object construction out of a tight loop that is frequently executed.

Some different strategies you could try:

Push responsiblity to caller One way would be to to have the caller pass in an object pre-initialized, making the method parameter final. However, whether this will work depends on what you need to do with the object.

Pointer to temporary object as method parameter Another way would be to have the caller pass as an object as a parameter that's purpose is essentially to be a pointer to an object where the method should do its temporary storage. I think this technique is more commonly used in C++, but works similarly, though sometimes shows up in places like graphics programming.

Object Pool One common way to reuse temporary objects is to use an object pool where objects are allocated from a fixed bank of "available" objects. This has some overhead, but if the objects are large, and frequently used for only short periods of time, such that memory fragmentation might be a concern, the overhead may be enough less to be worth considering.

Member Variable If you are not concerned about concurrent calls to the method (or have used synchronization to prevent such), you could emulate the C++ism of a "local static" variable, by creating a member variable of the class for your storage. It makes the code less readable and slightly more room to introduce accidental interference with other parts of your code using the variable, but lower overhead than an object pool, and does not require changes to your method signature. If you do this, you may optionally also wish to use the transient keyword on the variable as well to indicate the variable does not need to be serialized.

I would shy away from a static variable for the temporary unless the method is also static, because this may have a memory overhead for the entire time your program runs that is undesirable, and the same downsides as a member variable for this purpose x2 (multiple instances of the same class)