1 Lambda表达式

为什么使用Lambda表达式

lambda是一个匿名函数，我们可以把lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使java语言表达能力得到了提升。

基本案例

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

//等效于上面
Runnable runnable= () -> System.out.println("hello");

TreeSet<String> treeSet=new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(),o2.length());
            }
        });

TreeSet<String> treeSet=new TreeSet<>((o1, o2) -> Integer.compare(o1.length(),o2.length()));

TreeSet<String> treeSet=new TreeSet<>(Comparator.comparingInt(String::length));

final相关

public static void main(String[] args) {
        int num=0;
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println(num);      
            }
        };
    }

jdk1.7之前，匿名内部类使用外部变量则外部变量必须变为final，即不可变化。
在j.8之后，final可以省略，但是实际上final还是存在，在runnable内部num++还是报错

lambda表达式语法

lambda表达式在java语言内部引入了一个新的语法元素和操作符。这个操作符为"->"，该操作符被称为Lambda操作符或箭头操作符。它件Lambda表达式分为两个部分。

左侧：指定了Lambda表达式需要的所有参数
右侧：指定了Lambda体，即Lambda表达式要执行的功能

Lambda的内部实现

public static void main(String[] args) {
    //一个参数，小括号可省略
    Consumer<String> conn=x-> System.out.println(x);
    conn.accept("hello");
}

> Lambda表达式其实就是Consumer接口的accept函数的实现

2 函数式接口

只包含一个抽象方法的接口，称为函数式接口
可以通过Lambda表达式来创建该接口的对象
可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条生命，说明这个接口是函数式接口。
之所以Lambda必须和函数式接口配合是因为，接口如果多个函数，则Lambda表达式无法确定实现的是哪个

@FunctionalInterface
public interface MyNumber {
     double getValue();
}

@FunctionalInterface
public interface MyNumber<T> {
     T getValue(T t);
}

Lambda表达式作为参数

public static void main(String[] args) {
    System.out.println(toUpperString(str->str.toUpperCase(),"abc")); //ABC
}

public static String toUpperString(MyNumber<String> mn, String str) {
    return mn.getValue(str);
}

Java 内置四大核心函数式接口

函数式接口	参数类型	返回类型	用途
BiFunction<T,U,R>	T,U	R	对类型T,U参数应用操作，返回R类型的结果。包含方法为R apply(T t, U u)
UnaruOperator	T	T	对类型T的对象进行一元运算，并返回T类型的结果。包含的方法为 T apply(T t)
BinaryOperator	T,T	T	对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为T apply(T t1, T t2)
BiConsumer<T, U>	T,U	void	对类型为T, U 参数应用操作。包含方法为 void accept(T t, U u)
ToIntFunction ToLongFunction ToDoubleFunction	ToIntFunction ToLongFunction ToDoubleFunction	int long double	分别计算 int 、 long 、 double、值的函数
IntFunction LongFunction DoubleFunction	int long double	R	参数分别为int、long、double 类型的函数

使用场景

重要：之前MyNumber这种接口配合Lambda使用，可以发现必须先声明接口，很麻烦，而内置的几个接口就是解决这种问题的;<h5>而这些内置的接口也存在大量的内部实现，或者编程者自己定义的类，只要符合对应的参数类型和返回值类型的，都可以使用。例如：定义MyClass只要符合参数T返回R，则都可以使用Function<T, R> 函数型接口对应形式，包含下面的构造器引用，方法引用等等形式</h5>

//原始案例
public class java8 {
    public static void main(String[] args) {
        System.out.println(toUpperString(str->str.toUpperCase(),"abc"));
    }

    public static String toUpperString(MyNumber<String> mn, String str) {
        return mn.getValue(str);
    }
}

//使用Function<T, R> 函数型接口 
public class java8 {
    public static void main(String[] args) {
        System.out.println(toUpperString(str->str.toUpperCase(),"abc"));
    }

    public static String toUpperString(Function<String,String> mn, String str) {
        return mn.apply(str);
    }
}
//效果等效，而且省略了之前定义的MyNumber接口

方法引用与构造器引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。如下三种主要使用情况：

对象::实例方法
类::静态方法
类::实例方法

//例如：此时Consumer参数类型和返回值和println方法一致
//对象::实例方法名
PrintStream printStream=System.out;
Consumer<String> con= printStream::println;
con.accept("haha");


//类::静态方法名
Comparator<Integer> com=Integer::compare;
Comparator<Integer> com1=(x,y)->Integer.compare(x,y);

//类::实例方法
//注意：当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引
//用方法的第二个参数(或无参数)时：ClassName::methodName
BiPredicate<String,String> biPredicate=(x,y)->x.equals(y);
BiPredicate<String,String> biPredicate1= String::equals;
biPredicate.test("a","b");
biPredicate1.test("a","b");
//BiPredicate是Predicate 断言型接口的一个具体实现

构造器引用

格式： ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致

Function<Integer,Integer[]> fun=n->new MyClass();
Function<Integer,Integer[]> fun1=MyClass::new;
fun.apply(args...)

如果存在多个构造器，会自动匹配对应参数或者无参的构造器,取决于apply传递的参数。

数组引用

格式： type[]::new

Function<Integer,Integer[]> fun=n->new Integer[n];
Function<Integer,Integer[]> fun1=Integer[]::new;
fun.apply(10);

Java8 Lambda表达式和函数式接口

1 Lambda表达式

2 函数式接口