1つのキーが複数のValueに対応

Mapはkeyがvalueに対応し、ほとんどのニーズを満たすことができます.しかし、私は時々1つのkeyを使って複数のvalueに対応したらどうしますか?
1.一般的なやり方
  Map> map=new HashMap<>();
2.apache commonsキットにorgが入っています.apache.commons.collections.map.MultiValueMap.
3.オープンソースプロジェクトNoHttpのMultiValueMap.

public interface MultiValueMap {

    /**
     *   Key-Value
     *
     * @param key   key.
     * @param value value.
     */
    void add(K key, V value);

    /**
     *   Key-List
     *
     * @param key    key.
     * @param values values.
     */
    void add(K key, List values);

    /**
     *     Key-Value，    Key      ，       。
     *
     * @param key   key.
     * @param value values.
     */
    void set(K key, V value);

    /**
     *   Key-List，    Key      ，       。
     *
     * @param key    key.
     * @param values values.
     * @see #set(Object, Object)
     */
    void set(K key, List values);

    /**
     *      Key，           。
     *
     * @param key key.
     * @return value.
     */
    List remove(K key);

    /**
     *       。
     */
    void clear();

    /**
     *   Key   。
     *
     * @return Set.
     */
    Set keySet();

    /**
     *          。
     *
     * @return List.
     */
    List values();

    /**
     *   EntrySet.
     *
     * @return {@link Set}.
     */
    Set>> entrySet();

    /**
     *      Key      。
     *
     * @param key   key.
     * @param index index value.
     * @return The value.
     */
    V getValue(K key, int index);

    /**
     *      Key      。
     *
     * @param key key.
     * @return The value.
     */
    V getFirstValue(K key);

    /**
     *      Key     。
     *
     * @param key key.
     * @return values.
     */
    List getValues(K key);

    /**
     *   MultiValueMap   .
     *
     * @return size.
     */
    int size();

    /**
     *   MultiValueMap   null.
     *
     * @return True: empty, false: not empty.
     */
    boolean isEmpty();

    /**
     *   MultiValueMap      Key.
     *
     * @param key key.
     * @return True: contain, false: none.
     */
    boolean containsKey(K key);

}

public class BasicMultiValueMap implements MultiValueMap {

    private Map> mSource;

    public BasicMultiValueMap(Map> source) {
        mSource = source;
    }

    @Override
    public void add(K key, V value) {
        if (!containsKey(key))
            mSource.put(key, new ArrayList(1));
        getValues(key).add(value);
    }

    @Override
    public void add(K key, List values) {
        if (!containsKey(key))
            mSource.put(key, values);
        else
            mSource.get(key).addAll(values);
    }

    @Override
    public void set(K key, V value) {
        remove(key);
        add(key, value);
    }

    @Override
    public void set(K key, List values) {
        mSource.put(key, values);
    }

    @Override
    public List remove(K key) {
        return mSource.remove(key);
    }

    @Override
    public void clear() {
        mSource.clear();
    }

    @Override
    public Set keySet() {
        return mSource.keySet();
    }

    @Override
    public List values() {
        List allValues = new ArrayList<>();
        Set keySet = keySet();
        for (K key : keySet) {
            allValues.addAll(getValues(key));
        }
        return allValues;
    }

    @Override
    public List getValues(K key) {
        return mSource.get(key);
    }

    @Override
    public V getFirstValue(K key) {
        return getValue(key, 0);
    }

    @Override
    public Set>> entrySet() {
        return mSource.entrySet();
    }

    @Override
    public V getValue(K key, int index) {
        List values = getValues(key);
        if (values != null && values.size() > index)
            return values.get(index);
        return null;
    }

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

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

    @Override
    public boolean containsKey(K key) {
        return mSource.containsKey(key);
    }

    public Map> getSource() {
        return mSource;
    }
}

public class LinkedMultiValueMap extends BasicMultiValueMap {

    public LinkedMultiValueMap() {
        super(new LinkedHashMap>());
    }
}

テスト

public class Test {
    public static void main(String[] args) {
        String key = "a";

        LinkedMultiValueMap multiValueMap = new LinkedMultiValueMap<>();
        multiValueMap.add(key, "a");
        multiValueMap.add(key, "b");
        multiValueMap.add(key, "c");
        multiValueMap.add(key, "d");

        List values = multiValueMap.getValues(key);
        for (String v : values) {
            System.out.println(v); //   a  b  c  d
        }
    }
}

まとめ:
1.一般的な方法、元の操作、メンテナンスがよくない、多重化できない、拡張できない.2.jarパッケージを導入する必要があります.3.一般的な方法をカプセル化して多重化する.使用を推奨します.