一回顾与说明

????通过之前发布的”Java8Lamda和Stream原理引入“一文章中你已经了解了为什么会有Lamda表达式的由来，Lamda表达式的基本语法等；Lamda表达式简而言之：Lamda表达式本质上就是匿名类，我们称Lamda表达式就是函数式接口的实现；

二Lamda表达式的结构与函数式接口的关系

1准备工作

例子还是之前文章关于车的例子

判断型函数式接口：

/**
 * @Author lsc
 * @Description <p> </p>
 * @Date 2019/9/27 14:05
 * @Version 1.0
 */
@FunctionalInterface
public interface CarPredicate  {

    boolean test(Car car);
}

车实体类:

/**
 * @Author lsc
 * @Description <p> </p>
 * @Date 2019/9/27 11:09
 * @Version 1.0
 */
@Data
@AllArgsConstructor
public class Car {

    // 车牌号
    private String code;
    // 颜色
    private String color;
    // 生产商
    private String factory;
    // 价格
    private double price;
}

初始化实例函数：

    public List<Car> InitCar(){
        ArrayList<Car> carList = new ArrayList<>();
        Car car1 = new Car("100", "black", "中国", 20);
        Car car2 = new Car("101", "gray", "中国", 30);
        Car car3 = new Car("102", "yello", "中国", 50);
        Car car4 = new Car("103", "silvery", "英国", 20);
        Car car5 = new Car("104", "red", "英国", 30);
        carList.add(car1);
        carList.add(car2);
        carList.add(car3);
        carList.add(car4);
        carList.add(car5);
        return carList;
    }

根据条件获得车函数：

    public List<Car> getCarByPredicate(List<Car> carList, CarPredicate carPredicate){
        ArrayList<Car> resultList = new ArrayList<>();
        for (Car car : carList){
            if (carPredicate.test(car)){
                resultList.add(car);
            }
        }
        return resultList;
    }

2 Lamda 的结构

我们之前用Lamda是这样调用：

    @Test
    public void getCarByPredicatByLamda(){
        // 初始化车信息
        List<Car> cars = carFunFactory.InitCar();
        // 获取颜色为红色的车
        List<Car> carByPrice1 = carFunFactory.getCarByPredicate(cars,car -> car.getPrice()>30);
        // [Car(code=102, color=yello, factory=中国, price=50.0)]
        System.out.println(carByPrice1);
    }

图解Lamda 结构

3 Lamda与函数式接口的关系与类型推断

再次强调：Lamda表达式是对函数式接口的实现

类型?推断：

类型推断void：?

    // void 兼容 Lamda一句表达式的函数签名
    @Test
    public void runnableTest(){
        Runnable runnable = () -> System.out.println("欢迎关注youku1327");
        runnable.run();
    }

图解void类型推断?：

没有类型推断：

三内置函数式接口

1 Predicate<T>

java.util.function.Predicate;函数签名：boolean test(T t);
我们可以实现的Lamda函数签名：T -> boolen;

示例：

    @Test
    public void predicateTest(){
        Predicate predicate = s -> s.equals("youku1327");
        boolean youku1327 = predicate.test("youku1327");
        System.out.println(youku1327);//true
    }

2 Consumer<T>

java.util.function.Consumer;函数签名： void accept(T t);
我们可接受的Lamda函数签名：T -> void;

    @Test
    public void consumerTest(){
        Consumer consumer = s -> System.out.println(s);
        consumer.accept("youku1327");//youku1327
    }

3Function<T, R>

java.util.function.Function;函数签名?：R apply(T t);
我们可接受的Lamda函数签名：T -> R;?

    @Test
    public void functionTest(){
        ArrayList<Object> list = new ArrayList<>();
        Function function = s -> list.add(s);
        function.apply("youku1327");
        System.out.println(list);//[youku1327]
    }

4 Supplier<T>

java.util.function.Supplier;函数签名: T get();
我们可以接受的Lamda函数签名: void -> T

    @Test
    public void supplierTest(){
        ArrayList<Object> list = new ArrayList<>();
        Supplier supplier = () ->  "youku1327";
        System.out.println(supplier.get());//youku1327
    }

四 致谢

感谢观看Lamda与函数式接口的入门原理篇，有梦想的程序员，学技术不仅学使用方法，还要学原理，你将技术当工具，技术何尝不是把你当工具，想要系统学习快关注我的公众号吧；

原文地址：https://www.cnblogs.com/zszxz/p/12066855.html