Use la lista para implementar los métodos de búsqueda precisos, similares a la base de datos,
La copia del código es la siguiente:
Public Final Clase CommonLocalQuery <t extiende map <string, object >> {
// La lista de retorno después de pasar la consulta de datos, el primer parámetro: la lista de consultas, el segundo parámetro: la condición de consulta
Lista pública <T> QUERYDATA (Lista final <T> MallList, Final Hashhhashmap <Policy, String, String> Map) {
if (malllist == null | map == null) {
devolver nuevo ArrayList <T> ();
}
if (mallList.isEmpty ()) {
return MallList;
}
/* Encuentre las condiciones de consulta coincidente basadas en las necesidades reales*/
Establecer <Policy> Key1 = MAP.GetFirstKeys ();
para (Política Política: Key1) {
Concurrenthashmap <string, string> tempMap = map.get (política);
Establecer <String> key2 = tempMap.KeySet ();
for (tecla de cadena: key2) {
if (key.startswith ("-") || tempMap.get (key) == NULL ||
(tempMap.get (key)! = null && tempMap.get (key) .equals (""))) {
tempMap.remove (clave);
}
}
}
// Encuentra el patrón de diseño de la cadena de responsabilidad
Filtro filternormal, filtrebetween, filtrefuzzy;
filternormal = new FilternMal ();
filtreBetween = new FilterBetween ();
filtreFuzzy = new FilterFuzzy ();
Filternormal.setFilter (Filterbetween);
FilterBetween.SetFilter (FilterFuzzy);
Establecer <Policy> EndKey1 = MAP.GetFirstKeys ();
List <t> listresult = new ArrayList <T> ();
para (t resmap: malllist) {
para (política de política: endkey1) {
Concurrenthashmap <string, string> querymap = map.get (política);
if (filternormal.dofilter (resmap, política, querymap) && listresult.contains (resmap)) {
listresult.add (resmap);
}
}
}
regresar listresult;
}
Política pública de enum estática {normal, entre, difuso}
}
/*========= Cadena de responsabilidad Abstract Clase ======*/
Filtro de clase abstracta {
Filtro de filtro;
public void setFilter (filtro de filtro) {
this.filter = filtro;
}
Public Filter getFilter () {
Filtro de retorno;
}
abstracto boolean dofilter (map <string, object> resmap, política de política, map <string, string> QUYMAP);
}
// Método de búsqueda preciso
Clase Filternormal extiende el filtro {
@Anular
boolean dofilter (map <string, object> resmap, política de política, map <string, string> QueryMap) {
// TODO STUB de método generado automático
if (Policy.name (). EqualsignorEcase (Policy.Normal.Name ())) {
Iterator <Entry <String, String >> iterator = QueryMap.EntrySet (). Iterator ();
while (iterator.hasnext ()) {
Entrada <string, string> entry = iterator.next ();
if (! resmap.get (entry.getKey ()). toString (). contiene (entrada.getValue ())) {
devolver falso;
}
}
} else if (filtre! = null) {
return filtre.dofilter (resmap, política, querymap);
}
devolver verdadero;
}
}
// Entre el método de búsqueda
Filtro de clase Between extiende el filtro {
@Anular
boolean dofilter (map <string, object> resmap, política de política, map <string, string> QueryMap) {
// TODO STUB de método generado automático
if (Policy.name (). EqualSignorEcase (Policy.between.name ())) {
Iterator <Entry <String, String >> iterator = QueryMap.EntrySet (). Iterator ();
while (iterator.hasnext ()) {
Entrada <string, string> entry = iterator.next ();
if (! patrón.matches (".+? φ.+?", Entry.getValue ())))
arrojar nuevo desconocido ("Los valores deberían ser.+? φ.+? Patrón");
Cadena firstValue = entry.getValue (). Split ("φ") [0];
Cadena SecondValue = Entry.getValue (). Split ("φ") [1];
if (resmap.get (entry.getKey ()). ToString (). Compareto (FirstValue) <0
|| resmap.get (Entry.getKey ()). ToString (). CompareTo (SecondValue)> 0) {
devolver falso;
}
}
} else if (filtre! = null) {
return filtre.dofilter (resmap, política, querymap);
}
devolver verdadero;
}
}
// método de búsqueda difuso
Class FilterFuzzy extiende el filtro {
@Anular
boolean dofilter (map <string, object> resmap, política de política, map <string, string> QueryMap) {
// TODO STUB de método generado automático
if (Policy.Name (). EqualsignorEcase (Policy.fuzzy.name ())) {
Cadena temptr = resmap.values (). ToString (). Reemplazar ("", "") .replace (",", "");
Iterator <Entry <String, String >> iterator = QueryMap.EntrySet (). Iterator ();
while (iterator.hasnext ()) {
Entrada <string, string> entry = iterator.next ();
if (temptr.substring (1, temptr.length ()-1) .contains (entry.getValue ())) {
devolver verdadero;
}
}
} else if (filtre! = null) {
return filtre.dofilter (resmap, política, querymap);
}
devolver verdadero;
}
}
// La clase de ayuda implementa K1-K2-V
clase pública Hashhhashmap <K1, K2, V> {
Privado concurrenthashmap <K1, concurrenthashmap <k2, v >> k1k2vmap;
public hascashMap () {
this.k1k2vmap = new Concurrenthashmap <k1, concurrenthashmap <k2, v >> ();
}
public void put (k1 key1, k2 key2, valor v) {
if (k1k2vmap.containskey (key1)) {
Concurrenthashmap <k2, v> k2vmap = k1k2vmap.get (key1);
k2vmap.put (key2, valor);
} demás {
Concurrenthashmap <k2, v> k2vmap = nuevo concurrenthashmap <k2, v> ();
k2vmap.put (key2, valor);
k1k2vmap.put (key1, k2vmap);
}
}
conjunto público <K1> getFirstKeys () {
return k1k2vmap.keySet ();
}
public v get (k1 key1, k2 key2) {
Concurrenthashmap <k2, v> k2_v = k1k2vmap.get (key1);
return k2_v == null?
}
Public concurrenthashmap <k2, v> get (k1 key1) {
return k1k2vmap.get (key1);
}
Public Boolean contiene Key (K1 Key1, K2 Key2) {
if (k1k2vmap.containskey (key1)) {
return k1k2vmap.get (key1) .containskey (key2);
}
devolver falso;
}
Public Boolean contiene key (k1 key1) {
return k1k2vmap.containskey (key1);
}
public void clear () {
if (k1k2vmap.size ()> 0) {
para (concurrenthashmap <k2, v> k2vmap: k1k2vmap.values ()) {
k2vmap.clear ();
}
k1k2vmap.clear ();
}
}
}
// Método de uso específico
Hashhashmap <Policy, String, String> MAP = new Hashhashmap <CommonLocalQuery.policy, String, String> ();
para (int i = 0; i <querykey.length; i ++) {
map.put (Policy.Normal, QueryKey [i], QueryValue [i]);
}
Lista <map <string, object >> mtEmplist = new CommonLocalQuery <Hashmap <String, Object >> (