java 1.8新特性（二）关于 function 接口的使用

需求1：从user集合中找出age=15的用户传统方法就不说了举例明一下 java1.8 使用Predicate接口解决该需求：

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

public static List<User> testPredicate(List<User> users, Predicate<User> predicate) {
        List<User> tempUsers = new ArrayList<>();
        for (User user : users) {
            boolean test = predicate.test(user);
            System.out.println(test);
            if (test) {
                tempUsers.add(user);
            }
        }
        return tempUsers;
    }

public static void main(String[] args) {
         List<User> testPredicate = Test.testPredicate(Test.users, (user) ->
         user.getAge() == 15);
}

Predicate接口中有一个test 接口方法，该方法可以传入T 对象并且返回一个boolean类型 Predicate.test(user) 表示只有满足传参进去的user 的age=15 才会返回true 则将该user 添加到tempUsers中

需求2：将所有的user对象的age都初始化为0 传统的可以循环每个user 将该user的age设置为0 java1.8 则可以使用 Consumer 接口实现：

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

public static List<User> testConsumer(List<User> users, Consumer<User> consumer) {
        List<User> tempUsers = new ArrayList<>();
        for (User user : users) {
            consumer.accept(user);
            tempUsers.add(user);
        }
        return tempUsers;
    }

public static void main(String[] args) {
        
        List<User> testConsumer = Test.testConsumer(Test.users, (user) -> user.setAge(100));
}

Consumer 有个accept的接口方法，无返回值，可以用作更改对象  consumer.accept(user) 都将执行 user.setAge(100)

3 需求3：返回一个user的姓名一般都是直接user.getName java1.8 则用function接口可以实现，相对这个需求来说不用funcation 更快,这里就只是为了使用而使用：

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

public static String testFunction(User users, Function<User, String> function) {
        return function.apply(users);
    }

    public static void main(String[] args) {
        User user = new User("funcation", 25);
        String testFunction = Test.testFunction(user, (u) -> {
            return u.getName();
        });
        System.out.println(testFunction);
}

Function<T, R> 该接口泛型 T 你需要修改 或者 操作的对象  R 是你返回的对象  接口方法

 R apply(T t); 传入参数T 对象  返回  R 对象 例子：传入的是user对象 返回的是String 对象

4.需求4：尴尬的需求，就是返回一个User对象 java1.8 Supplier

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

public static User testSuppler(Supplier<User> supplier) {

        return supplier.get();

    }

public static void main(String[] args) {
        User testSuppler = Test.testSuppler(() -> new User("Tom", 15));
        System.out.println(testSuppler);
}

Supplier<T> 返回一个泛型对象。有点类似工厂方法
5 上面就是 java1.8 常用的几个接口简单的举了几个例子，主要是要能举一反三学活了。比如泛型T 可以使基本类型对象类型

java 1.8新特性（二） 关于 function 接口的使用

java 1.8新特性（二）关于 function 接口的使用