Verwenden Sie die Liste, um datenbankähnliche und präzise Suchmethoden zu implementieren
Die Codekopie lautet wie folgt:
öffentliche endgültige Klasse CommonLocalQuery <T erweitert Karte <String, Objekt >> {
// LISTE RETURIE LISTE nach dem Übergeben in Datenabfrage, dem ersten Parameter: die Abfrageliste, der zweite Parameter: die Abfragebedingung
öffentliche Liste <T> queryData (endgültige Liste <T> MALKLISTE, endgültiger HashhashMap <Richtlinie, String, String> Map) {
if (malllist == null | map == null) {
return New ArrayList <T> ();
}
if (talllist.isempty ()) {
Handlungsliste zurückkehren;
}
/* Finden Sie die passenden Abfragebedingungen basierend auf den tatsächlichen Anforderungen*/
Set <Politik> key1 = map.getFirstkeys ();
für (Richtlinienrichtlinie: Key1) {
ConcurrentHasMap <String, String> tempmap = map.get (Richtlinie);
Set <string> key2 = tempMap.keyset ();
für (String -Schlüssel: Key2) {
if (key.startswith ("-") || tempmap.get (key) == null ||
(tempmap.get (Schlüssel)! = null && tempmap.get (Schlüssel) .Equals (""))) {
tempmap.remove (Schlüssel);
}
}
}
// Finden Sie das Muster der Verantwortungskettendesign
Filter Filternormal, Filterbeträum, filterfuzzy;
filternormal = neu filternormal ();
filterbetween = neuer filterbetween ();
filterfuzzy = new FilterFuzzy ();
filternormal.setFilter (filterbetween);
filterbetween.setFilter (filterFuzzy);
Set <Politik> endKey1 = map.getFirstkeys ();
List <t> listesult = new ArrayList <T> ();
für (t resmap: talllist) {
für (Richtlinienrichtlinie: EndKey1) {
ConcurrentHasMap <String, String> querymap = map.get (Richtlinie);
if (filternormal.dofilter (Resmap, Richtlinie, Querymap) && listesult.contains (resmap)) {
listresult.add (RESMAP);
}
}
}
Rückgabe listresult;
}
public static enum Policy {normal, zwischen, fuzzy}
}
/*========= Verantwortungskette Abstract Class ======*/////
Zusammenfassung Klassenfilter {
Filterfilter;
public void setfilter (Filterfilter) {
this.filter = filter;
}
public filter getFilter () {
Rückgabefilter;
}
Abstract Boolean Dofilter (MAP <String, Object> RESMAP, Richtlinienrichtlinie, MAP <String, String> Querymap);
}
// präzise Suchmethode
Class Filternormal erweitert Filter {
@Override
Boolean Dofilter (MAP <String, Objekt> RESMAP, Richtlinienrichtlinie, MAP <String, String> Querymap) {
// Todo automatisch generierte Methode Stub
if (Policy.Name (). EqualSignoreCase (Policy.Normal.Name ())) {
Iterator <Eintrag <String, String >> iterator = querymap.EntrySet (). Iterator ();
while (iterator.hasnext ()) {
Eintrag <String, String> Eintrag = iterator.next ();
if (! resmap.get (Entry.getKey ()). toString (). Enthält (Eintrag.getValue ()) {
false zurückgeben;
}
}
} else if (filter! = null) {
Rückgabe filter.dofilter (RESMAP, Richtlinie, Querymap);
}
zurückkehren;
}
}
// zwischen Suchmethode
Klassenfilterbeträge erweitert Filter {
@Override
Boolean Dofilter (MAP <String, Objekt> RESMAP, Richtlinienrichtlinie, MAP <String, String> Querymap) {
// Todo automatisch generierte Methode Stub
if (Policy.Name (). EqualSignoreCase (Rictile.between.Name ()) {
Iterator <Eintrag <String, String >> iterator = querymap.EntrySet (). Iterator ();
while (iterator.hasnext ()) {
Eintrag <String, String> Eintrag = iterator.next ();
if (! muster.matches (".+? φ.+?", Eintrag. GETVALUE ()))
Neue unbekannte ERROR werfen ("Werte sollten sein.+? φ.+? Muster");
String firstValue = Eintrag.getValue (). Split ("φ") [0];
String SecondValue = Eintrag.GetValue (). Split ("φ") [1];
if (resmap.get (Entry.getKey ()). toString (). Vergleiche (FirstValue) <0
||.
false zurückgeben;
}
}
} else if (filter! = null) {
Rückgabe filter.dofilter (RESMAP, Richtlinie, Querymap);
}
zurückkehren;
}
}
// Fuzzy -Suchmethode
Klasse filterfuzzy erweitert den Filter {
@Override
Boolean Dofilter (MAP <String, Objekt> RESMAP, Richtlinienrichtlinie, MAP <String, String> Querymap) {
// Todo automatisch generierte Methode Stub
if (Policy.Name (). EqualSignoreCase (Policy.fuzzy.Name ())) {
String tempstr = resmap.Values (). ToString (). Ersetzen ("", "") .Replace (",", "");
Iterator <Eintrag <String, String >> iterator = querymap.EntrySet (). Iterator ();
while (iterator.hasnext ()) {
Eintrag <String, String> Eintrag = iterator.next ();
if (tempstr.substring (1, tempstr.length ()-1) .Contains (Eintrag.getValue ()) {
zurückkehren;
}
}
} else if (filter! = null) {
Rückgabe filter.dofilter (RESMAP, Richtlinie, Querymap);
}
zurückkehren;
}
}
// Hilfsklasse implementiert K1-K2-V
öffentliche Klasse HashhashMap <k1, k2, v> {
Private Concurrenthashmap <k1, Concurrenthashmap <k2, v >> k1k2vmap;
public HashhashMap () {
this.k1k2vmap = new Concurrenthashmap <k1, Concurrenthashmap <k2, v >> ();
}
public void put (K1 Key1, K2 Key2, V -Wert) {
if (k1k2vmap.ContainsKey (key1)) {
Concurrenthashmap <k2, v> k2vmap = k1k2vmap.get (key1);
k2vmap.put (Key2, Wert);
} anders {
Concurrenthashmap <k2, v> k2vmap = new Concurrenthashmap <k2, v> ();
k2vmap.put (Key2, Wert);
k1k2vmap.put (key1, k2vmap);
}
}
public set <k1> getfirstkeys () {
return k1k2vmap.keyset ();
}
public v get (k1 key1, k2 key2) {
ConcurrentHasMap <k2, v> k2_v = k1k2vmap.get (Key1);
return k2_v == null?
}
public ConcurrenthashMap <k2, v> get (k1 key1) {
return k1k2vmap.get (key1);
}
public boolean enthälty (k1 key1, k2 key2) {
if (k1k2vmap.ContainsKey (key1)) {
return k1k2vmap.get (key1) .ContainsKey (Key2);
}
false zurückgeben;
}
public boolean enthälty (k1 key1) {
return k1k2vmap.ContainsKey (Key1);
}
public void clear () {
if (k1k2vmap.size ()> 0) {
für (Concurrenthashmap <k2, v> k2vmap: k1k2vmap.values ()) {
k2vmap.clear ();
}
k1k2vmap.clear ();
}
}
}
// Spezifische Verwendungsmethode
HashhashMap <Richtlinie, String, String> map = new HashhashMap <CommonLocalQuery.policy, String, String> ();
für (int i = 0; i <queryKey.length; i ++) {
map.put (policy.normal, queryKey [i], queryValue [i]);
}
Liste <map <String, Objekt >> mtemplist = new CommonLocalQuery <HashMap <String, Object >> (