一个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.对普通方法进行封装复用。推荐使用。