Java-集合条件筛选

 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;

 import org.apache.commons.beanutils.BeanPredicate;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.collections.Predicate;
 import org.apache.commons.collections.PredicateUtils;
 import org.apache.commons.collections.functors.EqualPredicate;

 import com.yanfuchang.work.common.Reflections;

 /**
  * @ClassName: ConditionFilterUtil
  * @Description: 条件过滤工具类
  */
 public class ConditionFilterUtil {

     /**
      *    用于处理属性与属性值的类
      */
     public static class ConditionListMap {
         private Map<String, List<Object>> map = new HashMap<String, List<Object>>();
         public List<Object> get(String key) {
             return map.get(key);
         };
         public Map<String, List<Object>> getMap() {
             return map;
         }
         public void put(String key, Object value) {
             List<Object> list = map.get(key);
             if (list != null) {
                 list.add(value);
             } else {
                 List<Object> arrayList = new ArrayList<Object>();
                 arrayList.add(value);
                 map.put(key, arrayList);
             }
         }
     }

     /**
      * 根据条件筛选出相应对象集合
      */
     @SuppressWarnings("unchecked")
     public static <T> List<T> findList(Collection<T> list, String propertyName, Object agers) {
         if (agers == null) { // 如果是空则返回一个复制的集合
             return new ArrayList<T>(list);
         }
         EqualPredicate parameter = new EqualPredicate(agers);
         BeanPredicate tableCoulmn_paramerter = new BeanPredicate(propertyName, parameter);
         List<T> filteredCollection = null;
         synchronized (list) {
             filteredCollection = (List<T>) CollectionUtils.select(list, tableCoulmn_paramerter);
         }
         return filteredCollection;
     }

     /**
      * 根据条件筛选出相应对象集合,只对该对象本身的属性进行筛选，排除继承属性
      */
     @SuppressWarnings("unchecked")
     public static <T> List<T> findListByMultiCond(Collection<T> list, T obj) {

         try {
             if (obj == null) { // 如果是空则返回一个复制的集合
                 return new ArrayList<T>(list);
             }
             Predicate allPredicate = getAllPredicateByList(obj);
             List<T> filteredCollection = null;
             synchronized (list) {
                 filteredCollection = (List<T>) CollectionUtils.select(list, allPredicate);
             }
             return filteredCollection;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return new ArrayList<T>();
     }

     /**
      * 根据条件筛选出相应对象集合,只对该对象本身的属性进行筛选，排除继承属性
      */
     @SuppressWarnings("unchecked")
     public static <T> List<T> findListByMultiCond(List<T> list, T obj) {

         try {
             if (obj == null) { // 如果是空则返回一个复制的集合
                 return new ArrayList<T>(list);
             }
             Predicate allPredicate = getAllPredicateByList(obj);
             List<T> filteredCollection = null;
             synchronized (list) {
                 filteredCollection = (List<T>) CollectionUtils.select(list, allPredicate);
             }
             return filteredCollection;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return new ArrayList<T>();
     }

     /**
      * 获取满足所有条件的断言
      */
     public static Predicate getAllPredicateByList(ConditionListMap conditionListMap) {

         Map<String, List<Object>> propertyValMap = conditionListMap.getMap();
         List<Predicate> predicateList = new ArrayList<Predicate>();
         Set<Entry<String, List<Object>>> entrySet = propertyValMap.entrySet();
         for (Entry<String, List<Object>> entry : entrySet) {
             String key = entry.getKey();
             List<Object> values = entry.getValue();
             for (Object value : values) {
                 EqualPredicate parameter = new EqualPredicate(value);
                 BeanPredicate tableCoulmn_paramerter = new BeanPredicate(key, parameter);
                 predicateList.add(tableCoulmn_paramerter);

             }
         }
         Predicate predicate = PredicateUtils.allPredicate(predicateList);
         return predicate;
     }

     /**
      * 获取满足所有条件的断言
      */
     public static Predicate getAllPredicateByList(Map<String, Object> propertyValMap) {
         List<Predicate> predicateList = new ArrayList<Predicate>();
         Set<Entry<String, Object>> entrySet = propertyValMap.entrySet();
         for (Entry<String, Object> entry : entrySet) {
             String key = entry.getKey();
             Object value = entry.getValue();

             EqualPredicate parameter = new EqualPredicate(value);
             BeanPredicate tableCoulmn_paramerter = new BeanPredicate(key, parameter);
             predicateList.add(tableCoulmn_paramerter);
         }
         Predicate predicate = PredicateUtils.allPredicate(predicateList);
         return predicate;
     }

     /**
      * 获取满足所有条件的断言
      */
     public static <T> Predicate getAllPredicateByList(T obj) {
         List<Predicate> predicateList = new ArrayList<Predicate>();
         Field[] declaredFields = obj.getClass().getDeclaredFields();
         for (Field field : declaredFields) {
             if (Modifier.isFinal(field.getModifiers()) || Modifier.isStatic(field.getModifiers()))
                 continue; // static或final遍历下一个
             Object fieldValue = Reflections.getFieldValue(obj, field.getName());
             if (fieldValue == null)
                 continue;
             EqualPredicate parameter = new EqualPredicate(fieldValue);
             BeanPredicate tableCoulmn_paramerter = new BeanPredicate(field.getName(), parameter);
             predicateList.add(tableCoulmn_paramerter);
         }

         Predicate finalPredicate = PredicateUtils.allPredicate(predicateList);
         return finalPredicate;
     }

     /**
      * 获取满足任意条件的断言
      */
     public static Predicate getAnyPredicateByList(ConditionListMap conditionListMap) {

         Map<String, List<Object>> propertyValMap = conditionListMap.getMap();
         List<Predicate> predicateList = new ArrayList<Predicate>();
         Set<Entry<String, List<Object>>> entrySet = propertyValMap.entrySet();
         for (Entry<String, List<Object>> entry : entrySet) {
             String key = entry.getKey();
             List<Object> values = entry.getValue();
             for (Object value : values) {
                 EqualPredicate parameter = new EqualPredicate(value);
                 BeanPredicate tableCoulmn_paramerter = new BeanPredicate(key, parameter);
                 predicateList.add(tableCoulmn_paramerter);

             }
         }
         Predicate predicate = PredicateUtils.anyPredicate(predicateList);
         return predicate;
     }

     /**
      * 获取满足任意条件的断言
      */
     public static Predicate getAnyPredicateByList(Map<String, List<Object>> propertyValMap) {

         List<Predicate> predicateList = new ArrayList<Predicate>();
         Set<Entry<String, List<Object>>> entrySet = propertyValMap.entrySet();
         for (Entry<String, List<Object>> entry : entrySet) {
             String key = entry.getKey();
             List<Object> values = entry.getValue();
             for (Object value : values) {
                 EqualPredicate parameter = new EqualPredicate(value);
                 BeanPredicate tableCoulmn_paramerter = new BeanPredicate(key, parameter);
                 predicateList.add(tableCoulmn_paramerter);

             }
         }
         Predicate predicate = PredicateUtils.anyPredicate(predicateList);
         return predicate;
     }

     /**
      * 获取满足所有条件的断言
      */
     public static <T> Predicate getAnyPredicateByList(T obj) {
         List<Predicate> predicateList = new ArrayList<Predicate>();
         Field[] declaredFields = obj.getClass().getDeclaredFields();
         for (Field field : declaredFields) {
             if (Modifier.isFinal(field.getModifiers()) || Modifier.isStatic(field.getModifiers()))
                 continue; // static或final遍历下一个
             Object fieldValue = Reflections.getFieldValue(obj, field.getName());
             if (fieldValue == null)
                 continue;
             EqualPredicate parameter = new EqualPredicate(fieldValue);
             BeanPredicate tableCoulmn_paramerter = new BeanPredicate(field.getName(), parameter);
             predicateList.add(tableCoulmn_paramerter);
         }

         Predicate finalPredicate = PredicateUtils.anyPredicate(predicateList);
         return finalPredicate;
     }

     @SuppressWarnings("unchecked")
     public static <T> T getFirst(Collection<T> list, String propertyName, Object agers) {
         EqualPredicate parameter = new EqualPredicate(agers);
         BeanPredicate tableCoulmn_paramerter = new BeanPredicate(propertyName, parameter);
         T finalResult = null;
         synchronized (list) {
             finalResult = (T) CollectionUtils.find(list, tableCoulmn_paramerter);
         }
         return finalResult;
     }

     /**
      * 根据条件筛选出相应对象集合
      */
     @SuppressWarnings("unchecked")
     public static <T> T getFirst(List<T> list, String propertyName, Object agers) {
         Predicate finalPredicate = null;
         if (agers == null) {
             finalPredicate = PredicateUtils.truePredicate();
         } else {
             EqualPredicate parameter = new EqualPredicate(agers);
             BeanPredicate tableCoulmn_paramerter = new BeanPredicate(propertyName, parameter);
             T finalResult = null;
             synchronized (list) {
                 finalResult = (T) CollectionUtils.find(list, tableCoulmn_paramerter);
             }
             return finalResult;
         }
         return null;
     }

     @SuppressWarnings("unchecked")
     public static <T> T getFirstByMultiCond(Collection<T> list, T obj) {
         Predicate allPredicateByList = getAllPredicateByList(obj);
         T finalResult = null;
         synchronized (list) {
             finalResult = (T) CollectionUtils.find(list, allPredicateByList);
         }
         return finalResult;
     }

     /**
      * 根据条件筛选出相应对象集合
      */
     @SuppressWarnings("unchecked")
     public static <T> T getFirstByMultiCond(List<T> list, T obj) {
         Predicate allPredicateByList = getAllPredicateByList(obj);
         T finalResult = null;
         synchronized (list) {
             finalResult = (T) CollectionUtils.find(list, allPredicateByList);
         }
         return finalResult;
     }

     /**
      * 获得ConditionListMap
      */
     public static ConditionListMap newConditionListMap() {
         return new ConditionListMap();
     }
 }

依赖：

         <dependency>
             <groupId>commons-beanutils</groupId>
             <artifactId>commons-beanutils</artifactId>
             <version>1.9.1</version>
             <exclusions>
                 <exclusion>
                     <groupId>commons-logging</groupId>
                     <artifactId>commons-logging</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>