一个Key对应多个Value

Map 一个key对应一个value，它可以满足大部分需求。但有时我要用到一个key对应多个value怎么办？

1.普通做法
  Map<Object,List<Object>> map=new HashMap<>();

2.apache commons工具包里有个org.apache.commons.collections.map.MultiValueMap。

3.开源项目NoHttp里的MultiValueMap。

public interface MultiValueMap<K, V> {

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

    /**
     * 添加Key-List<Value>
     *
     * @param key    key.
     * @param values values.
     */
    void add(K key, List<V> values);

    /**
     * 设置一个Key-Value，如果这个Key存在就被替换，不存在则被添加。
     *
     * @param key   key.
     * @param value values.
     */
    void set(K key, V value);

    /**
     * 设置Key-List<Value>，如果这个Key存在就被替换，不存在则被添加。
     *
     * @param key    key.
     * @param values values.
     * @see #set(Object, Object)
     */
    void set(K key, List<V> values);

    /**
     * 移除某一个Key，对应的所有值也将被移除。
     *
     * @param key key.
     * @return value.
     */
    List<V> remove(K key);

    /**
     * 移除所有的值。
     */
    void clear();

    /**
     * 拿到Key的集合。
     *
     * @return Set.
     */
    Set<K> keySet();

    /**
     * 拿到所有的值的集合。
     *
     * @return List.
     */
    List<V> values();

    /**
     * 获取EntrySet.
     *
     * @return {@link Set}.
     */
    Set<Map.Entry<K, List<V>>> 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<V> 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<K, V> implements MultiValueMap<K, V> {

    private Map<K, List<V>> mSource;

    public BasicMultiValueMap(Map<K, List<V>> source) {
        mSource = source;
    }

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

    @Override
    public void add(K key, List<V> 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<V> values) {
        mSource.put(key, values);
    }

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

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

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

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

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

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

    @Override
    public Set<Map.Entry<K, List<V>>> entrySet() {
        return mSource.entrySet();
    }

    @Override
    public V getValue(K key, int index) {
        List<V> 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<K, List<V>> getSource() {
        return mSource;
    }
}

public class LinkedMultiValueMap<K, V> extends BasicMultiValueMap<K, V> {

    public LinkedMultiValueMap() {
        super(new LinkedHashMap<K, List<V>>());
    }
}

测试

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

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

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

总结：

1.普通方法，原始操作、不好维护、不可复用、不可拓展 。

2.需要引入jar包。

3.对普通方法进行封装复用。推荐使用。