一起爪哇Java 8(二)——Lambda表达式和方法引用

简介:

定义

Java 表达式有很多种,声明一个class是一个表达式,定义一个变量是一个表达式,写一个=赋值逻辑是一个表达式……

Lambda表达式是这样一个表达式:

lambdaParameters -> lambdaBody

在lambdaParameters传递参数,在lambdaBody中编写逻辑。lambda表达式生成的结果就是一个函数式接口(上文提到过的)。lambdaBody中的逻辑内容(各种表达式)不会在定义时执行,在实际函数式接口调用时才会执行。

举几个官方的例子看看:

() -> {}                // No parameters; result is void
() -> 42                // No parameters, expression body
() -> null              // No parameters, expression body
() -> { return 42; }    // No parameters, block body with return
() -> { System.gc(); }  // No parameters, void block body

() -> {                 // Complex block body with returns
  if (true) return 12;
  else {
    int result = 15;
    for (int i = 1; i < 10; i++)
      result *= i;
    return result;
  }
}                          

(int x) -> x+1              // Single declared-type parameter
(int x) -> { return x+1; }  // Single declared-type parameter
(x) -> x+1                  // Single inferred-type parameter
x -> x+1                    // Parentheses optional for
                            // single inferred-type parameter

(String s) -> s.length()      // Single declared-type parameter
(Thread t) -> { t.start(); }  // Single declared-type parameter
s -> s.length()               // Single inferred-type parameter
t -> { t.start(); }           // Single inferred-type parameter

(int x, int y) -> x+y  // Multiple declared-type parameters
(x, y) -> x+y          // Multiple inferred-type parameters
(x, int y) -> x+y    // Illegal: can't mix inferred and declared types
(x, final y) -> x+y  // Illegal: no modifiers with inferred types

lambda表达式的参数部分

可以通过上面的例子看到,lambda的参数声明主要包含两大类,一类是声明类型的,一类是不声明类型的(依赖推断的)。其中声明类型的参数,与定义一个方法时声明参数是一样的。

几个注意的点:

  1. _不能作为lambda参数。
  2. int...与int[]是一致的。
  3. 当参数是推断类型时,注意推断类型的类型转换错误,类型是依据上下文变化的。

来个推断的例子:

        Function inferedFunc = x -> {
            System.out.println(x.getClass().getTypeName());
            return x.toString();
        };

        Object a = inferedFunc.apply(10);
        Object b = inferedFunc.apply(100D);

lambda表达式的body部分

body部分的形式同一个方法的描述基本一致,或者是一个表达式,或者是一个block代码。整体理解lambda的参数和body,可以对应上一节的Function接口来看:()的参数部分,对应Function的第一个泛型参数;{}或者类似x+1这样的表达式作为body,对应Function的第二个泛型参数。空参数对应Supplier,而空return对应Consumer。

不同于匿名内部类的形式,lambda表达式的body共享上下文类的this变量。另一个注意点是lambda表达式的body里包含的外部变量,变量需要是final的或者effectively final。

effectively final的定义如下:

  • 如果是有初始值的变量(赋值过一次),需要满足:

    • 没有声明final
    • 从未出现在赋值语句的左值部分
    • 从未作为一个变量被++或--之类的递增递减形式操作过
  • 如果是没有初始值的变量,需要满足:

    • 没有声明final
    • 在实际赋值前,绝对未赋值或者未绝对赋值
    • 从未作为一个变量被++或--之类的递增递减形式操作过
  • 方法、构造函数、lambda和异常的参数,会被认为是effectively final

这里又引入两个概念:绝对赋值和绝对未赋值。

  • 绝对赋值:变量在复杂逻辑中的每个执行路径中都保证赋值语句存在。
  • 绝对未赋值:变量在复杂逻辑中的每个执行路径中都保证没有赋值语句存在。

看个例子:(绝对赋值,需要注释掉n=6)

{
    int k;
    while (true) {
        k = n;
        if (k >= 5) break;  //这里之前是绝对赋值
        n = 6;    //如果n=2,那么k需要被赋值两次,就不是绝对赋值
    }
    System.out.println(k);
}

不满足绝对赋值:

{
    int k;
    while (n < 4) {
        k = n;
        if (k >= 5) break;
        n = 6;
    }
    System.out.println(k);  /* k is not "definitely assigned"
                               before this statement */
}

绝对未赋值:

void unflow(boolean flag) {
    final int k;
    if (flag) {
        k = 3;
        System.out.println(k);
    }
    else {
        k = 4;
        System.out.println(k);
    }
}

不满足绝对未赋值:

void unflow(boolean flag) {
    final int k;
    if (flag) {
        k = 3;
        System.out.println(k);
    }
    if (!flag) {
        k = 4;
        System.out.println(k);  /* k is not "definitely unassigned"
                                   before this statement */
    }
}

body部分也表达出了一部分兼容性,即当body部分是表达式语句时,如果语句允许独立执行,那么该表达式等价于body部分是void返回值的。即如下的例子,list.add是个返回boolean的方法,因为可以独立执行,那么下面的例子都是OK的:

List list = new ArrayList();
// Predicate has a boolean result
java.util.function.Predicate<String> p = s -> list.add(s);
// Consumer has a void result
java.util.function.Consumer<String> c = s -> list.add(s);

方法引用

方法引用表达式是另一类执行函数式接口的模式,在Java 8之前是没有能力表达一个函数方法的,在Java 8引入函数式接口后,每个lambda表达式都代表了一个函数,可以指向性的将lambda表达式赋值给一个Function类的接口。另一个重要的方法就是直接使用函数方法引用。

方法引用是通过[对象名]::[方法名]这种模式来引用的,其中::两个冒号的操作符非常重要。具体的场景针对类、对象实例、数组、泛型等均有不同的支持,下面的例子看看各种方法引用的表达方式:

public class TestJ8MethodReference {

    public static void main(String[] args) {
        // static method
        Function<Integer, Integer> f1 = TestJ8MethodReference::add;
        System.out.println(f1.apply(1));
        // instance method
        Function<String, String> f2 = String::trim;
        System.out.println(f2.apply("   abd b"));
        TestJ8MethodReference testJ8MethodReference = new TestJ8MethodReference();
        Function<Integer, String> f3 = testJ8MethodReference::getStr;
        System.out.println(f3.apply(3));
        // super
        testJ8MethodReference.testSuper();

        // explicit type arguments for generic type
        testJ8MethodReference.testExplicitType();

        // implicit type arguments for generic type
        testJ8MethodReference.testImplicitType();

        // new
        Supplier s1 = TestJ8MethodReference::new;
        System.out.println(s1.get());

        // type arguments inferred from context
        Consumer<int[]> c1 = Arrays::sort;
        int[] array = new int[]{4, 3, 2, 1};
        c1.accept(array);

        // explicit type arguments
        Consumer<int[]> c2 = Arrays::<int[]>sort;
        c2.accept(array);

        // new array
        Function<Integer, int[]> f4 = (int[]::new);
        int[] a = f4.apply(10);
        System.out.println(a.length);
    }

    public static int add(int x) {
        return x + 1;
    }

    public String getStr(int x) {
        return "" + x;
    }

    public void testSuper() {
        Supplier<String> f = super::toString;
        System.out.println(f.get());
    }

    public void testExplicitType() {
        List<String> list = new ArrayList<>();
        Function<String, Boolean> func = list::add;
        System.out.println(func.apply("a"));
    }

    public void testImplicitType() {
        List list = new ArrayList();
        Function<String, Boolean> func = list::add;
        System.out.println(func.apply("a"));
    }
}

其中需要注意的是,数组的new方法引用等价于一个有入参的Function,因为new一个数组是需要指定size的。

总结

无论lambda表达式还是方法引用表达式,所指向的都是一个方法或者是函数。而它们指向的内容能赋值的也一定是函数式接口。这两种指向也是实用场景各异,方法引用需要使用在已有方法上(显而易见),而lambda表达式是一种快速行内声明一个方法且指向一个函数式接口的方法。两者交互配合,基本可以覆盖各种函数式接口使用的场景。

目录
相关文章
|
3天前
|
存储 Java 索引
Java快速入门之数组、方法
### Java快速入门之数组与方法简介 #### 一、数组 数组是一种容器,用于存储同种数据类型的多个值。定义数组时需指定数据类型,如`int[]`只能存储整数。数组的初始化分为静态和动态两种: - **静态初始化**:直接指定元素,系统自动计算长度,如`int[] arr = {1, 2, 3};` - **动态初始化**:手动指定长度,系统给定默认值,如`int[] arr = new int[3];` 数组访问通过索引完成,索引从0开始,最大索引为`数组.length - 1`。遍历数组常用`for`循环。常见操作包括求和、找最值、统计特定条件元素等。
|
1天前
|
算法 Java API
Java 方法注释:规范、实用和高质量的写法
本文深入探讨了如何编写高质量的 Java 方法注释
21 11
|
1天前
|
SQL Java 数据库连接
【潜意识Java】Java中JDBC过时方法的替代方案以及JDBC为什么过时详细分析
本文介绍了JDBC中一些常见过时方法及其替代方案。
20 5
|
1月前
|
Java API 开发者
Java中的Lambda表达式与Stream API的协同作用
在本文中,我们将探讨Java 8引入的Lambda表达式和Stream API如何改变我们处理集合和数组的方式。Lambda表达式提供了一种简洁的方法来表达代码块,而Stream API则允许我们对数据流进行高级操作,如过滤、映射和归约。通过结合使用这两种技术,我们可以以声明式的方式编写更简洁、更易于理解和维护的代码。本文将介绍Lambda表达式和Stream API的基本概念,并通过示例展示它们在实际项目中的应用。
|
1月前
|
安全 Java API
Java中的Lambda表达式:简化代码的现代魔法
在Java 8的发布中,Lambda表达式的引入无疑是一场编程范式的革命。它不仅让代码变得更加简洁,还使得函数式编程在Java中成为可能。本文将深入探讨Lambda表达式如何改变我们编写和维护Java代码的方式,以及它是如何提升我们编码效率的。
|
15天前
|
监控 Java
java异步判断线程池所有任务是否执行完
通过上述步骤,您可以在Java中实现异步判断线程池所有任务是否执行完毕。这种方法使用了 `CompletionService`来监控任务的完成情况,并通过一个独立线程异步检查所有任务的执行状态。这种设计不仅简洁高效,还能确保在大量任务处理时程序的稳定性和可维护性。希望本文能为您的开发工作提供实用的指导和帮助。
72 17
|
26天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
11天前
|
缓存 安全 算法
Java 多线程 面试题
Java 多线程 相关基础面试题
|
28天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
28天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。