Create a map from a set and function
Here are two classes, each of which must do the job. The first one simply shows the view of the dialing map, and the second can write the values back to the dialing via a special interface.
Call Syntax:
Map<K,V> immutable = new SetBackedMap<K,V>(Set<K> keys, Function<K,V> func); Map<K,V> mutable = new MutableSetBackedMap<K,V>(Set<K> keys, Function<K,V> func);
Where to place this code?
Side note: if guava was my library, I would make them available through the Maps class:
Map<K,V> immutable = Maps.immutableComputingMap(Set<K> keys, Function<K,V> func); Map<K,V> mutable = Maps.mutableComputingMap(Set<K> keys, Function<K,V> func);
Immutable Version:
I implemented this as a one-way view:
- Changes in the set are reflected in the map, but not vice versa (and you cannot change the map in any case, the
put(key, value) method is not implemented). - The
entrySet() iterator uses the set iterator internally, so it will also inherit the internal iterator handling ConcurrentModificationException . - Both
put(k,v) and entrySet().iterator().remove() will throw an UnsupportedOperationException . - Values are cached in
WeakHashMap , without special concurrency processing, i.e. synchronization to any level. This will be done in most cases, but if your function is expensive, you can add some lock.
The code:
public class SetBackedMap<K, V> extends AbstractMap<K, V>{ private class MapEntry implements Entry<K, V>{ private final K key; public MapEntry(final K key){ this.key = key; } @Override public K getKey(){ return this.key; } @Override public V getValue(){ V value = SetBackedMap.this.cache.get(this.key); if(value == null){ value = SetBackedMap.this.funk.apply(this.key); SetBackedMap.this.cache.put(this.key, value); } return value; } @Override public V setValue(final V value){ throw new UnsupportedOperationException(); } } private class EntrySet extends AbstractSet<Entry<K, V>>{ public class EntryIterator implements Iterator<Entry<K, V>>{ private final Iterator<K> inner; public EntryIterator(){ this.inner = EntrySet.this.keys.iterator(); } @Override public boolean hasNext(){ return this.inner.hasNext(); } @Override public Map.Entry<K, V> next(){ final K key = this.inner.next(); return new MapEntry(key); } @Override public void remove(){ throw new UnsupportedOperationException(); } } private final Set<K> keys; public EntrySet(final Set<K> keys){ this.keys = keys; } @Override public Iterator<Map.Entry<K, V>> iterator(){ return new EntryIterator(); } @Override public int size(){ return this.keys.size(); } } private final WeakHashMap<K, V> cache; private final Set<Entry<K, V>> entries; private final Function<? super K, ? extends V> funk; public SetBackedMap( final Set<K> keys, Function<? super K, ? extends V> funk){ this.funk = funk; this.cache = new WeakHashMap<K, V>(); this.entries = new EntrySet(keys); } @Override public Set<Map.Entry<K, V>> entrySet(){ return this.entries; } }
Test:
final Map<Integer, String> map = new SetBackedMap<Integer, String>( new TreeSet<Integer>(Arrays.asList( 1, 2, 4, 8, 16, 32, 64, 128, 256)), new Function<Integer, String>(){ @Override public String apply(final Integer from){ return Integer.toBinaryString(from.intValue()); } }); for(final Map.Entry<Integer, String> entry : map.entrySet()){ System.out.println( "Key: " + entry.getKey() + ", value: " + entry.getValue()); }
Output:
Key: 1, value: 1 Key: 2, value: 10 Key: 4, value: 100 Key: 8, value: 1000 Key: 16, value: 10000 Key: 32, value: 100000 Key: 64, value: 1000000 Key: 128, value: 10000000 Key: 256, value: 100000000
Mutable Version:
While I think it’s a good idea to do it one way, here is a version for Emil that provides a two-way presentation (this is a variation of Emil’s variation of my solution :-)). This requires an extended map interface, which I will call ComputingMap , to show that it is a map where it makes no sense to call put(key, value) .
Card Interface:
public interface ComputingMap<K, V> extends Map<K, V>{ boolean removeKey(final K key); boolean addKey(final K key); }
Card Implementation:
public class MutableSetBackedMap<K, V> extends AbstractMap<K, V> implements ComputingMap<K, V>{ public class MapEntry implements Entry<K, V>{ private final K key; public MapEntry(final K key){ this.key = key; } @Override public K getKey(){ return this.key; } @Override public V getValue(){ V value = MutableSetBackedMap.this.cache.get(this.key); if(value == null){ value = MutableSetBackedMap.this.funk.apply(this.key); MutableSetBackedMap.this.cache.put(this.key, value); } return value; } @Override public V setValue(final V value){ throw new UnsupportedOperationException(); } } public class EntrySet extends AbstractSet<Entry<K, V>>{ public class EntryIterator implements Iterator<Entry<K, V>>{ private final Iterator<K> inner; public EntryIterator(){ this.inner = MutableSetBackedMap.this.keys.iterator(); } @Override public boolean hasNext(){ return this.inner.hasNext(); } @Override public Map.Entry<K, V> next(){ final K key = this.inner.next(); return new MapEntry(key); } @Override public void remove(){ throw new UnsupportedOperationException(); } } public EntrySet(){ } @Override public Iterator<Map.Entry<K, V>> iterator(){ return new EntryIterator(); } @Override public int size(){ return MutableSetBackedMap.this.keys.size(); } } private final WeakHashMap<K, V> cache; private final Set<Entry<K, V>> entries; private final Function<? super K, ? extends V> funk; private final Set<K> keys; public MutableSetBackedMap(final Set<K> keys, final Function<? super K, ? extends V> funk){ this.keys = keys; this.funk = funk; this.cache = new WeakHashMap<K, V>(); this.entries = new EntrySet(); } @Override public boolean addKey(final K key){ return this.keys.add(key); } @Override public boolean removeKey(final K key){ return this.keys.remove(key); } @Override public Set<Map.Entry<K, V>> entrySet(){ return this.entries; } }
Test:
public static void main(final String[] args){ final ComputingMap<Integer, String> map = new MutableSetBackedMap<Integer, String>( new TreeSet<Integer>(Arrays.asList( 1, 2, 4, 8, 16, 32, 64, 128, 256)), new Function<Integer, String>(){ @Override public String apply(final Integer from){ return Integer.toBinaryString(from.intValue()); } }); System.out.println(map); map.addKey(3); map.addKey(217); map.removeKey(8); System.out.println(map); }
Output:
{1=1, 2=10, 4=100, 8=1000, 16=10000, 32=100000, 64=1000000, 128=10000000, 256=100000000} {1=1, 2=10, 3=11, 4=100, 16=10000, 32=100000, 64=1000000, 128=10000000, 217=11011001, 256=100000000}