/var/log/mind

Eric Redmond in his post A Safe HashMap for Java describes a SafeHashMap

Here’s a suggestion to extend the capabilities of the same. Lets look at the code.

Define an interface to create an instance.

First, I create a new interface (We’ll get to know why very soon).

public interface InstanceProvider<K,V>
{
        public V createNew(K k);
}

The SafeMap class itself

Here’s the proposed class. The main distinction is that instead of caching an instance and using the clone method to clone, this implementation stores away a reference to the instance provider and triggers it when required.

public class SafeMap<K, V> extends HashMap<K, V>
{
        // Here's where we cache away the provider
        private InstanceProvider<K,V> provider;

        // Note that the provider is now 
        // passed to all the constructors
        
        public SafeMap(
                        int initialCapacity, 
                        float loadFactor, 
                        InstanceProvider<K,V> provider)
        {
                super(initialCapacity,loadFactor);
                this.provider = provider;
        }

        public SafeMap(
                        int initialCapacity, 
                        InstanceProvider<K,V> provider)
        {
                this.provider = provider;
        }

        public SafeMap(
                        InstanceProvider<K,V> provider)
        {
                this.provider = provider;
        }

        public SafeMap(
                        Map<? extends K, ? extends V> m, 
                        InstanceProvider<K,V> provider)
        {
                super(m);
                this.provider = provider;
        }

        @Override
        @SuppressWarnings("unchecked")
        public V get(Object key)
        {
                V value = super.get(key);
                if (value == null)
                {
                        // use the provider here
                        value = 
                                provider.createNew(
                                                (K) key);
                }
                return value;
        }       
}

Test Case demonstrating usage.

public class TestSafeMap
{
        @Test
        public void testGetObject()
        {
                // Am using an anonymous class here. 
                // If additional parameters are required
                // to be passed to constructor, one could 
                // create an abstract class with the constructor
                // and pass the necessary arguments 
                Map<String, List<String>> myMap = 
                        new SafeMap<String, List<String>>(
                                        new InstanceProvider<String, List<String>>()
                                        {
                                                public List<String> createNew(String string)
                                                {
                                                        List<String> list = new ArrayList<String>();
                                                        list.add(string);
                                                        return list;
                                                }
                                        }
                );
                
                String key = "hello world";
                assertEquals(
                                "List size should've been one",
                                1,
                                myMap.get(key).size());
                assertEquals(
                                "The only element in the list should've been : " + key,
                                key,
                                myMap.get(key).get(0));
        }
        
        @Test
        public void testArrayInstantiation()
        {
                Map<String, String[]> myMap = 
                        new SafeMap<String, String[]>(
                                        new InstanceProvider<String, String[]>()
                                        {
                                                public String[] createNew(
                                                                String string)
                                                {
                                                        return new String[] {string};
                                                }
                                        }
                        );
                        
                String key = "hello world";
                assertEquals(
                                "List size should've been one",
                                1,
                                myMap.get(key).length);
                assertEquals(
                                "The only element in the list should've been : " + key,
                                key,
                                myMap.get(key)[0]);
        }
}

This way I get a finer level of control on the instantiation of the default instance. There are multiple reasons why one might want that such as :