public final class CommonLocalQuery {

 //传入数据查询后返回list， 第一个参数：被查询列表，第二个参数：查询条件
 public List queryData(final List mAllList, final HashHashMap map) {

  if(mAllList == null | map == null) {
   return new ArrayList();
  }

  if(mAllList.isEmpty()) {
   return mAllList;
  }

  /* 根据实际需要找出符合的查询条件 */
  Set key1 = map.getFirstKeys();
  for (POLICY policy : key1) {
   ConcurrentHashMap tempMap = map.get(policy);
   Set key2 = tempMap.keySet();
   for (String key : key2) {
    if(key.startsWith("-") || tempMap.get(key) == null ||
      (tempMap.get(key) != null && tempMap.get(key).equals(""))) {
     tempMap.remove(key);
    }
   }
  }
// 责任链设计模式进行查找
  Filter filterNormal, filterBetween, filterFuzzy;
  filterNormal = new FilterNormal();
  filterBetween = new FilterBetween();
  filterFuzzy = new FilterFuzzy();
  filterNormal.setFilter(filterBetween);
  filterBetween.setFilter(filterFuzzy);
  Set endKey1 = map.getFirstKeys();
  List listResult = new ArrayList();
  for (T resMap : mAllList) {
   for (POLICY policy : endKey1) {
    ConcurrentHashMap queryMap = map.get(policy);
    if (filterNormal.doFilter(resMap, policy, queryMap) && listResult.contains(resMap)) {
     listResult.add(resMap);
    }
   }
  }
  return listResult;
 }

 public static enum POLICY { NORMAL, BETWEEN, FUZZY }
}

/*======== 责任链抽象类 ======*/
abstract class Filter {

 Filter filter;

 public void setFilter(Filter filter) {
  this.filter = filter;
 }

 public Filter getFilter() {
  return filter;
 }

 abstract boolean doFilter(Map resMap, POLICY policy, Map queryMap);
}
//精确查找方式
class FilterNormal extends Filter {

 @Override
 boolean doFilter(Map resMap, POLICY policy, Map queryMap) {
  // TODO Auto-generated method stub
  if (policy.name().equalsIgnoreCase(POLICY.NORMAL.name())) {
   Iterator iterator = queryMap.entrySet().iterator();
   while(iterator.hasNext()) {
    Entry entry = iterator.next();
    if(!resMap.get(entry.getKey()).toString().contains(entry.getValue())) {
     return false;
    }
   }
  } else if (filter != null) {
   return filter.doFilter(resMap, policy, queryMap);
  }
  return true;
 }
}
//between查找方式
class FilterBetween extends Filter {

 @Override
 boolean doFilter(Map resMap, POLICY policy, Map queryMap) {
  // TODO Auto-generated method stub
  if (policy.name().equalsIgnoreCase(POLICY.BETWEEN.name())) {
   Iterator iterator = queryMap.entrySet().iterator();
   while(iterator.hasNext()) {
    Entry entry = iterator.next();
    if(!Pattern.matches(".+?Φ.+?", entry.getValue()))
     throw new UnknownError("Values should be .+?Φ.+? pattern");
    String firstValue = entry.getValue().split("Φ")[0];
    String secondValue = entry.getValue().split("Φ")[1];
    if(resMap.get(entry.getKey()).toString().compareTo(firstValue) < 0
      || resMap.get(entry.getKey()).toString().compareTo(secondValue) > 0) {
     return false;
    }
   }
  } else if (filter != null) {
   return filter.doFilter(resMap, policy, queryMap);
  }
  return true;
 }
}
//模糊查找方式
class FilterFuzzy extends Filter {

 @Override
 boolean doFilter(Map resMap, POLICY policy, Map queryMap) {
  // TODO Auto-generated method stub
  if (policy.name().equalsIgnoreCase(POLICY.FUZZY.name())) {
   String tempStr = resMap.values().toString().replace(" ", "").replace(",", "");
   Iterator iterator = queryMap.entrySet().iterator();
   while(iterator.hasNext()) {
    Entry entry = iterator.next();
    if(tempStr.substring(1, tempStr.length()-1).contains(entry.getValue())) {
     return true;
    }
   }
  } else if (filter != null) {
   return filter.doFilter(resMap, policy, queryMap);
  }
  return true;
 }
}

//帮助类实现 k1-k2-v
public class HashHashMap {

    private ConcurrentHashMap k1k2vMap;

    public HashHashMap() {
        this.k1k2vMap = new ConcurrentHashMap();
    }

    public void put(K1 key1, K2 key2, V value) {
        if (k1k2vMap.containsKey(key1)) {
            ConcurrentHashMap k2vMap = k1k2vMap.get(key1);
            k2vMap.put(key2, value);
        } else {
            ConcurrentHashMap k2vMap = new ConcurrentHashMap();
            k2vMap.put(key2, value);
            k1k2vMap.put(key1, k2vMap);
        }
    }

    public Set getFirstKeys() {
        return k1k2vMap.keySet();
    }

    public V get(K1 key1, K2 key2) {
        ConcurrentHashMap k2_v = k1k2vMap.get(key1);
        return k2_v == null ? null : k2_v.get(key2);
    }

    public ConcurrentHashMap get(K1 key1) {
        return k1k2vMap.get(key1);
    }

    public boolean containsKey(K1 key1, K2 key2) {
        if (k1k2vMap.containsKey(key1)) {
            return k1k2vMap.get(key1).containsKey(key2);
        }
        return false;
    }

    public boolean containsKey(K1 key1) {
        return k1k2vMap.containsKey(key1);
    }

    public void clear() {
        if (k1k2vMap.size() > 0) {
            for (ConcurrentHashMap k2vMap : k1k2vMap.values()) {
                k2vMap.clear();
            }
            k1k2vMap.clear();
        }
    }
}

//具体使用方式
HashHashMap map = new HashHashMap();
  for(int i = 0; i < queryKey.length; i++){
   map.put(POLICY.NORMAL, queryKey[i], queryValue[i]);
  }
List mTempList = new CommonLocalQuery(