Lambda表达式

目录

1.Lambda简介

2.一个简单理解

3.一些基础用法

方法归属者::方法名

构造方法的引用

函数式接口使用

4.集合操作

5.变量作用域问题

6.一个实际中的使用

参考文档

---

1.Lambda简介

        Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

        Lambda 表达式的语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

2.一个简单理解

        我们知道，对于一个Java变量，我们可以赋给其一个“值”。

        如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？比如，我想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量：

        在Java 8之前，这个是做不到的。但是Java 8问世之后，利用Lambda特性，就可以做到了。

        当然，这个并不是一个很简洁的写法。所以，为了使这个赋值操作更加elegant, 我们可以移除一些没用的声明。

        这样，我们就成功的非常优雅的把“一块代码”赋给了一个变量。而“这块代码”，或者说“这个被赋给一个变量的函数”，就是一个Lambda表达式。但是这里仍然有一个问题，就是变量aBlockOfCode的类型应该是什么？在Java 8里面，所有的Lambda的类型都是一个接口，而Lambda表达式本身，也就是”那段代码“，需要是这个接口的实现。这是我认为理解Lambda的一个关键所在，简而言之就是，Lambda表达式本身就是一个接口的实现。直接这样说可能还是有点让人困扰，我们继续看看例子。我们给上面的aBlockOfCode加上一个类型：

        这种只有一个接口函数需要被实现的接口类型，我们叫它”函数式接口“。为了避免后来的人在这个接口中增加接口函数导致其有多个接口函数需要被实现，变成"非函数接口”，我们可以在这个上面加上一个声明@FunctionalInterface, 这样别人就无法在里面添加新的接口函数了：

        这样，我们就得到了一个完整的Lambda表达式声明：

3.一些基础用法

方法归属者::方法名

           静态方法的归属者为类名，普通方法归属者为对象。示例：

public class Exe1 {
    public static void main(String[] args) {
        ReturnOneParam lambda1 = a -> doubleNum(a);
        System.out.println(lambda1.method(3));

        //lambda2 引用了已经实现的静态 doubleNum 方法
        ReturnOneParam lambda2 = Exe1::doubleNum;
        System.out.println(lambda2.method(3));

        Exe1 exe = new Exe1();

        //lambda4 引用了已经实现的 addTwo 方法
        ReturnOneParam lambda4 = exe::addTwo;
        System.out.println(lambda4.method(2));
    }

    /**
     * 要求
     * 1.参数数量和类型要与接口中定义的一致
     * 2.返回值类型要与接口中定义的一致
     */
    public static int doubleNum(int a) {
        return a * 2;
    }

    public int addTwo(int a) {
        return a + 2;
    }
}

构造方法的引用

        一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

interface ItemCreatorBlankConstruct {
    Item getItem();
}
interface ItemCreatorParamContruct {
    Item getItem(int id, String name, double price);
}

public class Exe2 {
    public static void main(String[] args) {
        ItemCreatorBlankConstruct creator = () -> new Item();
        Item item = creator.getItem();

        ItemCreatorBlankConstruct creator2 = Item::new;
        Item item2 = creator2.getItem();

        ItemCreatorParamContruct creator3 = Item::new;
        Item item3 = creator3.getItem(112, "鼠标", 135.99);
    }
}

函数式接口使用

        Java API中已经有了几个函数式接口，比如Comparator、Runnable，Callable等，Java 8在java.util.function包中引入了几个新的函数式接口，如Predicate、Consumer、Function。

        典型的使用方法如下：

Thread t = new Thread(() -> {
      for (int i = 0; i < 10; i++) {
        System.out.println(2 + ":" + i);
      }
    });
t.start();

4.集合操作

ArrayList<Integer> list = new ArrayList<>();

Collections.addAll(list, 1,2,3,4,5);

//lambda表达式 方法引用
list.forEach(System.out::println);

list.forEach(element -> {
        System.out.println(element);
});

        为什么能这样使用呢，可以看看源码

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

@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); };
    }
}

        Consumer< T>接口接受一个T类型参数，没有返回值。也即一切操作都可以由编写者自由定义。Predicate、Function同理。我们也可以使用如下方式来实现类似的功能

public static <T> void forEach(List<T> list, Consumer<T> c) {
        for(T i: list){
            c.accept(i);
        }
    }
 
forEach(Arrays.asList(1,2,3,4,5), (Integer i) -> System.out.println(i));

5.变量作用域问题

        Lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）。

        这个问题我们在匿名内部类中也会存在，如果我们把注释放开会报错，告诉我 num 值是 final 不能被改变。这里我们虽然没有标识 num 类型为 final，但是在编译期间虚拟机会帮我们加上 final 修饰关键字。

import java.util.function.Consumer;
public class Main {
    public static void main(String[] args) {

        int num = 10;

        Consumer<String> consumer = ele -> {
            System.out.println(num);
        };

        //num = num + 2;  会报错
        consumer.accept("hello");
    }
}

6.一个实际中的使用

        生产上使用controller接受消息是很常见的，如果我们在转为某个实体前，需要判断是否存在不存在则抛出异常，可以这么来设计。

Object o = request.getDtoOrElseThrow(Object.class,() -> new Exception("..."));

public <T,X extends Throwable> T getDtoOrElseThrow(Class<T> clazz, Supplier<? extends X> supplier) throws X{
    if(...){
        return ...;
    }else{
        throw supplier.get();
    }
}

参考文档

Lambda 表达式有何用处？如何使用？，Lambda 表达式有何用处？如何使用？ - 知乎

Lambda表达式详解，Lambda表达式详解 - 海向 - 博客园

java函数式编程之Consumer，java函数式编程之Consumer - lijingran - 博客园