Синтаксис Java расширенный 16-Lambda-Стрит-Факультативно

лямбда

　　не 2 года, дверь не нет второго шага двери. Продолжайте учиться!

Функциональный интерфейс

　　Лямбда - выражения фактически синтаксический сахар реализовать интерфейс SAM, интерфейс называется САМ Одно абстрактный метод, то есть, интерфейс только абстрактный метод должен достичь, конечно же , интерфейс может включать в себя другие не абстрактные методы.

 　　Это связанно с каким методом функции, подчеркнуть , что делать, а не в какой форме делать .

• Объектно-ориентированное мышление:

  • Сделайте одну вещь, ища цель, чтобы решить этот вопрос, вызовите метод объекта, чтобы получить вещи сделаны.

• Функциональные идеи программирования:

  • Пока перейдём к результатам, которые делают, как сделать, это не важно, важен результат, а не обращать внимание на процесс

Пользовательские функции интерфейса

 　　Пока абстрактные методы, чтобы гарантировать, что один и только один интерфейс может быть

Модификатор интерфейса Имя интерфейса {
     общественного  абстрактного имени метода обратного типа (необязательно) информационный параметр; // общественный реферат могут быть опущены
     // другие не абстрактное содержание методы 
}

Интерфейс Потребитель

　　Абстрактный метод особенность пользовательского интерфейса: физические параметры, но недействительна тип возвращаемого значения

имя интерфейса	Абстрактный метод	описание
Потребитель <T>	аннулированию принимают (T T)	Прием цели для завершения
BiConsumer <T, U>	недействительный принимают (Т Т, U и)	Прием двух объектов для завершения
DoubleConsumer	аннулированию принимает (двойное значение)	Получение двойного значения
IntConsumer	недействительным принимает (целое значение)	Прием Int
LongConsumer	аннулированию принять (длинное значение)	Получение длинного значения
ObjDoubleConsumer <Т>	недействительный принимает (T T, двойное значение)	Получение объекта и двойное значение
ObjIntConsumer <Т>	недействительный принимает (T T, INT значения)	Получение объекта и Int
ObjLongConsumer <Т>	недействительный принимает (Т т, длинное значение)	Получение целевого значения и длинный

Поставляя интерфейс

　　Способ подачи характеристики абстрактного интерфейса типа: без аргументов, возвращаемых значений, но

имя интерфейса	Абстрактный метод	описание
Поставщик <T>	T получаем ()	Возвращает объект
BooleanSupplier	булево getAsBoolean ()	Возвращает логическое значение
DoubleSupplier	двойная getAsDouble ()	Возвращает двойное значение
IntSupplier	ИНТ getAsInt ()	Возвращает Int
LongSupplier	долго getAsLong ()	Возвращает длинное значение

Анализ интерфейса

　　Метод определения характеристик абстрактного интерфейса: Есть параметры, но тип возвращаемого булева результат

имя интерфейса	Абстрактный метод	описание
Предиката <Т>	логический тест (T T)	Получение объекта
BiPredicate <T, U>	логический тест (T T, U U)	Прием двух объектов
DoublePredicate	логический тест (двойное значение)	Получение двойного значения
IntPredicate	логический тест (целое значение)	Прием Int
LongPredicate	логический тест (длительное значение)	Получение длинного значения

Функциональный интерфейс

　　Абстрактные методы функциональных характеристик интерфейса: оба имеют параметр возвращаемого значения

имя интерфейса	Абстрактный метод	описание
Функция <T, R>	R применяются (T T)	Получение объекта типа T, объект возвращает результат типа R
UnaryOperator <Т>	Т применяются (Т т)	Получение объекта типа T, объект возвращает результат типа T
DoubleFunction <R>	R применяется (двойное значение)	Получив двойное значение, возвращает объект типа R
IntFunction <R>	R применяется (целое значение)	Получение объекта типа INT возвращает R
LongFunction <R>	R применять (длительное значение)	Получение длинного значения, возвращает объект типа R
ToDoubleFunction <Т>	двойная applyAsDouble (значение Т)	Получение объекта типа T и возвращает двойной
ToIntFunction <Т>	INT applyAsInt (значение Т)	Получение объекта типа T и возвращает Int
ToLongFunction <Т>	долго applyAsLong (значение Т)	Получение объекта типа T и возвращает длинный
DoubleToIntFunction	INT applyAsInt (двойное значение)	Получив двойное значение, результат возвращает Int
DoubleToLongFunction	длинные applyAsLong (двойное значение)	Получение двойного значения, результат возвращается длинный
IntToDoubleFunction	double applyAsDouble(int value)	接收一个int值，返回一个double结果
IntToLongFunction	long applyAsLong(int value)	接收一个int值，返回一个long结果
LongToDoubleFunction	double applyAsDouble(long value)	接收一个long值，返回一个double结果
LongToIntFunction	int applyAsInt(long value)	接收一个long值，返回一个int结果
DoubleUnaryOperator	double applyAsDouble(double operand)	接收一个double值，返回一个double
IntUnaryOperator	int applyAsInt(int operand)	接收一个int值，返回一个int结果
LongUnaryOperator	long applyAsLong(long operand)	接收一个long值，返回一个long结果
BiFunction<T,U,R>	R apply(T t, U u)	接收一个T类型和一个U类型对象，返回一个R类型对象结果
BinaryOperator<T>	T apply(T t, T u)	接收两个T类型对象，返回一个T类型对象结果
ToDoubleBiFunction<T,U>	double applyAsDouble(T t, U u)	接收一个T类型和一个U类型对象，返回一个double
ToIntBiFunction<T,U>	int applyAsInt(T t, U u)	接收一个T类型和一个U类型对象，返回一个int
ToLongBiFunction<T,U>	long applyAsLong(T t, U u)	接收一个T类型和一个U类型对象，返回一个long
DoubleBinaryOperator	double applyAsDouble(double left, double right)	接收两个double值，返回一个double结果
IntBinaryOperator	int applyAsInt(int left, int right)	接收两个int值，返回一个int结果
LongBinaryOperator	long applyAsLong(long left, long right)	接收两个long值，返回一个long结果

Lambda表达式语法

　　其本质上，Lambda表达式是用于实现【函数式接口】的“抽象方法”

Lambda表达式语法格式

(形参列表) -> {Lambda体}

说明：

• (形参列表)它就是你要赋值的函数式接口的抽象方法的 (形参列表)，照抄

• {Lambda体}就是实现这个抽象方法的方法体

• -> 称为Lambda操作符（减号和大于号中间不能有空格，而且必须是英文状态下半角输入方式）

优化：Lambda表达式可以精简

• 当{Lambda体}中只有一句语句时，可以省略{}和{;}

• 当{Lambda体}中只有一句语句时，并且这个语句还是一个return语句，那么return也可以省略，但是如果{;}没有省略的话，return是不能省略的

• (形参列表)的类型可以省略

• 当(形参列表)的形参个数只有一个，那么可以把数据类型和()一起省略，但是形参名不能省略

• 当(形参列表)是空参时，()不能省略

ArrayList<String> list = new ArrayList<>();
list.forEach((li) -> System.out.println("li = " + li));//void forEach(Consumer<? super T> action)

方法引用

　　当 Lambda 体满足一些特殊的情况时，还可以再简化

　　　　（1）Lambda体只有一句语句，并且是通过调用一个对象的/类的现有的方法来完成的

　　　　（2）并且Lambda表达式的形参正好是给该方法的实参

　　方法引用的语法格式：

　　　　（1）实例对象名::实例方法

　　　　（2）类名::静态方法

　　　　（3）类名::实例方法

　　说明：

　　　　:: 称为方法引用操作符（两个 : 中间不能有空格，而且必须英文状态下半角输入）

　　　　Lambda表达式的形参列表，全部在Lambda体中使用上了，要么是作为调用方法的对象，要么是作为方法的实参。

　　　　在整个Lambda体中没有额外的数据。

构造器引用

　　（1）当Lambda表达式是创建一个对象，并且满足Lambda表达式形参，正好是给创建这个对象的构造器的实参列表。

　　（2） 当Lambda表达式是创建一个数组对象，并且满足Lambda表达式形参，正好是给创建这个数组对象的长度

　　构造器引用的语法格式：

　　　　类名::new

　　　　数组类型名::new

Stream

　　Stream API 提供了一种高效且易于使用的处理数据的方式。

　　Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的多种操作，可以执行非常复杂的查找、过滤和映射数据等操作。

　　Stream 是数据渠道，用于操作数据源（集合、数组等）所存储的元素序列。“集合指的是负责存储数据，Stream流指的是计算，负责处理数据！”

注意：

　　①Stream 自己不会存储元素。

　　②Stream 不会改变源对象。每次处理都会返回一个持有结果的新Stream。

　　③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤：

　　1- 创建 Stream：通过一个数据源（如：集合、数组），获取一个流

　　2- 中间操作：中间操作是个操作链，对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。

　　3- 终止操作：一旦执行终止操作，就执行中间操作链，最终产生结果并结束Stream。

创建Stream

　　1、创建 Stream方式一：通过集合

　　　　Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

　　　　　　public default Stream<E> stream() : 返回一个顺序流

　　　　　　public default Stream<E> parallelStream() : 返回一个并行流

　　2、创建 Stream方式二：通过数组

　　　　Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

　　　　　　public static <T> Stream<T> stream(T[] array): 返回一个流

 　　　　还有重载形式，能够处理对应基本类型的数组

　　3、创建 Stream方式三：通过 Stream.of()

　　　　可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

　　　　　　public static<T> Stream<T> of(T... values) : 返回一个顺序流

　　4、创建 Stream方式四：创建无限流

　　　　可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

　　　　　　public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f):返回一个无限流

　　　　　　public static<T> Stream<T> generate(Supplier<T> s) ：返回一个无限流

中间操作

　　多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

方 法	描 述
filter(Predicate p)	筛选，接收 Lambda ， 从流中排除某些元素
distinct()	去除，通过流所生成元素的equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量
skip(long n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
peek(Consumer action)	接收Lambda，对流中的每个数据执行Lambda体操作
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator com)	产生一个新流，其中按比较器顺序排序
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

终结操作

　　终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void。流进行了终止操作后，不能再次使用。

方法	描述
boolean allMatch(Predicate p)	检查是否匹配所有元素
boolean anyMatch(Predicate p)	检查是否至少匹配一个元素
boolean noneMatch(Predicate p)	检查是否没有匹配所有元素
Optional<T> findFirst()	返回第一个元素
Optional<T> findAny()	返回当前流中的任意元素
long count()	返回流中元素总数
Optional<T> max(Comparator c)	返回流中最大值
Optional<T> min(Comparator c)	返回流中最小值
void forEach(Consumer c)	迭代
T reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 T
U reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
R collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

　　Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

Optional<T>

　　为了解决空指针异常，Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。

　　Optional实际上是个容器：它可以保存类型 T 的值，或者仅仅保存 null。

API

　　1、如何创建Optional对象？或者说如何用Optional来装值对象或null值

　　　　（1）static <T> Optional<T> empty() ：用来创建一个空的Optional

　　　　（2）static <T> Optional<T> of(T value) ：用来创建一个非空的Optional

　　　　（3）static <T> Optional<T> ofNullable(T value) ：用来创建一个可能是空，也可能非空的Optional

　　2、如何从Optional容器中取出所包装的对象呢？

　　　　（1）T get() ：要求Optional容器必须非空

　　　　　　  T get()与of(T value)使用是安全的

　　　　（2）T orElse(T other) ：

　　　　　　  orElse(T other) 与 ofNullable(T value)配合使用，

　　　　　  　如果Optional容器中非空，就返回所包装值，如果为空，就用orElse(T other)other指定的默认值（备胎）代替

　　　　（3）T orElseGet(Supplier<? extends T> other) ：

　　　　　  　如果Optional容器中非空，就返回所包装值，如果为空，就用Supplier接口的Lambda表达式提供的值代替

　　　　（4）<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)

　　　　　  　如果Optional容器中非空，就返回所包装值，如果为空，就抛出你指定的异常类型代替原来的NoSuchElementException

　　3、其他方法

　　　　（1）boolean isPresent() ：判断Optional容器中的值是否存在

　　　　（2）void ifPresent(Consumer<? super T> consumer) ：

　　　　　  　判断Optional容器中的值是否存在，如果存在，就对它进行Consumer指定的操作，如果不存在就不做

　　　　（3）<U> Optional<U> map(Function<? super T,? extends U> mapper)

　　　　　  　判断Optional容器中的值是否存在，如果存在，就对它进行Function接口指定的操作，如果不存在就不做

重要的一点是 Optional 不是 Serializable。因此，它不应该用作类的字段。

 Jackson 库支持把 Optional 当作普通对象。也就是说，Jackson 会把空对象看作 null，而有值的对象则把其值看作对应域的值。