广元单页网站制作/个人网站制作模板

Java 8函数式编程设计-Functional-Interface

我自己的理解，函数式编程对用户最大的价值是促使开发者养成模块化编程的习惯，代码可读性和维护性提高很多。

通过阅读JDK 8的 java.util.function 和
java.util.stream 包源码，意在理解Java的函数式接口设计。

读后自己的理解：Java函数式编程的核心是将最基础的数学函数抽象成接口对象，可在已有的接口上进行积木拼插组合，形成完整地类型转换系统。最基础的数学函数包括一元函数、谓词、二元函数、运算符计算，对应的Java接口分别是Function、Predicate、BiFunction、BinaryOperator。

源码阅读笔记：jdk-8-Functional-Interface

---

函数式接口API

• @FunctionalInterface
• Functional interfaces
  • Function
  • Consumer
  • Predicate
  • Supplier
• 数据流特性和操作
  • BaseStream
  • Stream
• 使用示例

---

@FunctionalInterface

• 函数式接口注解
• 从概念上讲，函数式接口都只有一个抽象方法。
• 请注意，可以使用Lambda表达式、方法引用和构造器引用创建函数式接口的实例。

---

Functional interfaces

• 函数式接口提供lambda表达式和方法引用的目标类型
• 每个函数式接口有一个单一的抽象方法，称为函数方法
• 函数式接口可以匹配或适配为lambda表达式的参数和返回类型
• 函数式接口可以在多个上下文中提供一个目标类型，如赋值上下文、方法调用上下文、转换上下文
• 函数式接口往往代表抽象的概念，如函数、操作、谓词
• 可扩展的命名约定
• 基本的一元函数：Function、Consumer、Predicate、Supplier
• 二元函数：BiFunction、BiConsumer、BiPredicate
• 扩展的运算符：UnaryOperator、BinaryOperator
• 泛型->基本类型：int、long、double

一元函数

Function<T, R>

• 从T到R的一元映射函数，接受一个参数并产生一个结果的一元函数 (类型转换函数)
• R apply(T t)
• 组合函数
• compose(before)：V -> T -> R
• andThen(after)：T -> R -> V
• 基本类型的参数：IntFunction、LongFunction、DoubleFunction
• 基本类型的结果：ToIntFunction、ToLongFunction、ToDoubleFunction
• 基本类型的参数和结果：IntToLongFunction、IntToDoubleFunction

Consumer<T>

• 从T到void的一元函数，接受一个入参但不返回任何结果的操作
• void accept(T t)
• andThen(after)：N个消费者模式，多次消费的场景
• 基本类型的参数：IntConsumer、LongConsumer、DoubleConsumer

Predicate<T>

• 一个参数的谓词(返回布尔值的函数)
• boolean test(T t)
• 谓词函数：and、negate、or
• 基本类型的参数：IntPredicate、LongPredicate、DoublePredicate

Supplier<T>

• 表示结果的供应商
• T get()
• 基本类型的结果：BooleanSupplier、IntSupplier、LongSupplier、DoubleSupplier

使用图表方式总结如下：

一元函数	方法	类型转换	组合方法	基本类型专用类
Function<T, R>	R apply(T t)	T->R	compose(before)、andThen(after)	IntFunction、ToIntFunction、IntToLongFunction
Consumer	void accept(T t)	T->void	andThen(after)	IntConsumer
Predicate	boolean test(T t)	T->boolean	and、negate、or	IntPredicate
Supplier	T get()	*->T		IntSupplier、BooleanSupplier

二元函数

BiFunction<T, U, R>

• 从(T、U)到R的二元函数，接受两个参数并产生一个结果的二元函数
• R apply(T t, U u)
• 组合函数
• andThen(Function<? super R, ? extends V> after)：(T, U) -> R -> V
• 基本类型的结果：ToIntBiFunction<T, U>、ToLongBiFunction<T, U>、ToDoubleBiFunction<T, U>

BiConsumer<T, U>

• 从(T、U)到void的二元函数，接受两个入参但不返回任何结果的操作
• void accept(T t, U u)
• 基本类型的参数：ObjIntConsumer、ObjLongConsumer、ObjDoubleConsumer

BiPredicate<T, U>

• 两个参数的谓词(返回布尔值的函数)
• boolean test(T t, U u)
• 谓词函数：and、negate、or

使用图表方式总结如下：

二元函数	方法	类型转换	组合方法	基本类型专用类
BiFunction<T, U, R>	R apply(T t, U u)	(T、U)->R	andThen(Function after)	ToIntBiFunction<T, U>
BiConsumer<T, U>	void accept(T t, U u)	(T、U)->void	andThen(after)	ObjIntConsumer
BiPredicate<T, U>	boolean test(T t, U u)	(T、U)->boolean	and、negate、or

扩展的运算符

UnaryOperator<T>

• 一元运算符(单个操作数，生产与操作数类型相同的结果)
• 继承自Function<T, T>
• 基本类型的运算符：IntUnaryOperator、LongUnaryOperator、DoubleUnaryOperator

BinaryOperator<T>

• 二元运算符(两个相同类型的操作数，生产与操作数类型相同的结果)
• 继承自BiFunction<T, T, T>
• 基本类型的运算符：IntBinaryOperator、LongBinaryOperator、DoubleBinaryOperator

运算符	父类	组合方法	基本类型专用类
UnaryOperator	Function<T, T>		IntUnaryOperator: int applyAsInt(int operand)
BinaryOperator	BiFunction<T, T, T>	minBy、maxBy	IntBinaryOperator: int applyAsInt(int left, int right)

数据流操作

BaseStream<T,S extends BaseStream<T,S>>

数据流操作特性

• 顺序流
• 并行流
• 拆分器
• 关闭数据流(数据流管道)

Stream<T>

数据流

• 中间操作，返回Stream<T>
  • filter
  • distinct
  • map
  • flatMap
  • peek
• 终结操作，返回结果/Optional<T>
  • collect
  • forEach
  • reduce
  • anyMatch
  • findAny
  • findFirst
  • count
  • max
  • min

使用示例

Optional<T>

单值数据流

• 可能包含null值的容器对象，包装方法的返回结果
• empty()、of(T value)、ofNullable(T value)
• isPresent()、get()
• void ifPresent(Consumer<? super T> consumer)
• Optional filter(Predicate<? super T> predicate)：过滤操作
• Optional map(Function<? super T, ? extends U> mapper)
• Optional flatMap(Function<? super T, Optional> mapper)
• T orElse(T other)、T orElseGet(Supplier<? extends T> other)、T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X
• 基本类型实现：OptionalInt、OptionalLong、OptionalDouble
• 使用模式：
  • Optional.ifPresent(consumer)
  • Optional.filter(predicate).flatMap(mapper)
  • Optional.filter(predicate).map(mapper)

---

祝大家玩得开心！ˇˍˇ

简放，杭州