MultiKey HashMap实现

Question

我正在寻找MultiKey (实际上是DoubleDouble)到单个值的实现。*但*您可以通过(键之一！)访问值--意思是，为了访问映射，不一定要同时使用两个键。

我知道我可以写一些东西来满足我的要求，但问题是，如果有什么东西已经写好了，那么我就可以用它了。

谢谢:-)

编辑:在这一点上，我能想到的最佳实现是：

class DoubleKeyHashMap<K1, K2, V> {
    BiMap<K1, K2> keys; // Bidirectional map
    Map<K2, V> values;
..
..
}

Answer 1

这似乎是实现多键映射的一个良好开端。

编辑以添加removeElement方法，并保存和返回值列表。

package com.ggl.testing;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MultiMap<K, V> {

    private static long sequence = 0;

    private Map<K, Long> key1Map;
    private Map<K, Long> key2Map;
    private Map<Long, List<V>> valueMap;

    public MultiMap() {
        this.key1Map = new HashMap<>();
        this.key2Map = new HashMap<>();
        this.valueMap = new HashMap<>();
    }

    public void addElement(K key1, K key2, V value) {
        boolean key1boolean = key1Map.containsKey(key1);
        boolean key2boolean = key2Map.containsKey(key2);
        boolean key3boolean = key1Map.containsKey(key2);
        boolean key4boolean = key2Map.containsKey(key1);

        if (key1boolean && key2boolean) {
            Long key1Value = key1Map.get(key1);
            Long key2Value = key2Map.get(key2);
            updateValue(key1, key2, key1Value, key2Value, value);
        } else if (key3boolean && key4boolean) {
            Long key1Value = key1Map.get(key2);
            Long key2Value = key2Map.get(key1);
            updateValue(key1, key2, key1Value, key2Value, value);
        } else if (key1boolean || key4boolean) {
            String s = displayDuplicateError(key1);
            throw new IllegalStateException(s);
        } else if (key2boolean || key3boolean) {
            String s = displayDuplicateError(key2);
            throw new IllegalStateException(s);
        } else {
            createValue(key1, key2, value);
        }

    }

    private void createValue(K key1, K key2, V value) {
        Long newKeyValue = sequence++;
        key1Map.put(key1, newKeyValue);
        key2Map.put(key2, newKeyValue);

        List<V> values = new ArrayList<>();
        values.add(value);
        valueMap.put(newKeyValue, values);
    }

    private void updateValue(K key1, K key2, Long key1Value, Long key2Value,
            V value) {
        if (key1Value.equals(key2Value)) {
            List<V> values = valueMap.get(key1Value);
            values.add(value);
            valueMap.put(key1Value, values);
        } else {
            String s = displayMismatchError(key1, key2);
            throw new IllegalStateException(s);
        }
    }

    private String displayMismatchError(K key1, K key2) {
        return "Keys " + key1.toString() + " & " + key2.toString()
                + " have a different internal key.";
    }

    private String displayDuplicateError(K key) {
        return "Key " + key.toString() + " is part of another key pair";
    }

    public List<V> getElement(K key) {
        if (key1Map.containsKey(key)) {
            return valueMap.get(key1Map.get(key));
        }

        if (key2Map.containsKey(key)) {
            return valueMap.get(key2Map.get(key));
        }

        return null;
    }

    public boolean removeElement(K key) {
        if (key1Map.containsKey(key)) {
            Long key1Value = key1Map.get(key);
            Set<Entry<K, Long>> entrySet = key2Map.entrySet();
            K key2 = getOtherKey(key1Value, entrySet);

            valueMap.remove(key1Value);
            key1Map.remove(key);
            key2Map.remove(key2);

            return true;
        } else if (key2Map.containsKey(key)) {
            Long key2Value = key2Map.get(key);
            Set<Entry<K, Long>> entrySet = key1Map.entrySet();
            K key1 = getOtherKey(key2Value, entrySet);

            valueMap.remove(key2Value);
            key1Map.remove(key1);
            key2Map.remove(key);

            return true;
        }

        return false;
    }

    private K getOtherKey(Long key1Value, Set<Entry<K, Long>> entrySet) {
        Iterator<Entry<K, Long>> iter = entrySet.iterator();
        K key = null;
        while (iter.hasNext() && key == null) {
            Entry<K, Long> entry = iter.next();
            if (entry.getValue().equals(key1Value)) {
                key = entry.getKey();
            }
        }
        return key;
    }

    public static void main(String[] args) {
        MultiMap<String, String> multiMap = new MultiMap<>();

        try {
            multiMap.addElement("one", "two", "numbers");
            multiMap.addElement("alpha", "beta", "greek alphabet");
            multiMap.addElement("beta", "alpha", "alphabet");
            multiMap.addElement("iron", "oxygen", "elements");
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(Arrays.toString(multiMap.getElement("iron")
                .toArray()));
        System.out.println(Arrays.toString(multiMap.getElement("beta")
                .toArray()));

        System.out.println(multiMap.removeElement("two"));
    }

}