Java lambda循环

我仍然在搞清楚lambdas，我想知道一种方法

private enum Result
{
    RESULT1,
    RESULT2,
    RESULT3
}
public static Map<String, Result> calculateResults(List<String> list)
{
    Map<String, Result> map = new HashMap<>(list.size());
    List<String> leavings = new ArrayList<>(list);

    map.putAll(leavings.stream().filter(Main::firstFilter).collect(Collectors.toMap(s -> s, s -> Result.RESULT1)));
    leavings.removeAll(map.keySet());

    map.putAll(leavings.stream().filter(Main::secondFilter).collect(Collectors.toMap(s -> s, s -> Result.RESULT2)));
    leavings.removeAll(map.keySet());

    map.putAll(leavings.stream().filter(Main::thirdFilter).collect(Collectors.toMap(s -> s, s -> Result.RESULT3)));
    leavings.removeAll(map.keySet());

    return map;
}
private static boolean firstFilter(String s)
{
    return s.length() == 5;
}
private static boolean secondFilter(String s)
{
    return s.contains("A");
}
private static boolean thirdFilter(String s)
{
    return BlockedStrings.getInstance().contains(s);
}

私有枚举结果
{
结果1，
结果2，
结果3
}
公共静态地图计算结果（列表）
{
Map Map=newhashmap（list.size（））；
列表剩余=新的ArrayList（列表）；
putAll（leavings.stream（）.filter（Main:：firstFilter）.collect（Collectors.toMap（s->s，s->Result.RESULT1））；
removeAll（map.keySet（））；
putAll（leavings.stream（）.filter（Main:：secondFilter）.collect（Collectors.toMap（s->s，s->Result.RESULT2））；
removeAll（map.keySet（））；
putAll（leavings.stream（）.filter（Main:：thirdFilter）.collect（Collectors.toMap（s->s，s->Result.RESULT3））；
removeAll（map.keySet（））；
返回图；
}
私有静态布尔firstFilter（字符串s）
{
返回s.length（）==5；
}
私有静态布尔第二过滤器（字符串s）
{
报税表包含（“A”）；
}
私有静态布尔第三过滤器（字符串s）
{
返回BlockedStrings.getInstance（）.contains；
}

---

我认为若这可以在某种循环中实现，那个将是非常棒的，但我不知道如何编写代码。是否可以将筛选器谓词指定给枚举变量，或者执行其他操作以使其不可重复？

您的意思是这样的

List<Predicate<String>> predicates = Arrays.asList(
    Main::firstFilter, Main::secondFilter, Main::thirdFilter
);
Result[] results = Result.values();

for (int i = 0; i < predicates.size(); ++i) {
    final Predicate<String> predicate = predicates.get(i);
    final Result result = results[i];
    map.putAll(leavings.stream().filter(predicate)
             .collect(Collectors.toMap(s -> s, s -> result)));
    leavings.removeAll(map.keySet());
}

List谓词=Arrays.asList(
Main:：firstFilter，Main:：secondFilter，Main:：thirdFilter
);
Result[]results=Result.values（）；
for（int i=0；is，s->result））；
removeAll（map.keySet（））；
}

---

您还可以将过滤器合并到

结果

实例中；或者您可以使用一个漂亮的

EnumMap

来避免并行数组/列表迭代。

您的意思是这样的

List<Predicate<String>> predicates = Arrays.asList(
    Main::firstFilter, Main::secondFilter, Main::thirdFilter
);
Result[] results = Result.values();

for (int i = 0; i < predicates.size(); ++i) {
    final Predicate<String> predicate = predicates.get(i);
    final Result result = results[i];
    map.putAll(leavings.stream().filter(predicate)
             .collect(Collectors.toMap(s -> s, s -> result)));
    leavings.removeAll(map.keySet());
}

List谓词=Arrays.asList(
Main:：firstFilter，Main:：secondFilter，Main:：thirdFilter
);
Result[]results=Result.values（）；
for（int i=0；is，s->result））；
removeAll（map.keySet（））；
}

---

您还可以将过滤器合并到

结果

实例中；或者，您可以使用一个漂亮的

EnumMap

来避免并行数组/列表迭代。

如果您将筛选方法组合到一个确定每个字符串状态的方法中，您可以按如下方式计算结果，而不需要

剩余

列表：

public static Map<String, Result> calculateResults(List<String> list)
{
    return list.stream().filter(s -> calculateResult(s) != null)
            .collect(Collectors.toMap(Function.identity(), Main::calculateResult));
}

private static Result calculateResult(String s)
{
    if (s.length() == 5) return Result.RESULT1;
    if (s.contains("A")) return Result.RESULT2;
    if (blockedStrings.contains(s)) return Result.RESULT3;
    return null;
}

公共静态映射计算结果（列表）
{
return list.stream（）.filter->calculateResult！=null
.collect（Collectors.toMap（Function.identity（），Main:：calculateResult））；
}
私有静态结果计算器结果（字符串s）
{
如果（s.length（）==5）返回Result.RESULT1；
如果（s.contains（“A”））返回Result.RESULT2；
if（blockedStrings.contains）返回Result.RESULT3；
返回null；
}

如果将筛选方法组合成一个方法来确定每个字符串的状态，则可以按如下方式计算结果，而无需使用

剩余值列表：

public static Map<String, Result> calculateResults(List<String> list)
{
    return list.stream().filter(s -> calculateResult(s) != null)
            .collect(Collectors.toMap(Function.identity(), Main::calculateResult));
}

private static Result calculateResult(String s)
{
    if (s.length() == 5) return Result.RESULT1;
    if (s.contains("A")) return Result.RESULT2;
    if (blockedStrings.contains(s)) return Result.RESULT3;
    return null;
}

公共静态映射计算结果（列表）
{
return list.stream（）.filter->calculateResult！=null
.collect（Collectors.toMap（Function.identity（），Main:：calculateResult））；
}
私有静态结果计算器结果（字符串s）
{
如果（s.length（）==5）返回Result.RESULT1；
如果（s.contains（“A”））返回Result.RESULT2；
if（blockedStrings.contains）返回Result.RESULT3；
返回null；
}
我不确定你的意图是否正确，但在我看来，你似乎想做：

public static Map<String, Result> calculateResults(List<String> list) {
    return list.stream().filter(s -> firstFilter(s)||secondFilter(s)||thirdFilter(s))
        .collect(Collectors.toMap(s -> s, s -> firstFilter(s)? Result.RESULT1:
                              secondFilter(s)? Result.RESULT2: Result.RESULT3));
}

公共静态映射计算结果（列表）{
return list.stream（）.filter（s->firstFilter（s）| | | secondFilter（s）| | | thirdFilter（s））
.collect（收集器.toMap->s，s->firstFilter）？Result.RESULT1：
第二个过滤器？Result.RESULT2:Result.RESULT3）；
}

这样做的缺点是多次计算谓词。另一种方法是将评估结果存储到临时对象中：

public static Map<String, Result> calculateResults(List<String> list) {
    return list.stream().map(s -> new AbstractMap.SimpleImmutableEntry<>(s,
            firstFilter(s)? Result.RESULT1: secondFilter(s)? Result.RESULT2:
            thirdFilter(s)? Result.RESULT3: null))
        .filter(e -> e.getValue()!=null)
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}

公共静态映射计算结果（列表）{
return list.stream（）.map->new AbstractMap.SimpleImmutableEntry，
第一个过滤器？结果。结果1：第二个过滤器？结果。结果2：
第三个筛选器？Result.RESULT3:null）
.filter（e->e.getValue（）！=null）
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue））；
}
我不确定你的意图是否正确，但在我看来，你似乎想做：

public static Map<String, Result> calculateResults(List<String> list) {
    return list.stream().filter(s -> firstFilter(s)||secondFilter(s)||thirdFilter(s))
        .collect(Collectors.toMap(s -> s, s -> firstFilter(s)? Result.RESULT1:
                              secondFilter(s)? Result.RESULT2: Result.RESULT3));
}

公共静态映射计算结果（列表）{
return list.stream（）.filter（s->firstFilter（s）| | | secondFilter（s）| | | thirdFilter（s））
.collect（收集器.toMap->s，s->firstFilter）？Result.RESULT1：
第二个过滤器？Result.RESULT2:Result.RESULT3）；
}

这样做的缺点是多次计算谓词。另一种方法是将评估结果存储到临时对象中：

public static Map<String, Result> calculateResults(List<String> list) {
    return list.stream().map(s -> new AbstractMap.SimpleImmutableEntry<>(s,
            firstFilter(s)? Result.RESULT1: secondFilter(s)? Result.RESULT2:
            thirdFilter(s)? Result.RESULT3: null))
        .filter(e -> e.getValue()!=null)
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}

公共静态映射计算结果（列表）{
return list.stream（）.map->new AbstractMap.SimpleImmutableEntry，
第一个过滤器？结果。结果1：第二个过滤器？结果。结果2：
第三个筛选器？Result.RESULT3:null）
.filter（e->e.getValue（）！=null）
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue））；
}
发布主过滤器代码，以便于理解代码。是否尝试按元素属性对列表进行分组？如果是，请查看收集器。groupingBy（）是否正在查找
leavings.removeIf（Main:：firstFilter）
？枚举可以具有构造函数