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

1. 需求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. 需求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  可以使基本类型 对象类型