先判断几个Lambda的是否有效：
1). () -> {}
2). () -> “red”
3). () -> {return “red”;}
4). (Integer i) -> return “me”+i;
5). (String s) -> {“red”;}

对于1无参数返回void。
对于2无参数返回String。
对于3无参数返回String。
对于4，由于return是控制流，需要加{}才能使Lambda生效。{return “me”+i;}
对于5，”red”是表达式，不是一个语句。要么去掉{}，要么改成{return “red”;}

函数式接口：只定义一个抽象方法的接口。
例如：

public interface Runnable{
    void run();
  }

Lambda只有在需要函数式接口的时候才可以传递Lambda。关于这一点，笔者也不是特别清楚，也不好写出来误导大家。
关于Lambda表达式，例如：

() - > void 表示参数列表为空。
(Apple ,Apple) -> int 表示接受两个Apple 作为参数返回int。
try catch简写：
private static String processFile() throws IOException {
    try(BufferedReader bufferedReader=new BufferedReader(new FileReader("/data.txt"))){
        return bufferedReader.readLine();
    }
}

这里扩展上面的try -catch简写的Lambda表达式。
先写接口：

public interface BufferReaderProcessor{
    String process(BufferedReader b) throws IOException;
}

private static void process(Runnable r) {
    r.run();
}

接口作为新的方法的参数并执行行为：

 private static String processFile(BufferReaderProcessor p) throws IOException {
    try(BufferedReader bufferedReader=new BufferedReader(new FileReader("F:/Java world/data.txt"))){
        return p.process(bufferedReader);//执行行为
    }
}

传递Lambda表达式。

//打印一次读取两行
    String readTwo=processFile((BufferedReader br) -> br.readLine() +br.readLine());
    System.out.println(readTwo);

函数式接口：

java8的函数式接口很多，比如Comparable，Runnable，Callable，以及
function包中引入的新的函数式接口，如Predcate，Consumer，Function，Suppleier等。

说一下常见错误：

Incompatible type specified for lambda expression's parameter i

见下面的demo：

public static<T> void forEach(List<T> list, Consumer<T> c){
        for (T t : list) {
            c.accept(t);
        }
    }
}

测试时：

forEach(Arrays.asList(1,2,3,4,5), (int i) -> System.out.println(i));

将int改成引用类型 Integer，编译通过。由于java类型分为原始类型和引用类型，而接口Consumer就不支持原始类型。并且源码里面也没有过多解释。注意就好。

局部变量易错情况：

int num=5;
    Runnable r1=() -> System.out.println("hello world!"+num);
    num=10;
    r1.run();

如果num被赋值第二次（num=10），编译器马上报错：

Local variable num defined in an enclosing scope must be final or effectively 

意思是nums是final的，是不可能再次赋值，num=10写上去就会报错。删掉就好。

新建一个对象，查看Apple类的构造方法：

public Apple(int weight, String color){
     this.weight = weight;
     this.color = color;
 }

用Lambda创建对象就显得麻烦一点：

BiFunction<Integer, String, Apple> c1=Apple::new;
   Apple c2=c1.apply(110,"red");
   
   //或者
   BiFunction<Integer, String, Apple> c3=(weight,color) -> new Apple(weight, color);
   Apple c4=c3.apply(150, "green");

比较Compare<T>的使用：
先实现接口：

class AppleSort implements Comparator<Apple>{

    @Override
    public int compare(Apple o1, Apple o2) {
        // TODO Auto-generated method stub
        return o1.getWeight().compareTo(o2.getWeight());
    }
    
}

初始化数据：

List<Apple> inventory=Arrays.asList(new Apple(10,"red"),
            new Apple(300,"green"),
            new Apple(200,"yellow"));

调用并比较：

inventory.sort(new AppleSort());
System.out.println(inventory);

增加逆序功能：

inventory.sort(new AppleSort().reversed());

增加如果重量一样，按照颜色排序：

inventory.sort(new AppleSort().reversed().thenComparing(Apple::getColor));

使用Comparator.comparing类：

inventory.sort(Comparator.comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor));

关于函数复合：注意andThen 和compose区别

Function<Integer, Integer> f=x -> x+1;
    Function<Integer, Integer> g=x -> x*2;
    Function<Integer, Integer> h=f.andThen(g);//相当于g(f(x))
    int result=h.apply(2);
    System.out.println(result);
    
    Function<Integer, Integer> f1=x -> x+1;
    Function<Integer, Integer> g1=x -> x*2;
    Function<Integer, Integer> h1=f.compose(g);//相当于f(g(x))
    int result2=h1.apply(2);

积分：
简书的markdown居然写不出积分。算了不写了。直接从坐标轴x上计算，点（3,0），（20,0），与y=x+10构成的图形面积。

    public static double integrate(DoubleFunction<Double> f, double a, double b) {
    return (f.apply(a)+f.apply(b))*(b-a)/2.0;
}

调用：

double m=integrate((double x) -> x+10,3,20);
System.out.println(m);

好了,今天就到这里了。下次学流了。