Lambda表达式

Lambda表达式：可以理解就是一个接口的实现,将接口实现类的一段代码赋值给一个接口变量
函数式接口：一个interface里面只有1个接口

public interface Operator {
    int add(int i,int j);
}

上述定义了一个Operator接口 ，下方代码将实现类的代码赋值给了接口operator

Operator operator = (a,b) -> {return a + b;};

以上代码等价于：

 Operator operator2 = new Operator() {
       @Override
       public int add(int i, int j) {
           return i+j;
        }
 };

jdk中常用的函数式接口定义在java.util.function项下，如Predicate、Consumer、Function等，在集合List,Set,Map的流式编程的方法（如map、filter）等方法中，方法入参大量采用了Predicate、Consumer、Function表达式

完整实例如下：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {

    public static void main(String[] args) {
        //Lambda表达式可以理解就是一个接口的实现,将接口实现类的一段代码赋值给一个接口变量
        Operator operator = (a,b) -> {return a + b;};
        //上述代码等价于
        /*
        Operator operator2 = new Operator() {
            @Override
            public int add(int i, int j) {
                return i+j;
            }
        };
         */
        System.out.println(operator.add(10,20));
        //函数式接口：一个interface里面只有1个接口，java函数式接口定义在 java.util.function下
        //Predicate 断言函数式接口 boolean test(T t);
        Predicate<String> predicate = s -> s.contains("abc");
        System.out.println(predicate.test("abcdefg"));//true
        //Consumer 消费函数时接口 void accept(T t);
        Consumer<String> consumer = s -> {
            String newStr = s.toUpperCase();
            System.out.println(newStr);//ABCDEFG
        };
        consumer.accept("abcdefg");
        //Function 方法接口 R apply(T t);
        Function<String, Integer> function = (s) -> {
            return s.length();
        };
        System.out.println(function.apply("abcdefg"));//7

        //集合流编程
        List<String> list = new ArrayList<>();
        list.add("Lily");
        list.add("Andy");
        list.add("Jackson");
        list.add("Smith");
        Stream<String> stream = list.stream();
        //filter的参数是一个 Lambda表达式predicate
        List<String> filterList = stream.filter(s->s.contains("n")).collect(Collectors.toList());
        System.out.println(filterList);//[Andy, Jackson]
        //map的参数是 Lambda表达式Function
        stream = list.stream();
        List<String> mapList = stream.map(s -> {
            return s.substring(1);
        }).collect(Collectors.toList());
        System.out.println(mapList);//[ily, ndy, ackson, mith]
    }
}