Java函数式接口及Stream流

学习内容：

1、Function

//函数式接口：就是只定义一个抽象方法的接口
public class FunctionTest {
    public static void main(String[] args) {
        // 匿名内部类，函数有一个输入值和一个输出值，输入输出值的类型由我们进行指定
        Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s;
            }
        };

        // 改写成为lambda表达式
        Function<String, String> function1 = (s) -> {return s;};

        System.out.println("function.apply() = " + function.apply("hdsjhj"));
        System.out.println("function1.apply() = " + function1.apply("lambda表达式"));
    }
}

2、Predicate

 * @author lms
 * @date 2021-09-05 - 16:10
 * Predicate:断定型接口，有一个输入参数，返回值只能是布尔值
 */
public class PredictTest {
    public static void main(String[] args) {
        // 匿名内部类：断定型，用于判断的函数，有输出和输出
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String str) {
                return str.isEmpty();
            }
        };

        // lambda表达式
        Predicate<String> predicate1 = (str) -> {return str.isEmpty();};

        System.out.println("predicate.test() = " + predicate.test("hello"));
        System.out.println("predicate1.test() = " + predicate1.test("hdjh"));

    }
}

3、Consumer

/**
 * @author lms
 * @date 2021-09-05 - 16:20
 * 消费型接口：只有输入，没有返回值
 */
public class ConsumerTest {
    public static void main(String[] args) {
        // 消费者型接口,只有参数的输入，没有返回值
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println("str = " + str);
            }
        };
        // lambda表达式
        Consumer<String> consumer1 = (str) -> {System.out.println("str = " + str);};

        consumer.accept("hello");
        consumer1.accept("world!");
    }
}

4、Supplier

/**
 * @author lms
 * @date 2021-09-05 - 16:23
 * Supplier:供给型接口，只有输出，没有输入
 */
public class SupplierTest {
    public static void main(String[] args) {
        // 供给型接口:没有输入，有输出，输出的类型由我们进行指定
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "hello";
            }
        };

        // lambda表达式
        Supplier<String> supplier1 = () -> {return "world";};

        String s = supplier.get();
        String s1 = supplier1.get();
        System.out.println("s = " + s);
        System.out.println("s1 = " + s1);
    }
}

5、Stream

/**
 * @author lms
 * @date 2021-09-05 - 16:44
 * 链式计算
 * 题目要求： 一分钟内完成此题，只能使用一行代码实现
 * 现在有5个用户！筛选：
 *  1. ID必须是偶数
 *  2. 年龄必须大于23岁
 *  3，用户名转为大写字母
 *  4，用户名字母倒着排序
 *  5.只输出一个用户信息
 */
public class StreamTest {
    public static void main(String[] args) {
        User user1 = new User(1, "a", 21);
        User user2 = new User(2, "b", 22);
        User user3 = new User(3, "c", 23);
        User user4 = new User(4, "d", 24);
        User user5 = new User(6, "e", 25);

        // 先将用户转为list集合，然后在使用stream进行处理
        List<User> users = Arrays.asList(user1, user2, user3, user4, user5);

        // 链式计算
        users.stream()
                .filter((user) -> {return user.getId() % 2 == 0;})
                // 形参是Predicate型，一个输入一个输出(true/false),因此返回值是一个一个id为偶数的user对象
                .filter((user -> {return user.getAge() > 23;}))
                // 返回值是id > 23 的user
                .map(user -> {return user.getName().toUpperCase();})
                // 形参Function,有输入和输出(两者类型相同)
                // 返回值是user.getName()，即用户名，并且转为大写,默认顺序是 D E
                .sorted((o1,o2) -> {return o2.compareTo(o1);})
                // 形参Comparator，可以重写比较函数, 然后排序后得到的结果是 E D
                .limit(1)  // 取出第一个
                .forEach(System.out::println);
                // 形参Consumer有输入值，没有返回值，只有输出值，
                // 将得到的结果 E 进行输出
    }
}

---