java - 在表达式中使用外部不可变变量的 Lambda 表达式

Question

我有专门为这个问题编写的示例代码，但它反射(reflect)了我在工作中遇到的真实场景:

List<String> names = Arrays.asList("ALICE", "Alice", "BOB", "Bob", "CHUCK", "Chuck");

Predicate<String> has_u_or_i_whenLowercased = Stream.of("u", "i")
        .map(bit -> (Predicate<String>) (source -> source.toLowerCase(Locale.ENGLISH).contains(bit)))
        .reduce(Predicate::or)
        .orElse(p -> false);

List<String> english = names.stream()
        .filter(has_u_or_i_whenLowercased)
        .collect(Collectors.toList());
System.out.println(english);
System.out.println(english.size());

它创建一个谓词，检查源字符串是否包含 u 或 i 当使用英语语言环境小写时(编辑: 有十几种更好更简单的方法来实现这一点，但这只是一个例子。在真实场景中，我根据任意数量的搜索条件过滤一个小数据集)。我将在一个类的多个方法中使用这个 lambda 表达式。

现在，假设我想要一个不同的语言环境，它将作为参数传递给将使用 lambda 表达式(而不是构造函数)的方法。在工作中，这不是我必须处理的 Locale，但我将其边界定义为不可变变量。

我能想到的最简单的解决方案是使用一个“构建”该 lambda 表达式的方法。

@Override
public void run() {
    List<String> names = Arrays.asList("ALICE", "Alice", "BOB", "Bob", "CHUCK", "Chuck");

    List<String> english = names.stream()
            .filter(createUIPredicate(Locale.ENGLISH))
            .collect(Collectors.toList());
    System.out.println(english);
    System.out.println(english.size());

    System.out.println("--");

    List<String> turkish = names.stream()
            .filter(createUIPredicate(new Locale("tr", "TR")))
            .collect(Collectors.toList());
    System.out.println(turkish);
    System.out.println(turkish.size());
}

private Predicate<String> createUIPredicate(Locale locale) {
    return Stream.of("u", "i")
            .map(bit -> (Predicate<String>) (source -> source.toLowerCase(locale).contains(bit)))
            .reduce(Predicate::or)
            .orElse(p -> false);
}

但是我觉得这种方法有问题。如果我将一个外部不可变变量注入(inject)到函数式接口(interface)中，我想也许我应该将它作为 lambda 表达式参数而不是某个地方传递？

当遇到一个在表达式中使用了外部不可变变量的 lambda 表达式，并且该不可变变量在流中间操作中的每次使用都可能不同，是否有一种特定的方法可以匹配已知的函数式编程模式？

Answer 1

您的方法解决方案和评论中的 lambda 解决方案之间并没有太大的实际区别，两者都利用了 lambdas“关闭”“有效最终”变量。两者在我编写的 Java 8 函数代码中都很常见。

private Predicate<String> build(Locale locale) {
  return str -> str.toLowerCase(locale);
}

对比:

Function<Locale, Predicate<String>> build = locale -> str -> str.toLowerCase(locale);

两者之间的决定只是风格偏好和/或该构建器是仅在单个方法中使用还是在类中的多个位置使用。