java.util.Map<K,V>为单键对单值，有时需要双键对单值，因此基于Map<K,V>可以简单实现一个Map<K,P,V>。

接口定义：下载

Java代码  

1. package cc.lixiaohui.demo.javassist.proxy.util;  

2.   

3. import java.util.Collection;  

4. import java.util.Set;  

5.   

6. /** 

7.  * 两个键的复合map 

8.  * <pre> 

9.  * key------+ 

10.  *          |-->value 

11.  * param----+ 

12.  * <pre> 

13.  *  

14.  * @author lixiaohui 

15.  * @date 2016年10月1日 上午10:58:40 

16.  *  

17.  */  

18. public interface CompoundKeyMap<K, P, V> {  

19.       

20.     V get(K key, P param);  

21.     V get(K key, P param, V defValue);  

22.       

23.     V put(K key, P param, V value);  

24.     V putIfAbsent(K key, P param, V value);  

25.       

26.     Set<java.util.Map.Entry<CompoundKey<K, P>, V>> entrySet();  

27.     Set<CompoundKey<K, P>> keys();  

28.     Collection<V> values();  

29.       

30.     int size();  

31.     boolean isEmpty();  

32.       

33.     public interface CompoundKey<K, P> {  

34.         K getKey();  

35.         P getParam();  

36.     }  

37.       

38. }  

基于HashMap的简单实现，关键在于CompoundKey的hashcode和equals方法的重写：下载

Java代码  

1. package cc.lixiaohui.demo.javassist.proxy.util;  

2.   

3. import java.util.Collection;  

4. import java.util.HashMap;  

5. import java.util.Map;  

6. import java.util.Map.Entry;  

7. import java.util.Objects;  

8. import java.util.Set;  

9.   

10. /** 

11.  * 基于{@link java.util.HashMap}的CompoundKeyMap的实现. 

12.  *  

13.  * @author lixiaohui 

14.  * @date 2016年10月1日 下午12:37:08 

15.  *  

16.  */  

17. public class CompoundKeyHashMap<K, P, V> implements CompoundKeyMap<K, P, V> {  

18.   

19.     private Map<CompoundKey<K, P>, V> map = new HashMap<CompoundKey<K, P>, V>();  

20.       

21.       

22.     public V get(K key, P param) {  

23.         key = Objects.requireNonNull(key, "key cannot be null");  

24.         param = Objects.requireNonNull(param, "param cannot be null");  

25.           

26.         return map.get(newKey(key, param));  

27.     }  

28.   

29.     private CompoundKeyMap.CompoundKey<K, P> newKey(K key, P param) {  

30.         return new CompoundKeyImpl<K, P>(key, param);  

31.     }  

32.   

33.     public V get(K key, P param, V defValue) {  

34.         key = Objects.requireNonNull(key, "key cannot be null");  

35.         param = Objects.requireNonNull(param, "param cannot be null");  

36.           

37.         V value = get(key, param);  

38.         return value == null ? defValue : value;  

39.     }  

40.   

41.     public V put(K key, P param, V value) {  

42.         return map.put(newKey(key, param), value);  

43.     }  

44.   

45.     public V putIfAbsent(K key, P param, V value) {  

46.         return map.putIfAbsent(newKey(key, param), value);  

47.     }  

48.   

49.     public Set<Entry<CompoundKeyMap.CompoundKey<K, P>, V>> entrySet() {  

50.         return map.entrySet();  

51.     }  

52.   

53.     public Set<CompoundKeyMap.CompoundKey<K, P>> keys() {  

54.         return map.keySet();  

55.     }  

56.   

57.     public Collection<V> values() {  

58.         return map.values();  

59.     }  

60.   

61.     public int size() {  

62.         return map.size();  

63.     }  

64.   

65.     public boolean isEmpty() {  

66.         return map.isEmpty();  

67.     }  

68.   

69.     static class CompoundKeyImpl<K, P> implements CompoundKey<K, P> {  

70.   

71.         private K key;  

72.           

73.         private P param;  

74.           

75.         CompoundKeyImpl(K key, P param) {  

76.             super();  

77.             this.key = key;  

78.             this.param = param;  

79.         }  

80.   

81.         public K getKey() {  

82.             return key;  

83.         }  

84.   

85.         public P getParam() {  

86.             return param;  

87.         }  

88.           

89.         @Override  

90.         public int hashCode() {  

91.             final int prime = 31;  

92.             int result = 1;  

93.             result = prime * result + ((key == null) ? 0 : key.hashCode());  

94.             result = prime * result + ((param == null) ? 0 : param.hashCode());  

95.             return result;  

96.         }  

97.   

98.         @Override  

99.         public boolean equals(Object obj) {  

100.             if (this == obj)  

101.                 return true;  

102.             if (obj == null)  

103.                 return false;  

104.             if (getClass() != obj.getClass())  

105.                 return false;  

106.             CompoundKeyImpl<?, ?> other = (CompoundKeyImpl<?, ?>) obj;  

107.             if (key == null) {  

108.                 if (other.key != null)  

109.                     return false;  

110.             } else if (!key.equals(other.key))  

111.                 return false;  

112.             if (param == null) {  

113.                 if (other.param != null)  

114.                     return false;  

115.             } else if (!param.equals(other.param))  

116.                 return false;  

117.             return true;  

118.         }  

119.     }  

120.       

121. }  

简单组合java.util.Map<K,V>实现Map<K,P,V>