Dating Java8系列之Lambda表达式和函数式接口(下)

简介: Dating Java8系列之Lambda表达式和函数式接口(下)



使用函数式接口

  • 函数式接口定义且只定义了一个抽象方法。
  • 函数式接口很有用, 因为抽象方法的签名可以描述Lambda表达式的签名。
  • 为了应用不同的Lambda表达式,你需要一套能够描述常见函数描述符的函数式接口。
  • Java 8的库设计师帮我们在java.util.function包中引入了几个新的函数式接口。

常用的函数式接口

一元函数

  • Function(一般函数)
  • Consumer(消费者)
  • Predicate(谓词函数)
  • Supplier(供应者)

二元函数

  • BiFunction(一般函数)
  • BiConsumer(消费者)
  • BiPredicate(谓词函数)
public class FunctionLearn {
    /**     * Function     */    public static void learnFunction() {        Function<String, String> functionStr = (String s) -> s + "。";        System.out.println(functionStr.apply("Hello World"));
        Function<Integer, Integer> function1 = (Integer a) -> a + 2;        Integer x = function1.apply(5);        System.out.println(x);        Function<Integer, Integer> function2 = (Integer a) -> a * 2;
        // 组合两个Function函数,a * 2 compose a+2 = (a+2) * 2        Function<Integer, Integer> function3 = function2.compose(function1);        System.out.println("Function3 : " + function3.apply(20));
        // 先后顺序拼接两个Function a *2 andThen a+2 = (a*2) + 2        Function<Integer, Integer> function4 = function2.andThen(function1);        System.out.println("Function4 : " + function4.apply(15));
        // 输入啥返回啥        Function.identity();    }
    /**     * Consumer     */    public static void learnConsumer() {        Consumer<Integer> consumer1 = (Integer a) -> System.out.println("Consumer 1 : " + a);        // 吃掉外部传进来的T,在方法内部消化掉,什么也不返回        consumer1.accept(100);        Consumer<Integer> consumer2 = (Integer a) -> System.out.println("Consumer 2 : " + a + "Done");        Consumer<Integer> consumer3 = consumer1.andThen(consumer2);        consumer3.accept(10);        consumer1.andThen(consumer2).accept(10);    }
    /**     * Supplier     */    public static void learnSupplier() {        // 无中生有,凭空生成一个东西出来        Supplier<Integer> supplier = () -> 10;        Integer a = supplier.get();        System.out.println(a);    }
    /**     * Predicate     */    public static void learnPredicate() {        Predicate<Integer> predicate1 = (Integer a) -> a > 10;        System.out.println(predicate1.test(20));
        Predicate<Integer> predicate2 = (Integer a) -> a < 20;        // and 与操作        Predicate<Integer> predicate3 = predicate1.and(predicate2);        System.out.println(predicate3.test(9));
        Predicate<Integer> predicate4 = (Integer a) -> a > 8;        // or 或操作        System.out.println(predicate1.or(predicate4).test(7));
        // ! 取反操作        System.out.println(predicate4.negate().test(7));    }
    /**     * BiFunction     */    public static void learnBiFunction() {        BiFunction<Integer, Integer, Integer> biFunction1 = (Integer a, Integer b) -> a + b;        System.out.println(biFunction1.apply(10, 15));        Function<Integer, Integer> biFunction2 = (Integer a) -> a * 2;        System.out.println(biFunction1.andThen(biFunction2).apply(10, 15));    }
    /**     * BiConsumer     */    public static void learnBiConsumer() {        BiConsumer<Integer, Integer> biConsumer1 = (Integer a, Integer b) -> System.out.println(a + b);        biConsumer1.accept(1, 2);        BiConsumer<Integer, Integer> biConsumer2 = (Integer a, Integer b) -> System.out.println(a * b);        biConsumer1.andThen(biConsumer2).accept(1, 2);    }
    /**     * BiPredicate     */    public static void learnBiPredicate() {        BiPredicate<Integer, Integer> biPredicate1 = (Integer a, Integer b) -> a > 10 && b < 15;        System.out.println(biPredicate1.test(11, 14));        BiPredicate<Integer, Integer> biPredicate2 = (Integer a, Integer b) -> a > 13;
        System.out.println(biPredicate1.and(biPredicate2).test(11, 14));        System.out.println(biPredicate1.or(biPredicate2).test(11, 14));        System.out.println(biPredicate2.negate().test(11, 14));    }
    public static void main(String[] args) {
        learnFunction();        learnConsumer();        learnSupplier();        learnPredicate();        learnBiFunction();        learnBiConsumer();        learnBiPredicate();    }}

方法引用

简介

方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法。

当你需要使用方法引用时,目标引用放在分隔符::前,方法的名称放在后面。

例如, Phone::getPrice就是引用了Phone类中定义的方法getPrice。请记住,不需要括号,因为你没有实际调用这个方法。方法引用就是Lambda表达式(Phone a) -> a.getPrice()的快捷写法。

构建方法引用

方法引用主要有三类。

  1. 指向静态方法的方法引用(例如Integer的parseInt方法,写作Integer::parseInt)。
  2. 指向任意类型实例方法的方法引用(例如String的length方法,写作 String::length)。
  3. 指向现有对象的实例方法的方法引用(假设你有一个局部变量mobileCategory用于存放Category类型的对象,它支持实例方法getValue,那么你就可以写mobileCategory::getValue)。

释义

第二种和第三种方法引用可能乍看起来有点儿晕。

类似于String::length的第二种方法引用的思想就是你在引用一个对象的方法,而这个对象本身是Lambda的一个参数。例如,Lambda表达式(String s) -> s.toUppeCase()可以写作String::toUpperCase。

但第三种方法引用指的是,你在Lambda中调用一个已经存在的外部对象中的方法。例如,Lambda表达式()->mobileCategory.getValue()可以写作mobileCategory::getValue。

public class MethodReference {
    public static void main(String[] args) {        Function<String, Integer> function = (String s) -> Integer.parseInt(s);        Integer a = function.apply("15");        System.out.println(a);
        // 指向静态方法的方法引用(例如Integer的parseInt方法,写作Integer::parseInt)。        Function<String, Integer> function1 = Integer::parseInt;        System.out.println(function1.apply("20"));
        // 指向任意类型实例方法的方法引用        Function<String, Integer> function2 = (String s) -> s.length();        System.out.println(function2.apply("abc"));        Function<String, Integer> function3 = String::length;        System.out.println(function3.apply("abcd"));
        // 指向现有对象的实例方法的方法引用        // 调用外部的对象        PhonePredicate phonePredicate = (Phone phone) -> true;        Function<Phone, Boolean> function4 = (Phone phone) -> phonePredicate.test(phone);        System.out.println(function4.apply(new Phone()));        Function<Phone, Boolean> function5 = phonePredicate::test;        System.out.println(function5.apply(new Phone()));
        Supplier<Phone> supplier = Phone::new;        Function<Integer,Phone> function6 = Phone::new;    }}

构造函数引用

对于一个现有构造函数,我们可以利用它的名称和关键字new来创建它的一个引用: ClassName::new。

它的功能与指向静态方法的引用类似。

无参构造函数

例如,假设有一个构造函数没有参数。 它适合Supplier的签名() -> Phone。

Supplier<Phone> c1 = Phone::new;Phone a1 = c1.get();

这就等价于:

Supplier<Phone> c1 = () -> new Phone();Phone a1 = c1.get();

有参构造函数

如果你的构造函数的签名是Phone(Integer price),那么它就适合Function接口的签名。

Function<Integer, Phone> c2 = Phone::new;Phone a2 = c2.apply(110);

这就等价于:

Function<Integer, Phone> c2 = (price) -> new Phone(price);Phone a2 = c2.apply(110);

小结

  • Lambda表达式可以理解为一种匿名函数:它没有名称,但有参数列表、函数主体、返回类型,可能还有一个可以抛出的异常的列表。
  • 函数式接口就是仅仅声明了一个抽象方法的接口。
  • 只有在接受函数式接口的地方才可以使用Lambda表达式。
  • Lambda表达式允许你直接内联,为函数式接口的抽象方法提供实现,并且将整个表达式作为函数式接口的一个实例。
  • Java 8自带一些常用的函数式接口,放在java.util.function包里,包括Predicate<T>、Function<T,R>、Supplier<T>、Consumer<T>。
  • Comparator、Predicate和Function等函数式接口都有几个可以用来结合Lambda表达式的默认方法。

作者:翎野君

本篇文章如有帮助到您,请给「翎野君」点个赞,感谢您的支持。

目录
相关文章
|
1天前
|
Java
Java接口中可以定义哪些方法?
【4月更文挑战第13天】
4 0
Java接口中可以定义哪些方法?
|
3天前
|
设计模式 Java
Java接口与抽象类
Java接口与抽象类
15 0
|
3天前
|
分布式计算 Java API
Java 8新特性之Lambda表达式与Stream API
【4月更文挑战第16天】本文将介绍Java 8中的两个重要新特性:Lambda表达式和Stream API。Lambda表达式是Java 8中引入的一种新的编程语法,它允许我们将函数作为参数传递给其他方法,从而使代码更加简洁、易读。Stream API是Java 8中引入的一种新的数据处理方式,它允许我们以声明式的方式处理数据,从而使代码更加简洁、高效。本文将通过实例代码详细讲解这两个新特性的使用方法和优势。
|
7天前
|
Java
Java 14 强势登场:Switch 表达式的进化之路
Java 14 强势登场:Switch 表达式的进化之路
13 0
|
7天前
|
安全 Java 编译器
接口之美,内部之妙:深入解析Java的接口与内部类
接口之美,内部之妙:深入解析Java的接口与内部类
25 0
接口之美,内部之妙:深入解析Java的接口与内部类
|
9天前
|
Java 开发者
Java中的Lambda表达式:简洁、灵活的编程利器
在现代软件开发中,编写简洁、高效的代码是至关重要的。Java中的Lambda表达式为开发者提供了一种简洁、灵活的编程方式,使得代码更具可读性和可维护性。本文将探讨Lambda表达式的基本概念、语法结构以及在实际项目中的应用,以帮助读者更好地理解和运用这一强大的编程工具。
5 0
|
9天前
|
存储 Java
java接口和内部类
java接口和内部类
|
10天前
|
存储 Java 数据库连接
java多线程之线程通信
java多线程之线程通信
|
9天前
|
算法 Java 开发者
Java中的多线程编程:概念、实现与性能优化
【4月更文挑战第9天】在Java编程中,多线程是一种强大的工具,它允许开发者创建并发执行的程序,提高系统的响应性和吞吐量。本文将深入探讨Java多线程的核心概念,包括线程的生命周期、线程同步机制以及线程池的使用。接着,我们将展示如何通过继承Thread类和实现Runnable接口来创建线程,并讨论各自的优缺点。此外,文章还将介绍高级主题,如死锁的预防、避免和检测,以及如何使用并发集合和原子变量来提高多线程程序的性能和安全性。最后,我们将提供一些实用的性能优化技巧,帮助开发者编写出更高效、更稳定的多线程应用程序。