What is the best way to cache and reuse immutable singleton objects in Java?

Question

I have a class representing a set of values that will be used as a key in maps.

This class is immutable and I want to make it a singleton for every distinct set of values, using the static factory pattern. The goal is to prevent identical objects from being created many (100+) times and to optimize the equals method.

I am looking for the best way to cache and reuse previous instances of this class. The first thing that pops to mind is a simple hashmap, but are there alternatives?

Answer 1

There are two situations:

• If the number of distinct objects is small and fixed, you should use an enum
  • They're not instantiatiable beyond the declared constants, and EnumMap is optimized for it
• Otherwise, you can cache immutable instances as you planned:
  • If the values are indexable by numbers in a contiguous range, then an array can be used
    • This is how eg Integer cache instances in a given range for valueOf
  • Otherwise you can use some sort of Map

Depending on the usage pattern, you may choose to only cache, say, the last N instances, instead of all instances created so far. This is the approach used in eg re.compile in Python's regular expression module. If N is small enough (eg 5), then a simple array with a linear search may also work just fine.

For Map based solution, perhaps a useful implementation is java.util.LinkedHashMap , which allows you to enforce LRU-like policies if you @Override the removeEldestEntry .

There is also LRUMap from Apache Commons Collections that implement this policy more directly.

See also

• Java Tutorials/ enums
• Effective Java 2nd Edition, Item 1: Consider static factory methods instead of constructors
• Wikipedia/Flyweight pattern

Related questions

• Easy, simple to use LRU cache in java
• LRU LinkedHashMap that limits size based on available memory
  • Guava MapMaker , soft keys and values, etc
• How would you implement an LRU cache in Java 6?

Answer 2

What you're trying to make sounds like an example of the Flyweight Pattern , so looking for references to that might help clarify your thinking.

Storing them in a map of some sort is indeed a common implementation.

Answer 3

What do your objects look like? If your objects are fairly simple I think you should consider not caching them - object creation is usually quite fast. I think you should evaluate whether the possibly small performance boost is worth the added complexity and effort of a cache.