Java SE基础之Lambda

Lambda表达式(函数式编程)

思想

面向对象的思想: 做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
函数式编程思想: 只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

lambda表达式简述

什么是lambda函数？lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数。

当需要启动一个线程去完成任务时，通常会通过 java.lang.Runnable 接口来定义任务内容，并使用 java.lang.Thread 类来启动该线程。代码如下
对于 Runnable 的匿名内部类用法，可以分析出几点内容：

• Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心； 为了指定 run的方法体，不得不需要 Runnable 接口的实现类；
• 为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
• 必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
• 而实际上，似乎只有方法体才是关键所在。

java 8 lambda表达式写法

Lambda省去面向对象的条条框框，格式由3个部分组成：
一些参数
一个箭头
一段代码
标准格式
（参数类型 参数名称）->{代码语句}
格式说明：

• 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
• -> 是新引入的语法格式，代表指向动作。
• 大括号内的语法与传统方法体要求基本一致。

Lambda省略格式

可推导即可省略

规则

1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号

无参无返回值

有参有返回值

有参无返回值

无参有返回值

Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需l’y要特别注意：

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。 无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一 时，才可以使用Lambda。
2. 使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
   备注：有且仅有一个抽象方法的接口，称为“函数式接口”

lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数。解释例子
通过传递不同的单个表达式，实现传递行为（加减乘除）的函数

    public class lambda {
	public static void main(String[] args) {
		invokeCalc(120,130,(int a,int b)->{
			return a+b;
		});
		invokeCalc(120,130,(int a,int b)->{
			return a-b;
		});
		invokeCalc(120,130,(int a,int b)->{
			return a*b;
		});
		invokeCalc(120,130,(int a,int b)->{
			return a/b;
		});
	}
	public static void invokeCalc(int a,int b,Calculator calculator) {
		Integer result = calculator.doSomething(a, b);
		System.out.println(result);
	}
	}

函数式编程在JDK中的使用（Consumer）

最近看迭代器（iterator）的具体实现,第一次看一下jdk中的细节，发现迭代器使用了一个叫consumer的类,搜索了一下发现是函数式编程的方式
首先看一下Consumer接口中的具体代码

@FunctionalInterface//函数式接口
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
    /**
     * Returns a composed {@code Consumer} that performs, in sequence, this
     * operation followed by the {@code after} operation. If performing either
     * operation throws an exception, it is relayed to the caller of the
     * composed operation.  If performing this operation throws an exception,
     * the {@code after} operation will not be performed.
     *
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

default关键字

default关键字使得可以在接口中直接写具体实现，在继承该接口的子类中可以直接调用

@FunctionalInterface注释

参考网友的@FunctionalInterface关键字的作用
​有且只有一个抽象方法
可以有多个静态方法
可以有多个default方法(默认方法)
可以有多个Object的public的抽象方法

void accept(T t)：方法：对给定的参数执行操作定义的表达式操作
default Consumer andThen(Consumer<? super T> after)
在after操作之后返回一个consumer 按顺序执行consumer

public class testComsumer {
    public static void main(String[] args) {
        Consumer<List<Integer>> consumer1= list -> {
            for (Integer i: list) {
                System.out.println("first consumer"+i);
            }
        };
        Consumer<List<Integer>> consumer2=list->{
            for (Integer i:list) {
                System.out.println("second consumer"+i);
            }
        };
        Consumer<List<Integer>> consumer3=list->{
            for (Integer i:list) {
                System.out.println("third consumer"+i);
            }
        };
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        consumer1.andThen(consumer2).andThen(consumer3).accept(list);//按顺序执行三个consumer
    }
}

看着看着原来增强for循环 for each其实底层只是使用了迭代器。和函数式编程好像没多大关系，虽然提供了函数式编程的方法

迭代器中使用到函数式编程的方法

public class demo1 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Iterator<Object> iterator = list.iterator();
        iterator.forEachRemaining(o->{
            System.out.println(o);
        });
    }
}

遍历list中的几种操作

public class demo1 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Iterator<Object> iterator = list.iterator();
        Iterator<Object> iterator1 = list.iterator();
        //list中foreach函数式函数
        list.forEach(o-> System.out.println(o+"foreach"));
        //增强for循环
        for (Object o:list) {
            System.out.println(o+"for(:)");
        }
        //普通的迭代器操作
        while(iterator.hasNext()){
            System.out.println(iterator.next()+"hasnext");
        }
        //使用函数式编程的iterator函数
        iterator1.forEachRemaining(o->{
            System.out.println(o+"foreachRemaining");
        });
    }
}

list.foreach源码

 @Override
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

注：在jdk1.8之后，新增了很多函数式编程的源码