树状数据结构的后台缓存方式

我们经常用到一些树状的数据结构，在数据库中通常是用一个字段来记录其父节点的ID。在生成树状结构时，通常使用递归遍历的方法。在某些场合下，如果数据量不大，且更新不是很频繁时，可以将数据库的数据缓存到内存中。下面用一个自定义的特定的Map来保存这些数据：

MultiKeyMap.java

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 
 * @author eyes1842
 *
 * @param <K> Key type
 * @param <V> Value type
 */
public class MultiKeyMap<K,V>{
	
	private Map<K,MultiKeyMap.Entry<K, V>> map = new HashMap<K,MultiKeyMap.Entry<K, V>>();
	
	public V put(K pkey, K fkey, V value) {
		MultiKeyMap.Entry<K,V> entry = new MultiKeyMap.Entry<K,V>(fkey, value);
		map.put(pkey, entry);
		return value;
	}
	
	public V get(K pkey) {
		MultiKeyMap.Entry<K,V> entry = map.get(pkey);
		if(entry!=null&&!entry.isEmpty())
			return entry.getValue();
		else
			return null;
	}
	
	public V remove(K pkey){
		Entry<K,V> e = map.remove(pkey);
        return (e == null ? null : e.value);
	}
	
	public void clear(){
		map.clear();
	}
	
	public Collection<V> values(){
		Collection<V> result = null;
		if(!map.isEmpty()){
			result = new ArrayList<V>(map.size());
			for(MultiKeyMap.Entry<K,V> entry : map.values()){
				result.add(entry.getValue());
			}
		}
		return result;
	}
	
	public Collection<V> getByFKey(K fkey) {
		Collection<MultiKeyMap.Entry<K,V>> entrys = map.values();
		Collection<V> result = null;
		if(!entrys.isEmpty()){
			result = new ArrayList<V>();
			if(fkey==null)
				return result;
			for(MultiKeyMap.Entry<K,V> entry : entrys){
				if(entry.getKey().equals(fkey))
					result.add(entry.getValue());
			}
		}
		return result;
	}
	
	static class Entry<K,V> {
        final K key;
        V value;
        
        Entry(K k, V v) {
            value = v;
            key = k;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
	    V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public boolean isEmpty(){
        	return (this==null||getKey()==null);
        }
        
        public final boolean equals(MultiKeyMap.Entry<K,V> o) {
            if (!(o instanceof MultiKeyMap.Entry))
                return false;
            Object k1 = getKey();
            Object k2 = o.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = o.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }
    }
	
	
	/**
	 * Test
	 * @param args
	 */
	public static void main(String[] args) {
		MultiKeyMap<Integer,String> map = new MultiKeyMap<Integer,String>();
		
		map.put(0, 0, "hello_0");
		map.put(1, 0, "hello_1");
		map.put(2, 0, "hello_2");
		map.put(3, 2, "hello_3");
		map.put(4, 3, "hello_4");
		
		List<String> ss = (List<String>) map.getByFKey(0);
		for(String s : ss)
		System.out.println(s);

	}
}

 

这是一个多键值的Map，使用起来很方便，可以具有一般的Map的特点，又支持类似数据库中的主外健的特点。可以根据父节点获取其子节点列表。