lambda

jiezi

5 年前

lambda 表达式是一个代码块，并且可以执行很多次。支持函数式编程。

我们之前说 lambda 表达式是函数式编程，我们学习 lambda 可以当做一个函数来进行对比去学习。

语法如下：

 参数 -> 表达式

具体解读

1. 参数:

如果没有有一个参数，需要提供中括号

() -> System.out.println("hello world");

如果只有一个参数，而且这个参数类型可以推导出，可以不提供中括号，也可以提供

（String first）-> return first.toString();

String first -> return first.toString();

如果可以根据上下文推导出参数的类型，则可以不提供参数类型

(first) -> return first.toString();

2. 表达式

无需指定 lambda 表达式的返回类型，lambda 表达式会根据上下文推导出

(String first, String second) -> first.length() - second.length();

方法引用

stream.map(Sysout.out::println)

构造器引用

stream.map(String::new)

变量作用域

lambda 表达式可以使用外部的变量，但是这个变量在传入过来的时候不能是变化的或者不能在内部进行变化的。

我们一直依赖传递参数都是一个对象，那么传递 lambda 表达式可不可以呢？当然可以， 但是我们不能将 lambda 表达式传递给对象

那么我怎么定义 lambda 表达式作为函数接口的方法呢？下面给出一个表提供了方式

函数式接口	参数类型	返回类型	抽象方法名	描述	其他方法
Runnable	无	void	run	作为无参数或返回值
Supplier<T>	无	T	get	提供一个 T 类型的值返回
Consumer<T>	T	void	accept	处理一个 T 类型的参数	andThen
BiConsumer<T,U>	T,U	void	accept	处理一个 T 和 U 的参数	andThen
Funtion<T,R>	T	R	apply	处理一个 T 的参数，返回一个 R 的值	compose,andThen,identity
BiFunction<T,U,R>	T,U	R	apply	处理一个 T 和 R 的参数，返回一个 R 的值	andThen
UnaryOperator<T>	T	T	apply	类型 T 上的一元操作符 ”compose,andThen,Identity
BinaryOperator<T>	T,T	T	apply	类型 T 上的二元操作符	andThen,maxBy,minBy
Predicate<T>	T	boolean	test	布尔值函数	and,or,negate,isEqual
BiPredicate<T,U>	T,U	boolean	test	有两个参数的布尔值函数	and,or,negate

流不存储其元素
流的操作不会修改其数据源。例如，filter 方法不会从新的流中移除元素，而是会生成一个新的流，其中不包含过滤掉的流。
流的操作是尽可能惰性的。只有遇到想要的结果才会执行，完成之后流就不能操作了。

创建 Stream

-static <T> Stream<T> of(T… values)

产生一个元素为给定值的流

static <T> Stream<T> empty()

产生一个不包含任何元素的流

static <T> Stream<T> generate(Supplier<T> s)

产生一个无限流，它的值是通过反复调用函数构成

static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)

产生一个无限流，它的元素包含种子，在种子调用 f 产生的值

default Stream<E> steam()
default Stream<E> parallelStream()

产生当前集合中所有元素的顺序流或并行流

static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive)

产生一个流，元素数组里面指定的开始到结束的部分

转换 Stream

Stream<T> filter(Predicate<? super T> p)

产生一个流，其中包含满足条件 p 的所有元素

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

产生一个流，它包含将 mapper 应用于当前流中所有元素所产生的结果

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

产生一个流，它是通过将 mapper 应用于当前流中所有元素所产生的结果连接到一起得到的结果

Stream<T> limit(long maxSize)

产生一个流，它的元素是包含当前流最初 maxSize 的元素

Stream<T> skip(long n)

产生除了前 n 个元素的所有元素

Static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

将 a 和 b 的流合并

Stream<T> distinct()

产生一个没有重复元素的流

Stream<T> sorted()
Stream<T> sorted(Comparator<? super T> cpmparator)

产生按照 comparator 实现的方法排序，第一个方法要求实现 Cpmparable

void forEach(Consumer<? super T> action)

对于流的每一元素执行 action，也就是我们长做的遍历

收集 Stream

java.util.stream.Stream

long count()

产生当前流中元素的数量

Optional<T> max(Comparator<? super T> comparator)

根据 comparator 比较器得到最大的元素

Optional<T> min(Comparator<? super T> comparator)

根据 comparator 比较器得到最小的元素

Optional<T> findFirst()

找到第一个元素

Optional<T> findAny()

找到任意的元素

boolean anyMatch(Predicate<? super T> predicate)

在任意元素中根据 predicate 匹配元素返回 true

boolean allMatch(Predicate<? super T> predicate)

全部元素都根据 predicate 匹配到元素返回 true

boolean noneMatch(Predicate<? super T> predicate)

没有任何元素匹配的时候返回 true

java.util.Optional

- T orElse(T other)

如果 optional 为空的话则产生 other

T orElseGet(Supplier<? extends X> other)

如果 optional 为空的话则产生 other 的结果

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

如果 optional 为空则抛出 exceptionSupplier 的异常

void ifPresent(Consumer<? super T> consumer)

如果 optional 不为空的话则把值传给 comsumer

<R> Optional<R> map(Function<? super T, ? extends R> mapper)

如果部位空则将结果传递给 mapper，否则产生一个空的 opetional

boolean isPresent()

如果 optional 不为空则返回 true

T get()

如果不为空则返回具体的值，如果为空则剖出 NoSuchElementException 异常

创建 Optional

static <T> Optional<T> of(T value)

产生一个给定 value 值的 optional, 如果 value 为空抛出 NullPOinterException 异常

static <T> Optional<T> ofNullable(T value)

产生一个给定 value 值的 optional, 如果 value 为空则给一个空的 optional

static <T> Optional<T> empty()

产生一个空的 Optional

收集器

Object[] toArray()

将流转化为一个数组

<C> C[] toArray(IntFunction<C[]> generator)

产生一个使用构造方法生成特定对象数组

<R, A> R collect(Collector<? super T,A,R> collector)

使用给定的收集器收集元素

static <T> Collector<T,?,List<T>> toList()

将元素收集成一个 list

static <T> Collector<T,?,Set<T>> toSet()

将元素收集成一个 Set

static <T,C extends Collection<T>> collector<T,?,C> toCollection(Supplier<C> collectionFactory)

将元素收集成由 collecitonFactory 构造的方法的集合

static Collector<CharSequence,?,String> joining()
static Collector<CharSequence,?,String> joining(CharSequence delimiter)
static Colletor<CharSequence,?,String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

产生一个连接字符串的收集器。第一个方法，可以不加分隔符，第二个加了分隔符，第三个加分隔符同时可以在连接的字符串前面和最后面是否要添加字符

static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)

产生能够生成 (Int|Long|Double)SummaryStatistics 对象的收集器，通过它可以获得将 mapper 应用于每个元素所产生的结果个数，总和，平均值，最大值和最小值。

long getCount()

获取汇总后的元素个数

(int|long|double) getSum()
double getAverage()

产生汇总之后的总数和平均数，没有任何元素的时候返回 0

(int|long|double) getMax()
(int|long|double) getMIn()

返回汇总之后最大数和最小数，没有任何元素的时候产生 (Integer|Long|Double).(MAX|MIN)_VALUE

收集到 map

static<T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
static<T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction)
static<T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)

生成一个 map，keyMapper 和 valueMapper 函数对应 key 和 value, 当 key 值相同的时候抛出 IllegalStateException 异常，可以使用 mergeFunction 来合并相同键值。同时提供 mapSupplier 控制生成 map 的类型

static <T> Collector<T,?,Long> counting()
统计每一个分组的数量
static <T> Collector<T,?,Integer> summingInt(ToIntFunction<? super T> mapper)
static <T> Collector<T,?,Long> summingLong(ToLongFunction<? super T> mapper)
static <T> Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)
统计每一个分组的传递过来变量的总数
static <T> Collector<T,?,Optional<T>> maxBy(Comparator<? super T> comparator)
找出每一个分组里面的最大数，通过比较器 comparator
static <T> Collector<T,?,Optional<T>> minBy(Comparator<? super T> comparator)
找出每一个分组里面的最小数，通过比较器 comparator
static <T,U,A,R> Collector<T,?,R> mapping(Function<? super T, ? extends U> mapper, Collector<? super U,A,R> downstream)
将分组的每一个元素进行转换，然后可以进行一系列其他操作

lambda

lambda 表达式

是什么

语法

函数式接口

流（Stream）的规则

API

Optional