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

 

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

 

接口定义：

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

import java.util.Collection;
import java.util.Set;

/**
 * 两个键的复合map
 * <pre>
 * key------+
 *          |-->value
 * param----+
 * <pre>
 * 
 * @author lixiaohui
 * @date 2016年10月1日 上午10:58:40
 * 
 */
public interface CompoundKeyMap<K, P, V> {
	
	V get(K key, P param);
	V get(K key, P param, V defValue);
	
	V put(K key, P param, V value);
	V putIfAbsent(K key, P param, V value);
	
	Set<java.util.Map.Entry<CompoundKey<K, P>, V>> entrySet();
	Set<CompoundKey<K, P>> keys();
	Collection<V> values();
	
	int size();
	boolean isEmpty();
	
	public interface CompoundKey<K, P> {
		K getKey();
		P getParam();
	}
	
}

 

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

 

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

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;

/**
 * 基于{@link java.util.HashMap}的CompoundKeyMap的实现.
 * 
 * @author lixiaohui
 * @date 2016年10月1日 下午12:37:08
 * 
 */
public class CompoundKeyHashMap<K, P, V> implements CompoundKeyMap<K, P, V> {

	private Map<CompoundKey<K, P>, V> map = new HashMap<CompoundKey<K, P>, V>();
	
	
	public V get(K key, P param) {
		key = Objects.requireNonNull(key, "key cannot be null");
		param = Objects.requireNonNull(param, "param cannot be null");
		
		return map.get(newKey(key, param));
	}

	private CompoundKeyMap.CompoundKey<K, P> newKey(K key, P param) {
		return new CompoundKeyImpl<K, P>(key, param);
	}

	public V get(K key, P param, V defValue) {
		key = Objects.requireNonNull(key, "key cannot be null");
		param = Objects.requireNonNull(param, "param cannot be null");
		
		V value = get(key, param);
		return value == null ? defValue : value;
	}

	public V put(K key, P param, V value) {
		return map.put(newKey(key, param), value);
	}

	public V putIfAbsent(K key, P param, V value) {
		return map.putIfAbsent(newKey(key, param), value);
	}

	public Set<Entry<CompoundKeyMap.CompoundKey<K, P>, V>> entrySet() {
		return map.entrySet();
	}

	public Set<CompoundKeyMap.CompoundKey<K, P>> keys() {
		return map.keySet();
	}

	public Collection<V> values() {
		return map.values();
	}

	public int size() {
		return map.size();
	}

	public boolean isEmpty() {
		return map.isEmpty();
	}

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

		private K key;
		
		private P param;
		
		CompoundKeyImpl(K key, P param) {
			super();
			this.key = key;
			this.param = param;
		}

		public K getKey() {
			return key;
		}

		public P getParam() {
			return param;
		}
		
		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + ((key == null) ? 0 : key.hashCode());
			result = prime * result + ((param == null) ? 0 : param.hashCode());
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			CompoundKeyImpl<?, ?> other = (CompoundKeyImpl<?, ?>) obj;
			if (key == null) {
				if (other.key != null)
					return false;
			} else if (!key.equals(other.key))
				return false;
			if (param == null) {
				if (other.param != null)
					return false;
			} else if (!param.equals(other.param))
				return false;
			return true;
		}
	}
	
}