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

        新时代的程序员：lambda表达式，函数式接口，链式编程，Stream流式计算

函数式接口

        函数式接口：只有一个方法的接口(简化编程模型，在新版本框架底层中大量应用！)

        只要是 函数型接口 就可以使用lambda表达式简化

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

四大函数式接口

• Consumer

• Supplier

• Function

• Predicate

Function 函数式接口

        函数型接口, 有一个输入参数, 有一个输出

import java.util.function.Function;

/*
    函数型接口, 有一个输入参数, 有一个输出
    只要是 函数型接口 就可以使用lambda表达式简化
 */

public class FunctionDemo {
    public static void main(String[] args) {
        //工具类:输出输入的值
//        Function function = new Function<String,String>() {
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };

        //用 lambad简化
        Function function = (str)->{return str;};

        System.out.println(function.apply("asd"));
    }
}

Predicate 断定型接口

        断定型接口:有一个输入参数,返回值只能是 布尔值

import java.util.function.Predicate;

/*
    断定型接口:有一个输入参数,返回值只能是 布尔值
 */
public class PredicateDemo {
    public static void main(String[] args) {
        //判断字符串是否为空
//        Predicate<String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String str) {
//                return str.isEmpty();
//            }
//        };


        //使用 lambda简化
        Predicate<String> predicate = (str)->{return str.isEmpty();};

        System.out.println(predicate.test(""));
    }
}

Consumer 消费型接口

        Consumer 消费型接口: 只有输入, 没有返回值

import java.util.function.Consumer;

/*
    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);
//            }
//        };


        //使用 lambda简化
        Consumer<String> consumer = (str)->{System.out.println(str);};
        consumer.accept("asd");

    }
}

Supplier 供给型接口

        Supplier 供给型接口 没有参数只有返回值

import java.util.function.Supplier;

/*
    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;
//            }
//        };


        //使用 lambda简化
        Supplier supplier = ()->{
            System.out.println("get()");
            return 1024;
        };

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

---

Stream流式计算与链式编程

  什么是Stream流式计算

        大数据：存储+计算

        集合、MySQL本质就是存储东西的

        计算都应该交给流来操作

例：

 * 题目要求：一分钟内完成此题，只能用一行代码实现
 * 现在有5个用户！筛选
 * 1.ID必须是偶数
 * 2.年龄必须大于23岁
 * 3.用户转为大写
 * 4.用户名字母倒着排序
 * 5.只输出一个用户

  实体类：

public class User {
    private int id;
    private String name;
    private int age;

    public User() {
    }

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

  实现类：

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


public class Test {
    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(5,"e",26);
        User user6 = new User(6,"f",26);
        User user7 = new User(8,"g",28);
        //集合就是储存
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5, user6,user7);

        //计算交给流
        //链式编程
        list.stream()
                .filter(user -> {return user.getId()%2==0;})
                .filter(user -> {return user.getAge()>23;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((u1,u2)->{return u2.compareTo(u1);})
                .limit(1)
                .forEach(System.out::println);

    }
}