Weak hashmap with weak references to the values?

Question

I am building an android app where each entity has a bitmap that represents its sprite. However, each entity can be be duplicated (there might be 3 copies of entity asdf for example).

One approach is to load all the sprites upfront, and then put the correct sprite in the constructors of the entities.

However, I want to decode the bitmaps lazily, so that the constructors of the entities will decode the bitmaps. The only problem with this is that duplicated entities will load the same bitmap twice, using 2x the memory (Or n times if the entity is created n times).

To fix this, I built a SingularBitmapFactory that will store a decoded Bitmap into a hash, and if the same bitmap is asked for again, will simply return the previously hashed one instead of building a new one. Problem with this, though, is that the factory holds a copy of all bitmaps, and so won't ever get garbage collected.

What's the best way to switch the hashmap to one with weakly referenced values? In otherwords, I want a structure where the values won't be GC'd if any other object holds a reference to it, but as long as no other objects refers it, then it can be GC'd.

Answer 1

Pretty much what you said -- make the Bitmap (object side of the map) a WeakReference instead of a Bitmap. Then you have to add an extra check to see if the reference is still valid before passing it back to your entities. Here is a quick sketch of the general idea.

public class SingularBitmapFactory { 
    private HashMap <String, WeakReference<Bitmap>> cache = new HashMap<String, WeakReference<Bitmap>>();

    public Bitmap getBitmap(String key) {
        Bitmap image = null;
        WeakReference<Bitmap> ref = cache.get(key);
        if(ref != null) {
            image = ref.get();
        }
        if(image == null) {
            // Load image here ... 
            cache.put(key, new WeakReference<Bitmap>(image));
        }
        return image;   
    }
}

Answer 2

Old question, but I needed this today, and based on @iagreen's answer I've generalized the idea, maybe it comes in handy to someone ...

public static class WeakValueHashMap<K,V> {
    private HashMap<K,WeakReference<V>> mDatabase=new HashMap<K, WeakReference<V>>();
    public V get(K key) {
        WeakReference<V> weakRef=mDatabase.get(key);
        if (weakRef==null) return null;
        V result=weakRef.get();
        if (result==null) {
            // edge case where the key exists but the object has been garbage collected
            // we remove the key from the table, because tables are slower the more
            // keys they have (@kisp's comment)
            mDatabase.remove(key);
        }
        return result;
    }
    public void put(K key, V value) {
        mDatabase.put(key, new WeakReference<V>(value));
    }
}

So you can just do for example

    private WeakValueHashMap<String,Drawable> mTextDrawables=new WeakValueHashMap<String,Drawable>();

and the Drawables would be stored with Weakreferences.

The method "containsValue" would be trickier to implement, you'd have to iterate and dereference all the WeakRefs ...

Answer 3

The best way is to use the WeakHashMap class which does all the work for you and doesn't require any changes in your code. There is a really good tutorial here: http://weblogs.java.net/blog/2006/05/04/understanding-weak-references Its rather oldish but still alright. It is important that the WeakHashMap stores a weak reference to the key. That means you can't just use a constant string value as the key but instead use something like a Integer and store it in a constants class as a weak reference.