One-to-one mapping data structure (A,B) with getKey(B) in O(1)?

Question

This question was initially misphrased, see the EDIT below. I'll leave it up for context.

I've been thinking about smart ways to build a bijective (i.e. one-to-one) mapping. Mapping a function A->B (many-to-one) is basically what HashMap(A,B) does. If I now wanted to have a data structure that implements something one-to-one with contains() in O(1), would there be something in the java standard libraries that I could use? Mind you, I don't need this for anything right now, this was just something I thought about recently and couldn't come up with a data structure for, so answers aren't a rush. Is there a class like that? If not, what do you think why that is?

All I could find on SO are things about hibernate, that was of no help to me.

EDIT: My question was ill phrased, so some explanation is due.

What I meant was is the "backward" mapping B->A. HashMap(A,B) has contains(A) and contains(B) both in O(1), so that's not even what I meant, sorry for the confusion. What I meant was, is there a datastructure mapping A<->B that has getValue(A) and getKey(B) in O(1)?

I realize this could be done with two HashMaps (A,B) and (B,A) that are maintained to contain the same relation, but I feel there should be one data structure that handles that without having to do it "manually".

Answer 1

I don't think you'll do better than two HashMaps. Writing the wrapper interface is very simple:

class OneToOneMap<Key, Value> {

    public void add(Key k, Value v) {
        if (!keyToVal_.contains(k) && !valToKey_.contains(v)) {
            keyToVal_.add(k, v);
            valToKey_.add(v, k);
        }
    }

    private HashMap<K, V> keyToVal_;
    private HashMap<V, K> valToKey_;
}

I am not sure if this is valid Java, but you get the idea.

Answer 2

I don't know of an existing class that does O(1) for both containsKey and containsValue, but you can do it by extending HashMap so that on insert, you add each value to an internal HashSet. Overloading containsValue to do a lookup on the values HashSet. The standard HashMap has O(1) containsKey, but O(n) containsValue.

Likewise, you can enforce 1:1 in the insert and checking for existing values.

Note that if you get a ton of collisions the HashSet lookup can get to O(n) in the worst case.

Answer 3

If you're willing to use third-party libraries, Guava provides a nice API for this as BiMap. Instead of a getKey method, it provides an inverse() view which returns a BiMap<V, K>. (It does, of course, provide constant-time containsValue.)

At the moment, HashBiMap is basically internally two HashMaps kept in sync -- though it's very consistent about how it keeps them matching each other -- but the implementation might get smarter in the future.

Answer 4

I had the same need and came up with this BiMap that might be useful. It just uses one hashmap and returns an entry object so that the return value can be given a specific type and also to allow a mapping to null.

public class BiMap<T1, T2>
{
    public static class Entry<T1, T2>
    {
        public final T1 item1;
        public final T2 item2;

        public Entry( T1 item1, T2 item2 )
        {
            this.item1 = item1;
            this.item2 = item2;
        }
    }

    private final HashMap< Object, Entry<T1, T2> > mappings = new HashMap<>();
    private int loopedLinkCount;

    public void put( T1 item1, T2 item2 )
    {
        remove(item1);
        remove(item2);
        Entry<T1, T2> entry = new Entry<T1, T2>( item1, item2 );
        mappings.put( item1, entry );
        mappings.put( item2, entry );
        if( Objects.equals(item1, item2) ){
            loopedLinkCount++;
        }
    }

    /**
     * 
     * @param key 
     * @return an entry containing the key and it's one to one mapping or null if there is
     * no mapping for the key.
     */
    public Entry<T1, T2> get( Object key )
    {
        return mappings.get( key );
    }

    public Entry<T1, T2> remove( Object key )
    {
        Entry<T1, T2> entry = mappings.remove( key );
        if( entry == null ){
            return null;
        }
        if( Objects.equals( entry.item2, entry.item1 ) ){
            loopedLinkCount--;
            return entry;
        }
        return mappings.remove( Objects.equals( key, entry.item1 )  ?  entry.item2  :  entry.item1 );
    }

    public Set< Entry<T1, T2> > entrySet()
    {
        return new HashSet<>( mappings.values() );
    }

    public int size()
    {
        return ( mappings.size() + loopedLinkCount ) / 2;
    }
}

Answer 5

My initial thought is just use a standard map, if you have a perfect hash function you can use a HashMap as a one-to-one mapping. If I understand what you are doing the following would suffice:

Map<String,Object> map = new HashMap<String,Object>();