流和lambdas作为参数

我有多个函数根据条件过滤对象的贴图

函数具有相同的主体，只有布尔传递条件会更改

    filterOnFirstCriteria(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys) {
        for (Map.Entry<Integer, List<Container>> entry : containerMap.entrySet()) {
            List<Container> containers = entry.getValue();
            ClassKey classKey = classKeys.get(entry.getKey());
            for (Container container : containers) {
                List<MyObject> found = new ArrayList<>();
                for (MyObject myObject : container.getMyObjects()) {
                    boolean pass = criterias.getListOfFilter().stream().filter(s -> s.equals(container.getReference())).count() > 0;
                    if (pass) {
                        found.add(myObject);
                    }
                }
                container.getMyObjects().removeAll(found);
            }
        }
    }


filterOnOtherCriteria(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys) {
        for (Map.Entry<Integer, List<Container>> entry : containerMap.entrySet()) {
            List<Container> containers = entry.getValue();
            ClassKey classKey = classKeys.get(entry.getKey());
            for (Container container : containers) {
                List<MyObject> found = new ArrayList<>();
                for (MyObject myObject : container.getMyObjects()) {
                    boolean pass = myObject.getListOfObject().stream().filter(obj -> criterias.getLocations().stream().anyMatch(location -> location.equals(obj.getLocation()))).count() > 0;
                    if (pass) {
                        found.add(myObject);
                    }
                }
                container.getMyObjects().removeAll(found);
            }
        }
    }

filterOnFirstCriteria（criterias criterias、Map containerMap、Map classKeys）{
对于（Map.Entry:containerMap.entrySet（））{
列表容器=entry.getValue（）；
ClassKey ClassKey=ClassKey.get（entry.getKey（））；
用于（容器：容器）{
找到的列表=新的ArrayList（）；
对于（MyObject MyObject:container.getMyObjects（））{
布尔过程=criterias.getListOfFilter（）.stream（）.filter（s->s.equals（container.getReference（））.count（）>0；
如果（通过）{
找到。添加（myObject）；
}
}
container.getMyObjects（）.removeAll（已找到）；
}
}
}
filterOnOtherCriteria（条件标准、映射容器映射、映射类键）{
对于（Map.Entry:containerMap.entrySet（））{
列表容器=entry.getValue（）；
ClassKey ClassKey=ClassKey.get（entry.getKey（））；
用于（容器：容器）{
找到的列表=新的ArrayList（）；
对于（MyObject MyObject:container.getMyObjects（））{
布尔过程=myObject.GetListoObject（）.stream（）.filter（obj->criterias.getLocations（）.stream（）.anyMatch（location->location.equals（obj.getLocation（））））.count（）>0；
如果（通过）{
找到。添加（myObject）；
}
}
container.getMyObjects（）.removeAll（已找到）；
}
}
}

条件可以在上部循环中的任何对象上设置。 我想将重复的循环代码提取到函数中，但我不知道如何为布尔条件传递某种回调

---

谢谢。

这两种方法的唯一区别在于声明：

boolean pass = criterias.getListOfFilter().stream()
    .filter(s -> s.equals(container.getReference()))
    .count() > 0;

及

第一条语句不依赖于从内部循环获取的

myObject

，而是依赖于从外部循环获取的

container

。它还取决于传递给方法的参数

标准

第二条语句取决于从内部循环获取的
myObject
，以及传递给该方法的参数
criterias

因此，如果您想重构这些语句，从而生成
布尔值
，则必须找到一种支持这两种语句的统一方法，如：

@FunctionalInterface
public interface Guardian {
    boolean pass(MyObject myObject, Container container);
}

现在，您可以提取这两条语句，并将它们作为lambdas传递给新方法：

public static void filterOnFirstCriteria(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys) {
    filterOn(criterias, containerMap, classKeys, (myObject, container) ->
        criterias.getListOfFilter().stream()
                                   .filter(s -> s.equals(container.getReference()))
                                   .count() > 0);
}

public static void filterOnOtherCriteria(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys) {
    filterOn(criterias, containerMap, classKeys, (myObject, container) ->
        myObject.getListOfObject().stream()
                                  .filter(obj -> criterias.getLocations().stream().anyMatch(location -> location.equals(obj.getLocation())))
                                  .count() > 0);
}

public static void filterOn(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys, Guardian guardian) {
    for (Map.Entry<Integer, List<Container>> entry : containerMap.entrySet()) {
        List<Container> containers = entry.getValue();
        ClassKey classKey = classKeys.get(entry.getKey());
        for (Container container : containers) {
            List<MyObject> found = new ArrayList<>();
            for (MyObject myObject : container.getMyObjects()) {
                if (guardian.pass(myObject, container)) {
                    found.add(myObject);
                }
            }
            container.getMyObjects().removeAll(found);
        }
    }
}

publicstaticvoidfilteronfirstcriteria（criterias、Map containerMap、Map classkey）{
过滤器（标准，容器映射，类键，（myObject，容器）->
criterias.getListoFilter（）.stream（）
.filter（s->s.equals（container.getReference（）））
.count（）>0）；
}
公共静态空过滤器其他条件（条件标准、映射容器映射、映射类键）{
过滤器（标准，容器映射，类键，（myObject，容器）->
myObject.getListoObject（）.stream（）
.filter（obj->criterias.getLocations（）.stream（）.anyMatch（location->location.equals（obj.getLocation（）））
.count（）>0）；
}
公共静态无效过滤器（标准标准、地图容器映射、地图类键、守护者）{
对于（Map.Entry:containerMap.entrySet（））{
列表容器=entry.getValue（）；
ClassKey ClassKey=ClassKey.get（entry.getKey（））；
用于（容器：容器）{
找到的列表=新的ArrayList（）；
对于（MyObject MyObject:container.getMyObjects（））{
if（监护人通行证（myObject，容器））{
找到。添加（myObject）；
}
}
container.getMyObjects（）.removeAll（已找到）；
}
}
}
传递一个附加谓词，其中上下文将包含谓词在其中判断所需的所有信息，并应返回true或false（即myObject、container、criterias）。
public static void filterOnFirstCriteria(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys) {
    filterOn(criterias, containerMap, classKeys, (myObject, container) ->
        criterias.getListOfFilter().stream()
                                   .filter(s -> s.equals(container.getReference()))
                                   .count() > 0);
}

public static void filterOnOtherCriteria(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys) {
    filterOn(criterias, containerMap, classKeys, (myObject, container) ->
        myObject.getListOfObject().stream()
                                  .filter(obj -> criterias.getLocations().stream().anyMatch(location -> location.equals(obj.getLocation())))
                                  .count() > 0);
}

public static void filterOn(Criteria criterias, Map<Integer, List<Container>> containerMap, Map<Integer, ClassKey> classKeys, Guardian guardian) {
    for (Map.Entry<Integer, List<Container>> entry : containerMap.entrySet()) {
        List<Container> containers = entry.getValue();
        ClassKey classKey = classKeys.get(entry.getKey());
        for (Container container : containers) {
            List<MyObject> found = new ArrayList<>();
            for (MyObject myObject : container.getMyObjects()) {
                if (guardian.pass(myObject, container)) {
                    found.add(myObject);
                }
            }
            container.getMyObjects().removeAll(found);
        }
    }
}