java8 函数式编程、接口、lambda、stream

函数式编程

函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。
和命令式编程相比，函数式编程强调函数的计算比指令的执行重要。
和声明式编程相比，函数式编程里函数的计算可随时调用。

函数式编程与命令式编程不同

命令式编程的代码由一系列改变全局状态的语句构成；
函数式编程将计算过程抽象成表达式求值。表达式由纯数学函数构成，而这些数学函数是第一类对象且没有副作用。由于没有副作用，函数式编程可以更容易做到线程安全，因此特别适合于并发编程。
函数式编程是可以直接支持并行的模型。

    private static void programmatically() {
        //命令式编程     
        //关注计算机执行的步骤
        //一步一步告诉计算机怎么做
        List nums = new ArrayList(Arrays.asList(1,2,3,4,5,6,7,8,9,10));
        //第一步 创建一个存储结果的集合
        List results = new ArrayList();
        //第二步 遍历集合
        for (Integer num : nums) {
            //第三步 一个一个判断是否小于7，如果小于7就加入到结果集合中
            if(num < 7) {
                results.add(num);
            }
        }
        
        //声明书编程     
        //以数据结构的形式来表达程序执行的逻辑
        //只告诉计算机应该做什么，而不具体指定怎么做。
        //select num from nums where num < 7;
        
        
        //函数式编程  
        //和声明书编程 编程一样值关注做什么，而不去关心怎么做
        //函数式编程最重要的特点是“函数第一位”,即函数可以出现在任何地方,比如你可以把函数作为参数传递给另一个函数,还可以将函数作为返回值
        results = nums.stream().filter(num -> num < 7).collect(Collectors.toList());
        
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(Integer num) { 
                return num < 7;
            }
        };
        
        results = nums.stream().filter(predicate).collect(Collectors.toList());
        
        results.forEach(System.out::println);
    }

函数式接口

函数式接口只能有一个抽象方法，而不是只能有一个方法。
Java8新增了接口的默认方法，接口也可以包含若干个实例方法。在Java8中，使用default关键字，可以在接口内定义实例方法，这个方法并非抽象方法，而是拥有特定逻辑的具体实例方法。

java8内置的四大核心函数式接口

image.png

image.png

image.png

BiXX类型接口
BiConsumer、BiFunction、BiPrediate 是 Consumer、Function、Predicate 的扩展，可以传入多个参数。

XXYY类型接口
用 XX来表示 int、long、double、boolean，用 YY来表示 Consumer、Function、Predicate、Supplier 。JDK8就内置了此四种基本数据类型的消费，构建，操作，断言以及他们因此而产生的一系列其他接口 。

UnaryOperator与BinaryOperator
UnaryOperator：代表了一个作用于一个类型的操作，并且返回了同类型的结果
BinaryOperator：代表了一个作用于于两个同类型的操作，并且返回了同类型的结果
XXUnaryOperator：代表了一个作用于一个XX数据类型的操作，并且返回了同类型数据的结果
XXBinaryOperator：代表了一个作用于两个XX数据类型的操作，并且返回了同类型数据的结果
ToXXFunction与ToXXBiFunction类型接口
ToXXFunction：接受一个输入参数，返回一个XX类型结果
ToXXBiFunction：接受两个输入参数，返回一个XX类型结果

Consumer消费数据函数式接口

源码如下，有注解FunctionalInterface。提供了一个accept抽象方法（传入一个参数，无返回值），另有一个由default修饰的实列方法andThen,该方法可传入一个Consumer函数，并返回一个Consumer函数（先执行原函数的accept，再执行传入函数的accept）。

@FunctionalInterface
public interface Consumer {
    void accept(T t);
    default Consumer andThen(Consumer after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

演示

private static void consumerDetail() {
        Consumer c = new Consumer() {
            @Override
            public void accept(String t) {
                System.out.println(t);
            }
        };
        c.accept("samir");
    }

可以用lambda表达式优化（详细lambda语法在本文中会专门讲解）

private static void consumer() {
        /**
         * 输入： -> 前面部分 
         * 函数体 ： -> 后面部分
         */
        Consumer c = (x) -> {
            System.out.println(x);
        };
        //只有一个输入参数， 可以去掉（） , 当函数体中只有一个语句时，可以去掉{}进一步简化
        c = x -> System.out.println(x);
        //然而这还不是最简的，由于此处只是进行打印，调用了System.out中的println实列方法对输入参数直接进行打印，因此可以简化成以下写法
        c = System.out::println;
        
        c.accept("samir");
    }

输出

samir

注：default修饰的实列方法，是可以重写的。如下

private static void consumerDetail() {
        Consumer c = new Consumer() {
            @Override
            public void accept(String t) {
                System.out.println("C1-"+t);
            }

            @Override
            public Consumer andThen(Consumer after) {
                return (String t) -> {
                    accept(t);
                    System.out.println("todo");
                    after.accept(t);
                };
            }
        };
        
        Consumer