Java 如果某些条件已满，则对流应用过滤器

如何根据布尔值将过滤器添加到流中

例如variable=false（我不添加过滤器），如果variable=true，我添加它

list.stream()
  .filter(I want do add or not add this filter depending on boolean variable)
  .map(mapping method).collect(Collectors.toList)

---

我可以想出两种方法

我认为最简单的方法就是检查条件并写出相应的函数式编程结构

if (var) list.stream().filter().map().collect(Collectors.toList)
else list.stream().map().collect(Collectors.toList)

否则，请在筛选器本身中执行条件检查。在过滤器中，如果变量为true，我们总是返回true，从而使过滤器的行为无效，如果变量为false，则我们执行实际的过滤器逻辑

list.stream().filter(()=>{
if (!var) return true;
else doFilter();
}).map().collect(Collectors.toList)

---

我可以想出两种方法

我认为最简单的方法就是检查条件并写出相应的函数式编程结构

if (var) list.stream().filter().map().collect(Collectors.toList)
else list.stream().map().collect(Collectors.toList)

否则，请在筛选器本身中执行条件检查。在过滤器中，如果变量为true，我们总是返回true，从而使过滤器的行为无效，如果变量为false，则我们执行实际的过滤器逻辑

list.stream().filter(()=>{
if (!var) return true;
else doFilter();
}).map().collect(Collectors.toList)

---

以下是我将如何做到这一点。创建一个返回谓词的函数。根据您的参数，它要么应用您传入的函数，要么创建一个无操作谓词（即始终计算为true的谓词）：

公共谓词createPredicate（boolean shouldApply，函数fun）{
return（t）->shouldApply？乐趣。apply（t）：true；
}

以下是一些测试，以展示如何使用类似的内容：

private static final List<Integer> sampleList = List.of(1, 2, 3, 4, 5, 6);

@Test
public void shouldNotApplyFilter() {
    List<Integer> result = sampleList
            .stream()
            .filter(createPredicate(false, i -> i % 2 == 0))
            .map(i -> i * 2)
            .collect(Collectors.toList());

    Assertions.assertEquals(6, result.size());
}

@Test
public void shouldApplyFilter() {
    List<Integer> result = sampleList
            .stream()
            .filter(createPredicate(true, i -> i % 2 == 0))
            .map(i -> i * 2)
            .collect(Collectors.toList());

    Assertions.assertEquals(3, result.size());
}

private static final List sampleList=List.of（1,2,3,4,5,6）；
@试验
public void不应应用于筛选（）{
列表结果=样本列表
.stream（）
.filter（createPredicate（false，i->i%2==0））
.map（i->i*2）
.collect（Collectors.toList（））；
assertEquals（6，result.size（））；
}
@试验
public void应该应用过滤器（）{
列表结果=样本列表
.stream（）
.filter（createPredicate（true，i->i%2==0））
.map（i->i*2）
.collect（Collectors.toList（））；
assertEquals（3，result.size（））；
}

以下是我将如何做到这一点。创建一个返回谓词的函数。根据您的参数，它要么应用您传入的函数，要么创建一个无操作谓词（即始终计算为true的谓词）：

公共谓词createPredicate（boolean shouldApply，函数fun）{
return（t）->shouldApply？乐趣。apply（t）：true；
}

以下是一些测试，以展示如何使用类似的内容：

private static final List<Integer> sampleList = List.of(1, 2, 3, 4, 5, 6);

@Test
public void shouldNotApplyFilter() {
    List<Integer> result = sampleList
            .stream()
            .filter(createPredicate(false, i -> i % 2 == 0))
            .map(i -> i * 2)
            .collect(Collectors.toList());

    Assertions.assertEquals(6, result.size());
}

@Test
public void shouldApplyFilter() {
    List<Integer> result = sampleList
            .stream()
            .filter(createPredicate(true, i -> i % 2 == 0))
            .map(i -> i * 2)
            .collect(Collectors.toList());

    Assertions.assertEquals(3, result.size());
}

private static final List sampleList=List.of（1,2,3,4,5,6）；
@试验
public void不应应用于筛选（）{
列表结果=样本列表
.stream（）
.filter（createPredicate（false，i->i%2==0））
.map（i->i*2）
.collect（Collectors.toList（））；
assertEquals（6，result.size（））；
}
@试验
public void应该应用过滤器（）{
列表结果=样本列表
.stream（）
.filter（createPredicate（true，i->i%2==0））
.map（i->i*2）
.collect（Collectors.toList（））；
assertEquals（3，result.size（））；
}

流。过滤器

是一个中间操作。这意味着它将返回另一个

流

实例，因此您可以使用常见的老式局部变量：

Stream<Whatever> s = list.stream();
if (variable) {
    s = s.filter(x -> /* some condition to filter elements */);
}
List<SomethingElse> result = s.map(x -> /* map whatever to something else */)
                              .collect(Collectors.toList());

streams=list.Stream（）；
if（变量）{
s=s.过滤器（x->/*过滤器元件的某些条件*/）；
}
List result=s.map（x->/*将任何内容映射到其他内容*/）
.collect（Collectors.toList（））；

流。过滤器

是一个中间操作。这意味着它将返回另一个

流

实例，因此您可以使用常见的老式局部变量：

Stream<Whatever> s = list.stream();
if (variable) {
    s = s.filter(x -> /* some condition to filter elements */);
}
List<SomethingElse> result = s.map(x -> /* map whatever to something else */)
                              .collect(Collectors.toList());

streams=list.Stream（）；
if（变量）{
s=s.过滤器（x->/*过滤器元件的某些条件*/）；
}
List result=s.map（x->/*将任何内容映射到其他内容*/）
.collect（Collectors.toList（））；

…或干脆

list.stream（）.filter（项->！variable | doFilter（项））.map（映射方法）.collector（collector.toList）

…或干脆

list.stream（）.filter（项->！variable | doFilter（项））.map（映射方法）.collector（collector.toList）