未读代码 未读代码
首页
  • Java 18 新功能介绍
  • Java 17 新功能介绍
  • Java 16 新功能介绍
  • Java 15 新功能介绍
  • Java 14 新功能介绍
  • Java 8 新特性

    • Java 8 Lambda 表达式
    • Java 8 Stream 流式操作
    • Java 8 时间处理介绍
    • Java 8 Optional 介绍
  • Java 开发工具
Java 源码分析
Spring Boot 系列
  • Arthas 问题定位
  • JMH 基准测试
GitHub (opens new window)
首页
  • Java 18 新功能介绍
  • Java 17 新功能介绍
  • Java 16 新功能介绍
  • Java 15 新功能介绍
  • Java 14 新功能介绍
  • Java 8 新特性

    • Java 8 Lambda 表达式
    • Java 8 Stream 流式操作
    • Java 8 时间处理介绍
    • Java 8 Optional 介绍
  • Java 开发工具
Java 源码分析
Spring Boot 系列
  • Arthas 问题定位
  • JMH 基准测试
GitHub (opens new window)
  • Java 新特性

  • Java8 新特性

    • Java 8 Lambda 和 Comparator 排序
    • Java 8 Optional 介绍
    • Java 8 Lambda 表达式介绍
    • Java 8 Stream 流式操作
    • Java 8 LocalDate、LocalDateTime 时间处理介绍
    • Java 8 List 转 Map
    • Java 8 Function 函数接口
    • Java 8 Supplier 函数接口
    • Java 8 Consumer 函数接口
    • Java 8 Predicate 函数接口
      • 1. Predicate test
      • 2. Predicate Stream filter
      • 3. Predicate and
      • 4. Predicate negate
      • 5. Predicate or
      • 6. Predicate 链式编程
      • 7. Predicate 与对象
      • 参考
    • Java 8 forEach 遍历
    • Java 8 BiFunction 函数接口
    • Java 8 BiPredicate 函数接口
    • Java 8 UnaryOperator 函数接口
  • Java 新特性
  • Java8 新特性
程序猿阿朗
2021-07-21

Java 8 Predicate 函数接口

这篇文章属于 Java 8 教程(LTS)系列教程,点击阅读更多相关文章。

Predicate 函数接口同之前介绍的 Function (opens new window) 接口一样,是一个函数式接口,它可以接受一个泛型 <T> 参数,返回值为布尔类型。Predicate 常用于数据过滤,如过滤出集合中符合某个条件的元素。

源码:Java 8 中函数接口 Predicate。

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
  
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 1. Predicate test

Predicate 函数接口可以用于判断一个参数是否符合某个条件。

示例:判断某个字符串是否为空。

import java.util.function.Predicate;

public class Java8PredicateTest {
    public static void main(String[] args) {
        Predicate<String> isEmpty = String::isEmpty;
        System.out.println(isEmpty.test(""));
        System.out.println(isEmpty.test("www.wdbyte.com"));
    }
}
1
2
3
4
5
6
7
8
9

输出结果:

true
false
1
2

# 2. Predicate Stream filter

Stream 中的 filter() 方法是通过接收一个 Predicate 函数接口实现的。

示例:过滤出集合中,字符串长度为 4 的字符串。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Java8PredicateFilter {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("java", "node", "www.wdbyte.com");
        list = list.stream().filter(str -> str.length() == 4).collect(Collectors.toList());
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

输出结果:

[java, node]
1

# 3. Predicate and

使用 and() 方法,可以让前后两个 Predicate 判断条件一起生效。

示例 1:过滤数字集合中,数字大小在 5 至 9 之间的数字。

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Java8PredicateAnd {

    public static void main(String[] args) {
        List<Integer> numberList = Arrays.asList(3, 4, 5, 6, 7, 8, 9, 10);

        Predicate<Integer> greaterThan5 = number -> number > 5;
        Predicate<Integer> lessThan9 = number -> number < 9;
        Predicate<Integer> filter = greaterThan5.and(lessThan9);

        numberList = numberList.stream().filter(filter).collect(Collectors.toList());
        System.out.println(numberList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

结果输出:

[6, 7, 8]
1

示例 2:一个 Predicate 过滤数字集合中,数字大小在 5 至 9 之间的数字。

List<Integer> numberList = Arrays.asList(3, 4, 5, 6, 7, 8, 9, 10);
numberList = numberList.stream().filter(x -> x > 5 && x < 9).collect(Collectors.toList());
System.out.println(numberList);
1
2
3

输出结果;

[6, 7, 8]
1

# 4. Predicate negate

predicate.negate() 方法会返回一个与指定判断相反的 Predicate。

示例:过滤数字集合中,数字不大于 5 的数字。

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Java8PredicateNeagete {

    public static void main(String[] args) {
        List<Integer> numberList = Arrays.asList(3, 4, 5, 6, 7, 8, 9, 10);
        Predicate<Integer> greaterThan5 = number -> number > 5;

        numberList = numberList.stream().filter(greaterThan5.negate()).collect(Collectors.toList());
        System.out.println(numberList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出结果:

[3, 4, 5]
1

# 5. Predicate or

示例:过滤数字集合中,数字小于等于 5,或者大于等于 9 的数字。

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Java8PredicateOr {

    public static void main(String[] args) {
        List<Integer> numberList = Arrays.asList(3, 4, 5, 6, 7, 8, 9, 10);

        Predicate<Integer> lessThan5 = number -> number <= 5;
        Predicate<Integer> greaterThan8 = number -> number >= 9;

        numberList = numberList.stream().filter(lessThan5.or(greaterThan8)).collect(Collectors.toList());
        System.out.println(numberList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果:

[3, 4, 5, 9, 10]
1

# 6. Predicate 链式编程

Predicate 的 or() ,and(),negate() 方法可以随意组合 Predicate,组合后的判断逻辑是从左到右,从前到后,顺次判断。

如:(数字小于 5 ).and (数字大于 9 ).negate()。

解:(数字小于 5 )AND (数字大于 9 ) 对于任意数字都得 false,false.negate() 取相反 得 true。

所以,此判断逻辑对于任意数字都为 true。

示例:Predicate 的 or() ,and(),negate() 方法组合使用。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Java8PredicateChain {

    public static void main(String[] args) {
        List<Integer> numberList = Arrays.asList(3, 4, 5, 6, 7, 8, 9, 10);

        Predicate<Integer> lessThan5 = number -> number <= 5;
        Predicate<Integer> greaterThan9 = number -> number >= 9;

        // 小于等于 5
        System.out.println(filter(numberList, lessThan5));
        // 大于 5
        System.out.println(filter(numberList, lessThan5.negate()));
        // 小于等于 5 或者大于等于 9
        System.out.println(filter(numberList, lessThan5.or(greaterThan9)));
        // ! (小于等于 5 AND 大于等于 9)
        System.out.println(filter(numberList, lessThan5.and(greaterThan9).negate()));
    }

    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> resultList = new ArrayList<>();
        for (T t : list) {
            if (predicate.test(t)) {
                resultList.add(t);
            }
        }
        return resultList;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

输出结果:

[3, 4, 5]
[6, 7, 8, 9, 10]
[3, 4, 5, 9, 10]
[3, 4, 5, 6, 7, 8, 9, 10]
1
2
3
4

# 7. Predicate 与对象

示例:过滤符合某些特征的狗。

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class Java8PredicateObject {

    public static void main(String[] args) {
        List<Dog> dogList = new ArrayList<>();
        dogList.add(new Dog("哈士奇", 1));
        dogList.add(new Dog("牧羊犬", 2));
        dogList.add(new Dog("柯基", 3));
        dogList.add(new Dog("柴犬", 3));

        // 找到 3岁的狗
        System.out.println(filter(dogList, dog -> dog.getAge().equals(3)));
        // 找到哈士奇信息
        Predicate<Dog> predicate = dog -> ("哈士奇").equals(dog.getName());
        System.out.println(filter(dogList, predicate));
    }

    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> resultList = new ArrayList<>();
        for (T t : list) {
            if (predicate.test(t)) { resultList.add(t); }
        }
        return resultList;
    }
}

class Dog {
    private String name;
    private Integer age;

    public Dog(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

输出结果:

[Dog{name='柯基', age=3}, Dog{name='柴犬', age=3}]
[Dog{name='哈士奇', age=1}]
1
2

# 参考

  • Predicate (Java Platform SE 8 ) (opens new window)

扩展阅读:Java 8 Function 函数接口

订阅

文章持续更新,订阅可以关注「 程序猿阿朗 」公众号或者未读代码博客。

文章作者: 程序猿阿朗
文章链接:https://www.wdbyte.com/java8/java8-predicate/
版权声明:本网站当前文章采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 未读代码!
#Java8#Function Interface#Java8 predicate
上次更新: 2022/12/05, 08:18:32
Java 8 Consumer 函数接口
Java 8 forEach 遍历

← Java 8 Consumer 函数接口 Java 8 forEach 遍历→

最近更新
01
如何搭建一个自己的音乐服务器
12-04
02
JUnit 5 单元测试教程
11-17
03
使用 StringUtils.split 的坑
11-02
更多文章>

提示:评论前请刷新页面,否则评论的可能不是当前文章。

Theme by Vdoing | Copyright © 2018-2022 程序猿阿朗 | MIT License | 皖ICP备20000567号-1
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式