四大函数式接口(重点)

lambda表达式，链式编程，函数型接口，Stream流式计算

1:函数时接口；

package com.baidu.function;

import java.util.function.Function;

/**
 * Function 是一个函数时接口，有一个输入参数，就有一个输出参数。
 * 只要是函数时接口，就可以用lambda 表达式；
 */
public class Demo01 {

    public static void main(String[] args) {
//        Function<String, String> function = new Function<String, String>() {
//
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };

        Function<String, String> function =(str)->{
            return str;
        };
        System.out.println(function.apply("abc"));


    }
}

2：断定型接口；

package com.baidu.function;

import java.util.function.Predicate;

/**
 * 断定型接口；有一个输入的参数，返回值只能是Boolean的值
 */
public class PredicateDemo {

    public static void main(String[] args) {
//        Predicate<String> predicate = new Predicate<String>() {
//
//            //判断字符串是否为空
//            @Override
//            public boolean test(String str) {
//
//                return str.isEmpty();
//            }
//        };

        Predicate<String> predicate =(str)->{
            return str.isEmpty();
        };
                System.out.println(predicate.test(""));

    }
}

3：消费型接口；

package com.baidu.function;

import java.util.function.Consumer;

/**
 * 只有输入，没有返回值；
 *
 */
public class ConsumerDemo {

    public static void main(String[] args) {
//        Consumer<String> consumer = new Consumer<String>() {
//            @Override
//            public void accept(String str) {
//                System.out.println(str);
//            }
//        };

        Consumer<String> consumer = (str)->{
            System.out.println(str);
        };

         consumer.accept("abc");


    }
}

4：供给型接口；

package com.baidu.function;

import java.util.function.Supplier;

/**
 * 没有参数，只有返回值
 */
public class SupplierDemo {
    public static void main(String[] args) {
//        Supplier supplier = new Supplier<Integer>() {
//
//            @Override
//            public Integer get() {
//                System.out.println("get");
//                return 1024;
//            }
//        };

        Supplier supplier = ()->{
            return 1024;
        };

        System.out.println(supplier.get());

    }
}

Stream流式计算

大数据:存储＋计算
集合、MySQL本质就是存储东西的;

计算都应该交给流来操作!

User类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private int id;
    private String name;
    private int age;
}

测试类：

package com.baidu.Stream;


import java.util.Arrays;
import java.util.List;

/**
 *  题目要求:一分钟内完成此题,只能用一行代码实现! 现在有5个用户! 筛选:
 * 1、ID必须是偶数  2、年龄必须大于23岁  3、用户名转为大写字母  4、用户名字母倒着排序  5、只输出一个用户!
 */
public class Test {
    public static void main(String[] args) {

        User u1 = new User(1,"a",21);
        User u2 = new User(2,"b",22);
        User u3 = new User(3,"c",23);
        User u4 = new User(4,"d",24);
        User u5 = new User(5,"e",25);
        User u6 = new User(6,"e",26);

        //集合就是存储数据的；
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5,u6);

        //计算交给Stream
        list.stream()
                .filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);


    }
}