Filter 使用另一个ArrayList Java 8动态筛选ArrayList

我有一些搜索结果对象，如下所示：

public class TradeSearchResult{ 

    private String tradeRefNo;
    private String relatedTradeId;
    private String custodyDate;
    private String orderNumber;
    private String odrQty;
    private String price : 500;
}

public class CollateralTradesSearchResult{

    private String excludeTradeOUT;
    private String settlementStatus;
    private String fundId;
    private String altFundId;
    private String apNumber;
    private String collateralOrderNumber;
    private String componenetIdentifier;
}

现在我有了一个搜索筛选条件对象

public class CRITERION {  

    protected String field; //The field denotes any field name of the either 
                              SearchResult object
    protected String operator; its will be EQUALS or NOT_EQUALS   
    protected String value; Value of the field.
}

现在我需要编写一个动态过滤方法，在这里我将传递Criteria对象的列表，并且可以传递下面的任何一个SearchResult列表

public static List<Object> applyFilter(List<CRITERION> comp, List<?> objectList){

    //The CRITERION.fiedName can be same in more than one in the list 
    return filteredList;

}

即使relatedTradeId有两个过滤器，它也只返回一个结果

TradeSearchResult{
 tradeRefNo : W12344;
 relatedTradeId: N993093;
 custodyDate : 2018-12-14;
 orderNumber : 0000342344;
 String odrQty : 18;
 String price : 600;
}

现在，在相同的applyFIlter方法中，我可以发送条件列表和CollateralTradesSearchResult列表，并返回筛选结果。 这是我试过的东西

public static List<Object> applyFilter(List<CRITERION> criList, List<?> objectList){    
    long startTime = Calendar.getInstance().getTimeInMillis();          
        Set<Object> objectSet = new HashSet<>();    

        for(CRITERION cri : criList){
        String fieldName = cri.getFIELD();
        objectList.stream().filter(p->beanProperties(p).get(fieldName).equals(cri.getVALUE())).forEachOrdered(objectSet::add);
        //objectList.retainAll(objectSet);
        //objectSet.clear();
        }

        List<Object> ret =  new ArrayList<>(objectSet);
        long endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("Size"+ ret.size());
        System.out.println("Time Taken to Search"+ String.valueOf(endTime-startTime));
    return ret;
    }

publicstaticlistapplyfilter（List-criList，List-objectList）{
long startTime=Calendar.getInstance（）.getTimeInMillis（）；
Set objectSet=new HashSet（）；
对于（标准cri:criList）{
字符串fieldName=cri.getFIELD（）；
objectList.stream（）.filter（p->beanProperties（p）.get（fieldName）.equals（cri.getVALUE（））.forEachOrdered（objectSet:：add）；
//objectList.retainal（objectSet）；
//objectSet.clear（）；
}
List ret=新的ArrayList（对象集）；
long-endTime=Calendar.getInstance（）.getTimeInMillis（）；
System.out.println（“大小”+ret.Size（））；
System.out.println（“搜索时间”+String.valueOf（endTime startTime））；
返回ret；
}

下面是beanProperties（）方法

公共静态映射bean属性（对象bean）{
试一试{
Map Map=newhashmap（）；
Arrays.asList（Introspector.getBeanInfo（bean.getClass（），Object.class）
.getPropertyDescriptors（））
.stream（）
//仅使用setter筛选出属性
.filter（pd->Objects.nonNull（pd.getReadMethod（）））
.forEach（pd->{//调用方法以获取值
试一试{
Object value=pd.getReadMethod（）.invoke（bean）；
if（值！=null）{
put（pd.getName（），value）；
}
}捕获（例外e）{
//在此处添加正确的错误处理
}
});
返回图；
}捕获（内省异常e）{
//这里也是
return Collections.emptyMap（）；
}
}
使用Stream或通过任何方式提供的任何帮助都会有所帮助。

创建一个接口

SearchResult

，并让两个类都实现它。然后创建这个类：

public class Filter<T extends SearchResult> {

    public List<T> applyFilter(List<Criterion> criteria, List<T> list) {
        Map<String, Set<String>> allowedValues = new HashMap<>();
        Map<String, Set<String>> prohibitedValues = new HashMap<>();
        populateValues(criteria, "EQUALS", allowedValues);
        populateValues(criteria, "NOT_EQUALS", prohibitedValues);

        prohibitedValues.forEach((k, v) -> list.removeIf(t -> v.contains(getFieldValue(k, t))));
        allowedValues.forEach((k, v) -> list.removeIf(t -> !v.contains(getFieldValue(k, t))));
        return list;
    }

    private static void populateValues(List<Criterion> criteria, String operator, Map<String, Set<String>> values) {
        criteria.stream()
                .filter(c -> c.getOperator().equals(operator))
                .forEach(c -> {
                    values.merge(c.getField(), Stream.of(c.getValue()).collect(Collectors.toSet()),
                            (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
                });
    }

    private String getFieldValue(String fieldName, T object) {
        Field field;
        try {
            field = object.getClass().getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
            return null;
        }
        field.setAccessible(true);
        try {
            return (String) field.get(object);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }
}

公共类过滤器{
公共列表applyFilter（列表条件、列表）{
Map allowedValues=new HashMap（）；
Map prohibitedValues=newhashmap（）；
普及值（标准“等于”，允许值）；
普及价值观（标准，“不等于”，禁止价值观）；
forEach（（k，v）->list.removeIf（t->v.contains（getFieldValue（k，t）））；
forEach（（k，v）->list.removeIf（t->！v.contains（getFieldValue（k，t）））；
退货清单；
}
私有静态void populateValues（列表条件、字符串运算符、映射值）{
标准.流（）
.filter（c->c.getOperator（）.equals（运算符））
.forEach（c->{
values.merge（c.getField（）、Stream.of（c.getValue（））.collect（Collectors.toSet（）），
（set1，set2）->Stream.concat（set1.Stream（），set2.Stream（））.collect（collector.toSet（））；
});
}
私有字符串getFieldValue（字符串字段名，T对象）{
场域；
试一试{
field=object.getClass（）.getDeclaredField（fieldName）；
}捕获（无此字段例外）{
e、 printStackTrace（）；
返回null；
}
字段。setAccessible（true）；
试一试{
返回（字符串）字段。获取（对象）；
}捕获（非法访问例外e）{
e、 printStackTrace（）；
返回null；
}
}
}

并将其用作：

Filter<TradeSearchResult> filter = new Filter<>(); //or CollateralTradesSearchResult
List<TradeSearchResult> filteredList = filter.applyFilter(criteria, searchResults);

过滤器过滤器=新过滤器（）//或间接交易结果
List filteredList=filter.applyFilter（条件、搜索结果）；

您要求我们为您编写所有代码？但事实并非如此。请提供您尝试的内容（代码）以及您遇到的问题。

public class Filter<T extends SearchResult> {

    public List<T> applyFilter(List<Criterion> criteria, List<T> list) {
        Map<String, Set<String>> allowedValues = new HashMap<>();
        Map<String, Set<String>> prohibitedValues = new HashMap<>();
        populateValues(criteria, "EQUALS", allowedValues);
        populateValues(criteria, "NOT_EQUALS", prohibitedValues);

        prohibitedValues.forEach((k, v) -> list.removeIf(t -> v.contains(getFieldValue(k, t))));
        allowedValues.forEach((k, v) -> list.removeIf(t -> !v.contains(getFieldValue(k, t))));
        return list;
    }

    private static void populateValues(List<Criterion> criteria, String operator, Map<String, Set<String>> values) {
        criteria.stream()
                .filter(c -> c.getOperator().equals(operator))
                .forEach(c -> {
                    values.merge(c.getField(), Stream.of(c.getValue()).collect(Collectors.toSet()),
                            (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
                });
    }

    private String getFieldValue(String fieldName, T object) {
        Field field;
        try {
            field = object.getClass().getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
            return null;
        }
        field.setAccessible(true);
        try {
            return (String) field.get(object);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }
}

Filter<TradeSearchResult> filter = new Filter<>(); //or CollateralTradesSearchResult
List<TradeSearchResult> filteredList = filter.applyFilter(criteria, searchResults);