java mysql like_java使用list实现数据库的like功能

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>(