Utilisez la liste pour implémenter des méthodes de recherche de base de base de données, entre
La copie de code est la suivante:
classe finale publique CommonlocalQuery <T étend la carte <chaîne, objet >> {
// Liste de retour après avoir transmis la requête de données, le premier paramètre: la liste des requêtes, le deuxième paramètre: la condition de requête
Liste publique <T> QueryData (Liste finale <T> Malllist, Final HashhashMap <Policy, String, String> Map) {
if (MallList == null | map == null) {
return new ArrayList <T> ();
}
if (MallList.iSempty ()) {
return MallList;
}
/ * Trouvez les conditions de requête correspondantes en fonction des besoins réels * /
Set <golicy> key1 = map.getFirstKeys ();
pour (politique politique: key1) {
ConcurrentHashMap <String, String> tempmap = map.get (politique);
Set <string> key2 = tempmap.KeySet ();
for (string key: key2) {
if (key.startswith ("-") || tempmap.get (key) == null ||
(tempmap.get (key)! = null && tempmap.get (key) .equals (""))) {
Tempmap.Remove (clé);
}
}
}
// trouver le modèle de conception de la chaîne de responsabilité
Filtre filternormal, filtre entre, filterfuzzy;
Filternormal = new FilternorMal ();
filterbetween = new filterbetween ();
filterFuzzy = new FilterFuzzy ();
Filternormal.setFilter (filterbetween);
filterbetween.setFilter (filterFuzzy);
Set <Policy> EndKey1 = map.getFirstKeys ();
List <T> ListResult = new ArrayList <T> ();
pour (t resmap: Malllist) {
pour (politique politique: endkey1) {
ConcurrentHashMap <String, String> queryMap = map.get (politique);
if (FilternOrnal.Dofilter (resMap, Policy, QueryMap) && listResult.contains (resmap)) {
listresult.add (resmap);
}
}
}
retour listresult;
}
Politique publique de l'énumération statique {normal, entre, flou}
}
/ * ========= Chaîne de responsabilité Classe abstraite ====== * /
Filtre de classe abstrait {
Filtre filtrant;
public void setFilter (filtre filtre) {
this.filter = filtre;
}
Filtre public getFilter () {
filtre de retour;
}
Résumé Boolean Dofilter (map <string, objet> resmap, stratégie de stratégie, map <string, string> queryMap);
}
// Méthode de recherche précise
classe filternormal étend le filtre {
@Outrepasser
booléen dofilter (map <string, objet> resmap, stratégie de stratégie, map <string, string> querymap) {
// Talage de méthode générée automatiquement de TODO
if (politique.name (). equalsignorecase (politique.normal.name ())) {
Iterator <entrée <string, string >> iterator = querymap.entryset (). Iterator ();
while (iterator.hasnext ()) {
Entrée <string, string> entrée = iterator.next ();
if (! resmap.get (entry.getkey ()). toString (). contient (entrée.getValue ())) {
retourne false;
}
}
} else if (filter! = null) {
return filter.dofilter (resmap, politique, queryMap);
}
Retour Vrai;
}
}
// entre la méthode de recherche
Classe filtre entre le filtre étend {
@Outrepasser
booléen dofilter (map <string, objet> resmap, stratégie de stratégie, map <string, string> querymap) {
// Talage de méthode générée automatiquement de TODO
if (politique.name (). equalsignorecase (politique.between.name ())) {
Iterator <entrée <string, string >> iterator = querymap.entryset (). Iterator ();
while (iterator.hasnext ()) {
Entrée <string, string> entrée = iterator.next ();
if (! Pattern.matches (". +? φ. +?", Entry.getValue ()))
Jetez un nouveau sous-connu ("Les valeurs devraient être. +? φ. +? Modèle");
String FirstValue = Entry.getValue (). Split ("φ") [0];
String secondValue = entry.getValue (). Split ("φ") [1];
if (resmap.get (entry.getKey ()). toString (). compareto (FirstValue) <0
|| resmap.get (entrée.getKey ()).
retourne false;
}
}
} else if (filter! = null) {
return filter.dofilter (resmap, politique, queryMap);
}
Retour Vrai;
}
}
// Méthode de recherche floue
classe FilterFuzzy étend le filtre {
@Outrepasser
booléen dofilter (map <string, objet> resmap, stratégie de stratégie, map <string, string> querymap) {
// Talage de méthode générée automatiquement de TODO
if (politique.name (). equalsignorecase (politique.fuzzy.name ())) {
String tempptr = resmap.values (). ToString (). Remplace ("", "") .replace (",", "");
Iterator <entrée <string, string >> iterator = querymap.entryset (). Iterator ();
while (iterator.hasnext ()) {
Entrée <string, string> entrée = iterator.next ();
if (temptr.substring (1, temptr.length () - 1) .Contains (entry.getValue ())) {
Retour Vrai;
}
}
} else if (filter! = null) {
return filter.dofilter (resmap, politique, queryMap);
}
Retour Vrai;
}
}
// aide la classe implémente K1-K2-V
classe publique HashhashMap <K1, K2, V> {
privé concurrenthashmap <k1, concurrenthashmap <k2, v >> k1k2vmap;
public hashhashmap () {
this.k1k2vmap = new concurrenthashmap <k1, concurrenthashmap <k2, v >> ();
}
public void put (k1 key1, k2 key2, v valeur) {
if (k1k2vmap.containsKey (key1)) {
ConcurrentHashmap <k2, v> k2vmap = k1k2vmap.get (key1);
k2vmap.put (key2, valeur);
} autre {
ConcurrentHashmap <k2, v> k2vmap = new concurrenthashmap <k2, v> ();
k2vmap.put (key2, valeur);
k1k2vmap.put (key1, k2vmap);
}
}
ensemble public <K1> getFirstKeys () {
retour 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);
}
Boolean public Contiseykey (K1 Key1, K2 Key2) {
if (k1k2vmap.containsKey (key1)) {
return k1k2vmap.get (key1) .ContainsKey (key2);
}
retourne false;
}
Boolean public Contiseykey (K1 Key1) {
return k1k2vmap.containsKey (key1);
}
public void clear () {
if (k1k2vmap.size ()> 0) {
pour (concurrenthashmap <k2, v> k2vmap: k1k2vmap.values ()) {
k2vmap.clear ();
}
k1k2vmap.clear ();
}
}
}
// Méthode d'utilisation spécifique
Hashhashmap <stratégie, string, string> map = new HashhashMap <commonLocalQuery.Policy, String, String> ();
for (int i = 0; i <querykey.length; i ++) {
map.put (Policy.Normal, QueryKey [i], queryValue [i]);
}
List <map <string, objet >> mtemplist = new CommonLocalQuery <hashmap <string, objet >> (