JDK1.8的函数式编程入门

函数式编程优点

1.大数据下处理集合效率高(并行流，不用自己写多线程处理)

2.代码简洁，可读性好(后面章节实战会体现)

3.不学看不懂公司的代码

https://www.bilibili.com/video/BV1Gh41187uR?p=39&vd_source=b2e596b686781ec41de76995b33cfe21 

Lambda表达式

Lambda是函数式编程的基石，可以对某些匿名内部类的写法进行简化。

不关注是什么对象，只关注对什么数据操作。

基本格式：

(参数列表)——>{代码}

举例：

创建线程并启动使用匿名内部类和Lambda方式如下：

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("hello");
    }
});

new Thread(()->{
    System.out.println("hello");
});

由此可见：匿名内部类 需要关注接口名和方法名

lambda表达式只关注方法参数和方法体(具体操作)。

练习：

定义一个方法，接收一个接口

public static void printNum(IntPredicate intPredicate){
    int[] arr={1,2,3,4,5,6,7};
    for (int i : arr) {
        if (intPredicate.test(i)){
            System.out.println(i);
        }
    }
}

使用匿名内部类和Lambda分别调用此方法。

printNum(new IntPredicate() {
    @Override
    public boolean test(int value) {
        return value%2==0;
    }
});

printNum((int value)->{
    return value%2==0;
});

Lambda表达式省略规则：

1.参数类型可以省略。

2.方法体只有一句话时大括号return和唯一一句代码的分号可以省略。

3.方法只有一个参数时，小括号可以省略。

上面的例子可以写成如下：

printNum(value-> value%2==0);

Stream流

有了Lambda表达式的基础，可以接下来了解Stream流了（函数式编程最重要的一部分）

Stream流可以更方便的对集合 数组进行操作

1.如下是最简单的一个Stream操作集合：有常用的三个操作 分别是创建流 中间操作 终结操作

        list.stream()//创建流
                .distinct()// 中间操作
                .filter(emp -> emp.getAge()>=18)// 中间操作
                .forEach(emp -> System.out.println(emp.getAge()));//终结操作

如果不写终结操作，前面的中间操作是不会被调用的

有很多个终结操作和中间操作，大家慢慢查去吧 这里只简单介绍一下。

2.在介绍一个终结操作collect：把当前流转换成一个集合。

如下：转成Map

        list.stream()
                .distinct()
                .filter(emp -> emp.getAge()>=18)
                .collect(Collectors.toMap(emp -> emp.getAge(),emp -> emp));

常见的函数式接口

介绍一下JDK给我们提供的常用函数式接口。

1.Function计算转换接口

根据抽象方法的参数列表和返回值类型我们知道，我们可以在方法中对传入的参数计算或转换，把结果返回。

@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);

定义一个接口 接收Function函数

    static Double change(int base, Function<Integer,Double> function){
        Double res = function.apply(base);
        return res;
    }

调用带有Function参数的函数

Double res = change(1000, (Integer integer) -> {
　　　　　　　// 这里是业务逻辑
            return integer * 1.2;
});

现在也可以看到在调用change函数的时候，我们只关心参数和方法实现.

2.Supplier生产型接口

根据抽象方法的参数列表和返回值类型我们知道，我们可以在方法中创建对象，把创建好的对象返回。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

定义一个接口 接收supplier参数：如果emp的年龄大于传入的age就设置为成年。

   static void testSupplier(int age, Supplier<Emp> supplier){
        Emp emp =supplier.get();
        if (supplier.get().getAge()>age){
            emp.setAdultFlag(true);
        }
        emp.setAdultFlag(false);
    }

调用该接口

        testSupplier(18,()->{
　　　　　　//do some thing
           return new Emp(19);
        });