紧凑的java.util.Map实现

Question

Is there any java.util.Map implementation that do not stores Values of equals ValueObjects but store only one of them? (references of this Objects are different, but they are equals)

here is a little test code :

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
for (int i = 0; i <= 1000000; i++) { 
map.put(i, new Integer(42)); 
}

and visual VM shows : 2 million of instances of Integer these objects are equals but Map stores all of them

Just for history logging I coded chiastic-security's solution and test it to compare with HashMap:

public class CompactMap<K, V> implements Map<K, V> {

private Map<K, V> map;
private Map<V, V> canonicalMap;

public CompactMap() {
    map = new HashMap<K, V>();
    canonicalMap = new HashMap<V, V>();
}

@Override
public void clear() {
    map.clear();
    canonicalMap.clear();
}

@Override
public boolean containsKey(Object key) {
    return map.containsKey(key);
}

@Override
public boolean containsValue(Object value) {
    return map.containsValue(value);
}

@Override
public Set<java.util.Map.Entry<K, V>> entrySet() {
    return map.entrySet();
}

@Override
public V get(Object key) {
    return map.get(key);
}

@Override
public boolean isEmpty() {
    return map.isEmpty();
}

@Override
public Set<K> keySet() {
    return map.keySet();
}

@Override
public V put(K key, V value) {
    V canonValue = canonicalMap.get(value);
    V previous = null;
    if (canonValue != null) {
        previous = map.put(key, canonValue);
    } else {
        previous = map.put(key, value);
        canonicalMap.put(value, value);
    }
    return previous;
}

@Override
public void putAll(Map<? extends K, ? extends V> m) {
    if (m == null) throw new NullPointerException("Can't exceute putAll for null-map argument");
    for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
        map.put(entry.getKey(), entry.getValue());
    }
}

@Override
public V remove(Object key) {
    V removalValue = map.get(key);
    map.remove(key);
    if (!map.containsValue(removalValue)) {
        canonicalMap.remove(removalValue);
    }
    return removalValue;
}

@Override
public int size() {
    return map.size();
}

@Override
public Collection<V> values() {
    return map.values();
}

}

test compact map:

    public static void main(String[] args) {
       Map<Integer, Integer> compactMap = new CompactMap<Integer, Integer>();
       //Map<Integer, Integer> usualMap = new HashMap<Integer, Integer>();
       for (int i=0; i<=1000000; i++) {
           compactMap.put(i, new Integer(i % 1000));
           // usualMap.put(i, new Integer(i % 1000));
       }
    }

VisualVM heap dump for CompactMap:

test HashMap :

    public static void main(String[] args) {
       // Map<Integer, Integer> compactMap = new CompactMap<Integer, Integer>();
       Map<Integer, Integer> usualMap = new HashMap<Integer, Integer>();
       for (int i=0; i<=1000000; i++) {
           // compactMap.put(i, new Integer(i % 1000));
           usualMap.put(i, new Integer(i % 1000));
       }
    }

VisualVM heap dump for HashMap:

Answer 1

The standard implementations don't handle this, but you could roll your own easily enough. The trick is to keep hold of a HashMap<K,V> map to hold your real mappings, and another HashMap<V,V> canonical to make sure your values don't end up containing two equal but non-identical references.

Whenever you want to add something to your map with map.put(key,value) , you should

1. Look up value in your canonical map to see whether you've encountered something equal to this before. If canonical.get(value) returns something, then this is the canonical representation you should put into map .
2. If it doesn't exist in canonical , then call map.put(key,value) to add it to the main map, and also canonical.put(value,value) so that you now have a canonical representation for things equal to this value.

Answer 2

Maybe you are confused to the meanings of equality in Java. When you call new, a new instance will always be created. It is not trivial to determine if it is "equal" to another one, as it might have several fields of several complex types.

If you do something like this instead:

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
Integer answer = new Integer(42);
for (int i = 0; i <= 1000000; i++) { 
    map.put(i, answer); 
}

Then only one instance is created. The would only point to one place in memory, that, if altered, would change everyone (though Integer and every other wrapper are immutable in Java, meaning the cannot change).