[二] java8 函数式接口详解函数接口详解 lambda表达式匿名函数方法引用使用含义函数式接口实例如何定义函数式接口

时间 2019-11-06

标签 java8 java 函数接口详解 lambda 表达式匿名方法引用使用含义实例如何定义栏目 Java 繁體版

原文原文链接

函数式接口详细定义

package java.lang;
import java.lang.annotation.*;
/**
* An informative annotation type used to indicate that an interface
* type declaration is intended to be a <i>functional interface</i> as
* defined by the Java Language Specification.
*
* Conceptually, a functional interface has exactly one abstract
* method. Since {@linkplain java.lang.reflect.Method#isDefault()
* default methods} have an implementation, they are not abstract. If
* an interface declares an abstract method overriding one of the
* public methods of {@code java.lang.Object}, that also does
* <em>not</em> count toward the interface's abstract method count
* since any implementation of the interface will have an
* implementation from {@code java.lang.Object} or elsewhere.
*
* <p>Note that instances of functional interfaces can be created with
* lambda expressions, method references, or constructor references.
*
* <p>If a type is annotated with this annotation type, compilers are
* required to generate an error message unless:
*
* <ul>
* <li> The type is an interface type and not an annotation type, enum, or class.
* <li> The annotated type satisfies the requirements of a functional interface.
* </ul>
* <p>However, the compiler will treat any interface meeting the
* definition of a functional interface as a functional interface
* regardless of whether or not a {@code FunctionalInterface}
* annotation is present on the interface declaration.
*
* @jls 4.3.2. The Class Object
* @jls 9.8 Functional Interfaces
* @jls 9.4.3 Interface Method Body
* @since 1.8
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

一种用于表示一个接口是Java语言规范定义的函数式接口的注解类型.

关键概念

从文件注释中咱们能够看到函数式接口的关键概念

函数式接口只有一个抽象方法

因为default方法有一个实现,因此他们不是抽象的.

若是一个接口定义了一个抽象方法,而他刚好覆盖了Object的public方法,仍旧不算作接口的抽象方法, 由于它终将会在某处获得一个实现.(若是不是public的那么计数)

也便是只有一个抽象方法默认不算,Object的public也不算

函数式接口的实例能够经过 lambda表达式方法引用或者构造方法引用进行表示

类型必须是接口,而不能是其余的好比class 并且须要符合函数式接口的定义要求不然使用注解时编译器报错

无论他们是否有使用注解FunctionalInterface 进行注解, 编译器将会把任何知足函数式接口定义的接口当作一个函数式接口也就是说不加也行,可是显然不加的话,就没有限制约束,后续可能增长了其余方法致使出错

经常使用函数式接口

四大基础接口 java.util.function 包

接口抽象方法

Predicate<T> boolean test(T t);
Consumer<T> void accept(T t);
Function<T, R> R apply(T t);
Supplier<T> T get();

java.util.function.Predicate<T>

断言也就是条件测试器接收条件,进行测试

接口定义了一个名叫test的抽象方法，它接受泛型T对象，并返回一个boolean。

test (条件测试) , and-or- negate(与或非) 方法

java.util.function.Consumer<T>

消费者消费数据接收参数,返回void 数据被消费了

定义了一个名叫accept的抽象方法，它接受泛型T的对象，没有返回（void）

你若是须要访问类型T的对象，并对其执行某些操做，就可使用这个接口

java.util.function.Function<T, R>

函数有输入有输出数据转换功能

接口定义了一个叫做apply的方法，它接受一个泛型T的对象，并返回一个泛型R的对象。

java.util.function.Supplier<T>
提供者不须要输入,产出T 提供数据
无参构造方法提供T类型对象

接口中的compose, andThen, and, or, negate 用来组合函数接口而获得更强大的函数接口

四大接口为基础接口,其余的函数接口都是经过这四个扩展而来的

此处的扩展是指概念的展开不是日常说的继承或者实现,固然实现上多是经过继承好比UnaryOperator

扩展方式:

参数个数上扩展

好比接收双参数的，有 Bi 前缀，好比 BiConsumer<T,U>, BiFunction<T,U,R> ;

特殊经常使用的变形

好比 BinaryOperator ，是同类型的双参数 BiFunction<T,T,T> ，二元操做符； UnaryOperator 是 Function<T,T> 一元操做符。

类型上扩展

为何要有基本类型扩展

只有对象类型才能做为泛型参数,对于基本类型就涉及到装箱拆箱的操做,虽然是自动的

可是这不可避免给内存带来了额外的开销,装箱和拆箱都会带来开销

因此为了减少这些性能开销对基本类型进行类型扩展

Stream 类的某些方法对基本类型和装箱类型作了区分

Java 8中，仅对整型、长整型和双浮点型作了特殊处理由于它们在数值计算中用得最多

对基本类型作特殊处理的方法在命名上有明确的规范

若是参数是基本类型，则不加前缀只需类型名便可
若是方法返回类型为基本类型，则在基本类型前再加上一个 To

总结一句话:

加了类型前缀[Int|Double|Long] 表示参数是基本类型, 若是在此基础上又加上了To 表示返回类型是基本类型

若有可能，应尽量多地使用对基本类型作过特殊处理的方法，进而改善性能

函数式接口的实例

函数式接口的实例能够经过 lambda表达式方法引用或者构造方法引用进行表示

Lambda表达式

能够把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式,也就是用来表示匿名函数

它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个能够抛出的异常列表。

特色

匿名——咱们说匿名，是由于它不像普通的方法那样有一个明确的名称：写得少而想得多！
函数——咱们说它是函数，是由于Lambda函数不像方法那样属于某个特定的类。但和方法同样，Lambda有参数列表、函数主体、返回类型，还可能有能够抛出的异常列表。
传递——Lambda表达式能够做为参数传递给方法或存储在变量中。
简洁——无需像匿名类那样写不少模板代码。

基本语法

Lambda的基本语法是

(parameters) -> expression

或（请注意语句的花括号）

(parameters) -> { statements; }

Lambda表达式三个部分

参数列表
箭头 ( -> 把参数列表与Lambda主体分隔开)
Lambda主体 (表达式或者语句)

一些变形

1. 表达式不包含参数，使用空括号 () 表示没有参数 () -> System.out.println("Hello World");

2. 包含且只包含一个参数，可省略参数的括号 s -> System.out.println("Hello World");

3. Lambda 表达式的主体不只能够是一个表达式，并且也能够是一段代码块，使用大括号（{}）将代码块括起来

该代码块和普通方法遵循的规则别无二致，能够用返回或抛出异常来退出。

只有一行代码的 Lambda表达式也可以使用大括号，用以明确 Lambda表达式从何处开始、到哪里结束。

() -> {

System.out.print("Hello");

System.out.println(" World");

};

4. Lambda 表达式也能够表示包含多个参数的方法 (Long x, Long y) -> x + y;

5. 能够把 4 中的表达式进行简化,(x, y) -> x + y; 这借助于类型推断下面会说到

Lambda只能引用值，而不是变量(要求事实上的final)

匿名内部类，须要引用它所在方法里的变量时，须要将变量声明为 final

Lambda表达式不要求必须是final 变量可是，该变量在既成事实上必须是final

事实上的 final 是指只能给该变量赋值一次。换句话说，Lambda 表达式引用的是值，而不是变量跟匿名内部类相似,使用的是变量值的拷贝因此须要是不改变的

若是你试图给该变量屡次赋值，而后在 Lambda 表达式中引用它，编译器就会报错

好比:

无需设置final 一切运行正常

一旦给hello变量从新赋值 ,编译器将会报错

方法引用

方法引用让你能够重复使用现有的方法定义并像Lambda同样传递它们

方法引用使用 :: 来表示

方法引用主要有三类

(1) 指向静态方法的方法引用（例如Integer的parseInt方法，写做Integer::parseInt）

也就是静态方法做用于对象上

示例:字符串转换为数值

(2)指向任意类型实例方法的方法引用（例如 String 的 length 方法，写做String::length）

你在引用一个对象的方法，而这个对象自己是Lambda的一个参数。例如，Lambda表达式(String s) -> s.toUppeCase() 能够写做String::toUpperCase

示例:打印字符串的长度 1个 3个 2个 (没有空格和换行因此挤在一块儿了)

(3) 指向现有对象的实例方法的方法引用

好比lambda表达式中调用字符串helloString的charAt()方法 helloString就是一个现有对象

示例:获取字符串位于给定序列的charAt值

构造函数引用

对于一个现有构造函数，你能够利用它的名称和关键字new来建立它的一个引用：

ClassName::new

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

定义Class A 三个属性设置了默认值以观察构造方法的调用状况

class A {
private String s1="a";
private String s2="b";
private String s3="c";
A(){
}
A(String s1){
this.s1=s1;
}

A(String s1,String s2){
this.s1=s1;
this.s2=s2;
}
A(String s1,String s2,String s3){
this.s1=s1;
this.s2=s2;
this.s3=s3;
}

@Override
public String toString() {
final StringBuilder sb = new StringBuilder("A{");
sb.append("s1='").append(s1).append('\'');
sb.append(", s2='").append(s2).append('\'');
sb.append(", s3='").append(s3).append('\'');
sb.append('}');
return sb.toString();
}
}

能够看到分别调用了,无参构造方法一个参数构造方法以及两个参数构造方法

若是三个构造方法如何设置呢?

咱们只须要定义函数接口便可

再次运行

类型检查与类型推断

类型检查

咱们知道当咱们操做赋值运算时会有类型检查

好比:

那么对于函数式接口与函数值呢

函数式接口变量名 = Lambda-匿名函数/方法引用/构造方法引用;

那么函数做为值是如何进行类型检查的?

Lambda的类型是从使用Lambda的上下文推断出来的

上下文中Lambda表达式须要的类型称为目标类型

上下文是好比接受它传递的方法的形式参数，或接受它的值的局部变量

形式参数或者局部变量都会有类型的定义与声明

好比筛选 1~9之中小于5的数值

List<Integer> listNum = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); java

List filteredNum = listNum.stream().filter(i -> i.compareTo(5) < 0).collect(Collectors.toList()); web

System.out.println(filteredNum);express

这个示例中接收 Lambda表达式做为参数的形式参数为 Predicate<? super T> predicate

也就是目标类型函数接口为Predicate<T>

找到了目标类型咱们的T为Integer

也就是Predicate<Integer>

他的抽象方法为 boolean test(T t); 也就是 boolean test(Integer t); 接收一个Integer返回一个boolean

咱们的Lambda匿名函数 i -> i.compareTo(5) < 0 就是接收一个Integer 返回一个boolean 因此类型检查经过

简单说就是:

1. 经过形参类型或者变量类型找到函数接口进而找到抽象方法的声明

2. 而后在与参数值进行比对查看是否匹配

能够看得出来,Lambda表达式最终匹配的是函数接口中的抽象方法的方法签名

若是不一样的函数接口,具备相互兼容的抽象方法签名那么一个Lambda表达式显然能够匹配多个函数接口

特殊的void兼容规则

若是一个Lambda的主体是一个语句表达式，它就和一个返回void的函数描述符兼容（固然须要参数列表也兼容）。

就是说若是主体是一个语句,无论作什么或者调用方法返回其余的类型,他均可以兼容void

例如

List的add方法 boolean add(E e);

List<String> list= new ArrayList<>(); app

// Predicate返回了一个boolean less

Predicate<String> p = s -> list.add(s); ide

// Consumer返回了一个void 函数

Consumer<String> b = s -> list.add(s);性能

上面的代码均可以经过编译,而且运行

类型推断

类型推断的概念,在Java中不是第一次出现

Java SE 7以前，声明泛型对象的代码以下

List<String> list = new ArrayList<String>();

Java 7中，可使用以下代码：

List<String> list = new ArrayList<>();

这就是类型推断 ,一个最直接直观的好处就是能够简化代码的书写,这不就是语法糖么

针对 Lambda表达式也有类型推断

Java编译器能够根据上下文（目标类型）推断出用什么函数式接口来配合Lambda表达式

而后就能够获取到函数接口对应的函数描述符也就是那个抽象方法的方法签名

编译器能够了解Lambda表达式的参数类型，这样就能够在Lambda语法中省去标注参数类型

好比刚才的筛选 1~9之中小于5的数值的例子中,就能够有以下几种写法

.filter((Integer i) -> { return i.compareTo(5) < 0;}).collect(Collectors.toList()); 测试

.filter((Integer i) ->i.compareTo(5) < 0).collect(Collectors.toList()); ui

.filter(i ->i.compareTo(5) < 0).collect(Collectors.toList());

如何使用函数式接口

函数式接口定义了函数的类型有了类型就如同其余类型好比 int 同样

你能够定义变量

你能够传递参数

你能够返回

一个函数方法有方法签名和方法体两部份内容组成

函数接口只是有了方法签名

方法体由函数式接口的实例传递(也就是Lambda表达式-匿名函数方法引用构造方法引用 )

具体的调用则是调用抽象方法抽象方法的方法体就是函数式接口的实例

好比:

定义一个函数式接口,也可使用预置的好比 Predicate等

而后就是定义变量使用Lambda实例化

再接着就是方法调用

[二] java8 函数式接口详解 函数接口详解 lambda表达式 匿名函数 方法引用使用含义 函数式接口实例 如何定义函数式接口