实体类 接口_常用函数式接口的使用(Predicate)

常用函数式接口

Jdk8提供的函数式接口位置:package java.util.function;

Predicate

方法

• isEqual(Object targetRef) :比较两个对象是否相等,参数可以为Null
• and(Predicate other): 短路与操作,返回一个组成Predicate
• or(Predicate other) :短路或操作,返回一个组成Predicate
• test(T t) :传入一个Predicate参数,用来做判断
• negate() : 返回表示此Predicate逻辑否定的Predicate

Example

Test方法

/**
     * Predicate测试
     */
    @Test
    public void predicateTest() {
        // Creating predicate
        Predicate<Integer> LESSER_THAN = i -> (i < 18);

        // Calling Predicate method
        System.out.println(LESSER_THAN.test(10));
    }

And方法

/**
     * Predicate And方法测试
     */
    @Test
    public void predicateAndTest() {
        Predicate<Integer> greaterThanTen = (i) -> i > 10;

        // Creating predicate
        Predicate<Integer> lowerThanTwenty = (i) -> i < 20;
        boolean result = greaterThanTen.and(lowerThanTwenty).test(15);
        System.out.println(result);

        // Calling Predicate method
        boolean result2 = greaterThanTen.and(lowerThanTwenty).negate().test(15);
        System.out.println(result2);
    }

将Predicate封装成方法进行调用

/**
     * 匿名类:判断传入的字符串长度是否大于10
     */
    public static Predicate<String> hasLengthOf10 = new Predicate<String>() {
        @Override
        public boolean test(String t) {
            return t.length() > 10;
        }
    };

/**
     * Predicate 封装成方法进行调用
     */
    @Test
    public void predicateFunctionTest() {
        pred(10, (i) -> i > 7);
    }

OR方法

/**
     * OR
     */
    public static void predicate_or() {

        Predicate<String> containsLetterA = p -> p.contains("A");
        String containsA = "And";
        boolean outcome = hasLengthOf10.or(containsLetterA).test(containsA);
        System.out.println(outcome);
    }

@Test
    public void predicateOrTest() {
        predicate_or();
    }

And方法

/**
     * AND
     */
    public static void predicate_and() {
        Predicate<String> nonNullPredicate = Objects::nonNull;

        String nullString = null;

        boolean outcome = nonNullPredicate.and(hasLengthOf10).test(nullString);
        System.out.println(outcome);

        String lengthGTThan10 = "Welcome to the machine";
        boolean outcome2 = nonNullPredicate.and(hasLengthOf10).
                test(lengthGTThan10);
        System.out.println(outcome2);
    }

   /**
     * Predicate 封装成方法测试And
     */
    @Test
    public void predicateFunctionAndTest() {
        predicate_and();
    }

Negate方法

/**
     * negate
     */
    public static void predicate_negate() {

        String lengthGTThan10 = "Thunderstruck is a 2012 children's "
                + "film starring Kevin Durant";

        boolean outcome = hasLengthOf10.negate().test(lengthGTThan10);
        System.out.println(outcome);
    }

    /**
     * Predicate 封装成方法测试Negate
     */
    @Test
    public void predicateFunctionNegateTest() {
        predicate_negate();
    }

Predicate在集合中的使用

User实体类

package lambda.intertest;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;

@AllArgsConstructor
@ToString
@Getter
public class User {
    String name, role;
}

方法封装

public static List<User> process(List<User> users,
                                     Predicate<User> predicat) {
        List<User> result = new ArrayList<User>();
        for (User user : users)
            if (predicat.test(user))
                result.add(user);
        return result;
    }

测试

@Test
    public void predicateCollectionTest() {
        List<User> users = new ArrayList<User>();
        users.add(new User("John", "admin"));
        users.add(new User("Peter", "member"));
        List admins = process(users, (User u) -> u.getRole().equals("admin"));
        System.out.println(admins);
    }