美文网首页Python
Lamda 表达式作用域和内置函数式接口

Lamda 表达式作用域和内置函数式接口

作者: happyJared | 来源:发表于2019-07-30 08:29 被阅读52次

Lamda 表达式作用域

访问局部变量

可以直接在 lambda 表达式中直接访问外部的局部变量:

final int num = 1;
Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
stringConverter.convert(2);  // 3

但是和匿名对象不同的是,这里的变量 num 可以不用声明为 final,该代码同样正确:

int num = 1;
Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
stringConverter.convert(2);     // 3

不过这里的 num 必须不可被后面的代码修改(即隐性的含有 final 语义),例如下面的就无法编译:

int num = 1;
Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
num = 3;  // 在 lambda 表达式中试图修改 num 同样是不允许的

访问字段和静态变量

与局部变量相比,对 lambda 表达式中的实例字段和静态变量都有读写访问权限,该行为和匿名对象是一致的:

class Lambda4 {
    static int outerStaticNum;
    int outerNum;

    void testScopes() {
        Converter<Integer, String> stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };

        Converter<Integer, String> stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }
}

访问默认接口方法

还记得上一篇文章中的 formula 示例吗? Formula 接口定义了一个默认方法 sqrt(),可以从包含匿名对象的每个 formula 实例访问该方法,不过这不适用于 lambda 表达式,无法从 lambda 表达式中访问默认方法,以下代码无法通过编译:

Formula formula = (a) -> sqrt(a * 100);

内置函数式接口

JDK1.8 API 包含许多内置函数式接口。 其中一些借口在老版本的 Java 中是比较常见的,比如: ComparatorRunnable,这些接口都增加了 @FunctionalInterface 注解,以便能用在 lambda 表达式上。

但是 Java8 API 同样还提供了很多全新的函数式接口来让编程工作更加方便,有一些接口是来自 Google Guava 库里的,来看看这些是如何扩展到 lambda 上使用的。

Predicates

Predicate 接口是只有一个参数的返回布尔类型值的 断言型 接口。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑(比如:与,或,非):

Predicate 接口源码如下:

package java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface Predicate<T> {

    // 该方法是接受一个传入类型,返回一个布尔值.此方法应用于判断
    boolean test(T t);

    // and 方法与关系型运算符"&&"相似,两边都成立才返回 true
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    // 与关系运算符"!"相似,对判断进行取反
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    // or 方法与关系型运算符"||"相似,两边只要有一个成立就返回 true
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
   // 该方法接收一个 Object 对象,返回一个 Predicate 类型。此方法用于判断第一个 test 的方法与第二个 test 方法相同(equal)
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

示例:

Predicate<String> predicate = (s) -> s.length() > 0;

predicate.test("foo");              // true
predicate.negate().test("foo");     // false

Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;

Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

Functions

Function 接口接受一个参数并生成结果。默认方法可用于将多个函数链接在一起(compose, andThen):

Function 接口源码如下:

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Function<T, R> {

    // 将Function对象应用到输入的参数上,然后返回计算结果
    R apply(T t);

    // 将两个Function整合,并返回一个能够执行两个 Function 对象功能的 Function 对象
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123");  // "123"

Suppliers

Supplier 接口产生给定泛型类型的结果。 与 Function 接口不同,Supplier 接口不接受参数。

Supplier<Person> personSupplier = Person::new;
personSupplier.get();  // new Person

Consumers

Consumer 接口表示要对单个输入参数执行的操作。

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));

Comparators

Comparator 是老版本中的经典接口, Java8 在此之上添加了多种默认方法:

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);

Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");

comparator.compare(p1, p2);             // > 0
comparator.reversed().compare(p1, p2);  // < 0

相关文章

  • Lamda 表达式作用域和内置函数式接口

    Lamda 表达式作用域 访问局部变量 可以直接在 lambda 表达式中直接访问外部的局部变量: 但是和匿名对象...

  • Java8新特性

    1.Lamda表达式 Lambda表达式的作用主要是用来简化接口的创建,使用Lambda表达式接口必须是函数式接口...

  • Java8教程

    本次只讲三个东西,Lamda表达式、函数引用、函数式接口。 一、Lamda表达式 也就是说以前需要用匿名实现类来做...

  • Java8 新特性 四大内置核心函数式接口及其扩展

    四大内置核心函数式接口 Java内置的函数式接口是为了方便开发者使用Lambda表达式,对于应对大部分函数式接口的...

  • JDK8新特性 内置函数式接口

    1. 内置函数式接口由来 lambda表达式的前提是需要有函数式接口。而且lambda表达式使用时不关心接口名,抽...

  • 3.JDK1.8特性之函数式接口

    1.什么是函数式接口 2.自定义函数式接口 3.Lambda表达式替代函数式接口做参数使用 4.Java内置四大核...

  • Lambda表达式总结

    Lambda表达式总结使用范例以及例子Lambda表达式基础语法函数式接口Lambda练习Java8四大内置函数式...

  • golang作用域总结

    作用域分为全局作用域、包级作用域和局部作用域 系统内置的类型、函数和常量属于全局作用域 命名函数只能在包级作用域中...

  • python基础-08-内置函数、作用域、闭包、递归

    python基础-内置函数、作用域、闭包、递归 1.常见的内置函数 2.函数内变量的作用域 3.内嵌函数和闭包 4...

  • 2021-12-10

    拓展函数 高阶函数 内联函数 lamda表达式 函数式编程 jetpack kotlin 协程 flow bind...

网友评论

    本文标题:Lamda 表达式作用域和内置函数式接口

    本文链接:https://www.haomeiwen.com/subject/wkovrctx.html