四大函数式接口和流式计算

四大函数式接口

java.util.function,Java内置核心四大函数式接口，可以使用lambda表达式

函数型接口，有一个输入，有一个输出

public static void main(String[] args) {
        //函数式接口，可以改为lambda表达式
        //Function<String, Integer> function = new Function<String, Integer>() {
        //    @Override
        //    public Integer apply(String s) {
        //        return 1024;
        //    }
        //};

        //简写
        Function<String,Integer> function = s->{return s.length();};
        System.out.println(function.apply("abc"));
    }

断定性接口，有一个输入参数，返回只有布尔值

public static void main(String[] args) {
        //Predicate<String> predicate = new Predicate<String>() {
        //    @Override
        //    public boolean test(String s) {
        //        return false;
        //    }
        //};

        //简写
        Predicate<String> predicate = s -> {return s.isEmpty();};
        System.out.println(predicate.test("abc"));
    }

消费型接口，有一个输入参数，没有返回值

public static void main(String[] args) {
        //Consumer<String> consumer = new Consumer<String>() {
        //    @Override
        //    public void accept(String s) {
        //
        //    }
        //};

        //简写
        Consumer<String> consumer = s -> { System.out.println(s); };
        consumer.accept("abc");
    }

供给型接口，没有输入参数，只有返回参数

public static void main(String[] args) {
        //Supplier<String> supplier = new Supplier<String>() {
        //    @Override
        //    public String get() {
        //        return null;
        //    }
        //};
        Supplier<String> supplier = ()->{return "abc";};
        System.out.println(supplier.get());
    }

Stream流式计算

链式编程、流式计算、lambda表达式，现在的Java程序员必会！

流（Stream）到底是什么呢？

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
"集合讲的是数据，流讲的是计算！"
特点：

• Stream自己不会存储元素。
• Stream不会改变数据源，相反，他们会返回一个特有结果的Stream。
• Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才会执行。

代码验证

User实体类

/**
 * 题目：请按照给出数据，找出同时满足一下条件的用户
 *      也即以下条件：
 *          1、全部满足偶数ID
 *          2、年龄大于24
 *          3、用户名转为大写
 *          4、用户名字母按倒序
 *          5、只输出一个用户名字 limit
 **/
public class StreamDemo {
    public static void main(String[] args) {

        User u1 = new User(11, "a", 23);
        User u2 = new User(12, "b", 24);
        User u3 = new User(13, "c", 22);
        User u4 = new User(14, "d", 28);
        User u5 = new User(15, "e", 26);

        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);

        /**
         * 1、首先我们需要先将list转换为stream流
         * 2、然后将用户过滤出来，这里用到一个函数式接口Predicate<? super T>,我们可以使用lambda简化
         * 3、这里面传递的参数，就是Stream流的泛型类型，也就是User,所以，这里可以直接返回用户id为偶数的用户信息
         * 4、通过foreach进行遍历，直接简化输出System.out::println,等价于System。out.println(u)
         * @return void
         **/

        //list.stream().filter(u->{return u.getId()%2==0;})
        //         .forEach(System.out::println);

        //list.stream().filter(u->{return u.getId()%2==0;})
        //        .filter(u->{return u.getAge()>24;})
        //        .forEach(System.out::println);

        //sorted()  自然排序，正排序D->E

        list.stream().filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>24;})
                .map(u->{return u.getUserName().toUpperCase();})
                //.sorted()//默认正排序，自己用compareTo比较
                .sorted((o1,o2)->{return o2.compareTo(o1);})
                .limit(1)
                .forEach(System.out::println);

       /*  
        map解释
        List<Integer> list2 = Arrays.asList(1, 2, 3);
        list2 = list2.stream().map(x -> {
            return x * 2;
        }).collect(Collectors.toList());
        for (Integer element : list2) {
            System.out.println(element);
        }*/
    }
}