簡單組合java.util.Map<K,V>實現Map<K,P,V>

java.util.Map<K,V>爲單鍵對單值，有時需要雙鍵對單值，因此基於Map<K,V>可以簡單實現一個Map<K,P,V>。

 

接口定義：下載

Java代碼  

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方法的重寫：下載

 

Java代碼  

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;
        }
    }

}