必知必会之Lambda表达式

时间  2020-02-20
标签 必会 lambda 表达式 繁體版
原文   原文链接

Java是一门强大的面向对象的语言，除了8种基本的数据类型，其余一切皆为对象。所以，在Java中定义函数或方法都离不开对象，也就意味着很难直接将方法或函数像参数同样传递，而Java8中的Lambda表达式解决了这个问题。java

1、为何须要Lambda？

简单的来讲，引入Lambda就是为了简化代码，容许把函数做为一个方法的参数传递进方法中。git

1.1 真的简化了？

示例：若是想把某个接口的实现类做为参数传递给一个方法会怎么作？github

  • Java8之前
public static void general() {
    // 用匿名内部类的方式来建立线程
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("公众号：风尘博客！");
        }
    }).run();
}
  • Lambda 写法
public static void lambda() {
    // 使用Lambda来建立线程
    new Thread(() -> System.out.println("公众号：风尘博客！")).run();
}

1.2 Lambda表达式是什么？

Java中，将方法做为参数进行传递的方式被称为Lambda表达式。编程

1.3 Lambda 表达式语法结构

Lambda实际上是一个箭头函数，也可称为匿名函数:->数组

箭头操做符将Lambda表达式分红了两部分：app

  1. 左侧：Lambda表达式的参数列表(接口中抽象方法的参数列表)
  2. 右侧：Lambda表达式中所需执行的功能(Lambda体，对抽象方法的实现)

1.4 语法格式

  • 无参，无返回值，Lambda 体只需一条语句。
public static void noParam() {
    Runnable r1 = () -> System.out.println("noParam Test!");
    r1.run();
}
  • Lambda 须要一个参数，参数的小括号能够省略。
public static void oneParam() {
    // Consumer<String> con = (s) -> System.out.println(s);
    // 参数的小括号能够省略。
    Consumer<String> con = s -> System.out.println(s);
    con.accept("oneParam Test!");
}
  • Lambda 须要多个参数，而且有返回值。
public static void params() {
    Comparator<Integer> com = (x, y) -> {
        System.out.println("函数式接口");
        // 比较x/y的大小
        return Integer.compare(x, y);
    };
    System.out.println(com.compare(1, 2));
}
  • 当 Lambda 体只有一条语句时，return 与大括号能够省略。
public static void one() {
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    System.out.println(com.compare(1, 2));
}

上面几条示例好像有一个共性：参数列表的数据类型都没写，这是为何呢？dom

1.5 类型推断

Lambda 表达式中的参数类型都是由编译器推断得出的。ide

public static void typeInference() {
    //Integer 类型能够省略
    Comparator<Integer> com = (Integer x,Integer y) -> {
        System.out.println("函数式接口");
        return Integer.compare(x, y);
    };
    // 类型推断
    BinaryOperator<Long> addImplicit = (x, y) -> x + y;
}

Lambda 表达式中无需指定类型，程序依然可 以编译，这是由于 javac根据程序的上下文，在后台 推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。函数式编程

1.6 小节

Lambda表达式使得Java拥有了函数式编程的能力，但在Java中Lambda表达式是对象，它必须依附于一类特别的对象类型——函数式接口(functional interface)。函数

2、函数式接口

函数接口是只有一个抽象方法的接口，用做 Lambda 表达式的类型。使用@FunctionalInterface注解修饰的类，编译器会检测该类是否只有一个抽象方法或接口，不然，会报错。能够有多个默认方法，静态方法。

JDK8在 java.util.function 中定义了几个标准的函数式接口，供咱们使用。

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

函数式接口 参数类型 返回类型 用途
Consumer<T> T void 对类型为T的对象应用操做，包含方法：void accept(T t)
Supplier<T> 无 T 返回类型为T的对象，包 含方法：T get();
Function<T,R> T R 对类型为T的对象应用操做，并返回结果。结果是R类型的对象。包含方法：R apply(T t);
Predicate<T> T boolean 肯定类型为T的对象是否知足某约束，并返回 boolean 值。包含方法 boolean test(T t);
  • 消费型接口

void accept(T t);

consumerDemo(3, s -> System.out.println(s * 3));

public static void consumerDemo(Integer value, Consumer<Integer> consumer) {
    consumer.accept(value);
}
  • 供给型接口

T get();

// 生成10个之内的随机书
List<Integer> numList = supplierDemo(10, () -> (int)(100 * Math.random()));
System.out.println(numList);

public static List<Integer> supplierDemo(int num, Supplier<Integer> supplier) {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < num; i++) {
        Integer n = supplier.get();
        list.add(n);
    }
    return list;
}
  • 函数型接口

R apply(T t);

// 处理字符串
String str1 = functionDemo("Hello!风尘博客", s -> s.substring(6));
System.out.println(str1);
String str2 = functionDemo("vanDusty", s -> s.toUpperCase());
System.out.println(str2);

public static String functionDemo(String str, Function<String, String> function) {
    return function.apply(str);
}
  • 断言型接口

boolean test(T t);

// 将知足条件的字符串放入集合
List<String> list = Arrays.asList("hello", "van", "function", "predicate");
List<String> newList = predicateDemo(list, s -> s.length() > 5);
System.out.println(newList);

public static List<String> predicateDemo(List<String> list, Predicate<String> predicate) {
    List<String> newList = new ArrayList<>();
    for (String s : list) {
        if (predicate.test(s)) {
            newList.add(s);
        }
    }
    return newList;
}

2.2 自定义函数式接口

咱们能够在任意函数式接口上使用 @FunctionalInterface 注解， 这样作能够检查它是不是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

// 字符串转大写
String newStr = selfFunctionalInterface((str) -> str.toUpperCase(), "abc");
System.out.println(newStr);

public static String selfFunctionalInterface(SelfFunctionalInterface<String> selfFunctionalInterface, String str) {
    return selfFunctionalInterface.getValue(str);
}

3、方法引用和构造器引用

3.1 方法引用

方法引用是指经过方法的名字来指向一个方法。

3.1.1 方法引用使用的前提条件是什么呢？

  1. 方法引用所引用的方法的参数列表必需要和函数式接口中抽象方法的参数列表相同（彻底一致）；
  2. 方法引用所引用的方法的的返回值必需要和函数式接口中抽象方法的返回值相同（彻底一致）。

3.1.2 方法引用三种格式

  • 实例对象名::实例方法名
private static void instanceMethod() {
    UserDomain user = new UserDomain(1L, "Van");

    Supplier<String> sup = () -> user.getUserName();
    System.out.println(sup.get());

    // 等同于
    Supplier<String> supplier = user::getUserName;
    System.out.println(supplier.get());
}
  • 类名::静态方法名
private static void staticMethod() {
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    System.out.println(com.compare(3,9));

    // 等同于
    Comparator<Integer> com2 = Integer::compare;
    System.out.println(com2.compare(3,9));
}
  • 类名::实例方法名
private static void instanceMethodObject() {
    UserDomain user = new UserDomain(1L, "Van");
    
    Function<UserDomain, String> fun = (e) -> e.getUserName();
    System.out.println(fun.apply(user));

    // 等同于
    Function<UserDomain, String> fun2 = UserDomain::getUserName;
    System.out.println(fun2.apply(user));
}

3.2 构造器引用

  1. 前提：构造器参数列表要与接口中抽象方法的参数列表一致！
  2. 语法格式：类名 :: new
  • 构造器引用
private static void object() {
    // UserDomain 中必须有一个 UserDomain(String userName) 的构造器,下同
    Function<String,UserDomain> fun = (n) -> new UserDomain(n);
    fun.apply("Van");

    System.out.println("===等价于===");
    Function<String,UserDomain> function = UserDomain::new;
    function.apply("Van");

    // 带两个参数的构造器引用就要用BiFunction，多个参数的话，还能够自定义一个这样的函数式接口
    BiConsumer<Long, String> biConsumer = UserDomain :: new;
    biConsumer.accept(1L,"Van");
}
  • 数组引用
private static void array() {
    //传统Lambda实现
    Function<Integer,int[]> function = (i) -> new int[i];
    int[] apply = function.apply(10);
    System.out.println(apply.length);

    //数组类型引用实现
    function = int[] ::new;
    apply = function.apply(100);
    System.out.println(apply.length);
}

4、 总结

Github 示例代码

Lambda表达式是Java对于函数式编程的温和转变，面向对象编程和函数式编程不是互相对立的，结合使用可以更加有效地帮助咱们管理程序的复杂性。

技术交流

  1. 风尘博客
  2. 风尘博客-掘金
  3. 风尘博客-博客园
  4. Github
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程