lambda表达式

是什么

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

语法

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

语法如下：

参数 -> 表达式

具体解读

1.参数:

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

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

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

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

String first -> return first.toString();

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

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

2.表达式

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

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

1. 方法引用

stream.map(Sysout.out::println)

1. 构造器引用

stream.map(String::new)

1. 变量作用域

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

函数式接口

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

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

流（Stream）的规则

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

API

创建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

Optional

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)找出每一个分组里面的最大数，通过比较器comparatorstatic <T> Collector<T,?,Optional<T>> minBy(Comparator<? super T> comparator)找出每一个分组里面的最小数，通过比较器comparatorstatic <T,U,A,R> Collector<T,?,R> mapping(Function<? super T, ? extends U> mapper, Collector<? super U,A,R> downstream)将分组的每一个元素进行转换，然后可以进行一系列其他操作