lambda表达式过滤、链式编程、函数式接口、Stream流式计算

什么是stream流式计算

java.util.stream
Interface Stream
编程大部分都是存储和计算，存储用数据结构去存，计算交给stream流去计算(包括排序、过滤数据等)，分工明确。

Demo

package juc;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.Arrays;
import java.util.List;

/**
 * 一行代码完成：
 * 筛选出：
 * 1.ID为偶数
 * 2.年龄大于23
 * 3.用户名转为大写字母
 * 4.用户名字母到排序
 * 5.只输出一个用户
 */
public class TestStream {
    public static void main(String[] args) {
        User user1 = new User(12, "a", 20);
        User user2 = new User(13, "b", 21);
        User user3 = new User(14, "c", 26);
        User user4 = new User(15, "d", 23);
        User user5 = new User(16, "e", 24);
        //集合只做存储
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);

        //计算交给stream流
        //lambda表达式、链式编程、函数式接口、Stream流式计算
        list.stream()
                .filter(user -> {return user.getId() % 2 == 0;})//user代表形参，代指User对象
                .filter(user -> {return user.getAge() > 23;})
                .map(user -> {return user.getName().toUpperCase();})//map可以用来转换，里面是Function函数式接口，这里之后，返回值不再是User对象，而是字符串了
                .sorted((str1,str2)->{return str1.compareTo(str2);})//Stream sorted(Comparator comparator);
                .limit(1)//只输出一个
                .forEach(System.out::println);//::传的是方法，System.out::println打印的是传入的参数，也就是Consumer的参数泛型T，这个T就是从list的流对象获取的T，最终都是list对象创建时指定的泛型
    }
}

@Data
@AllArgsConstructor
class User {
    private int id;
    private String name;
    private int age;
}

Stream方法

Modifier and Type	Method and Description
boolean	allMatch(Predicate predicate) 返回此流的所有元素是否与提供的谓词匹配。
boolean	anyMatch(Predicate predicate) 返回此流的任何元素是否与提供的谓词匹配。
static < T > Stream.Builder< T >	builder() 返回一个 Stream的构建器。
R	collect(Collector collector) 使用 Collector对此流的元素执行 mutable reduction Collector 。
< R > R	collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) 对此流的元素执行 mutable reduction操作。
static < T > Stream< T >	concat(Stream a, Stream b) 创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
long	count() 返回此流中的元素数。
Stream< T >	distinct() 返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。
static < T > Stream< T >	empty() 返回一个空的顺序 Stream 。
Stream< T >	filter(Predicate predicate) 返回由与此给定谓词匹配的此流的元素组成的流。
Optional< T >	findAny() 返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional 。
Optional< T >	findFirst() 返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional 。
< R > Stream< R >	flatMap(Function> mapper) 返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。
DoubleStream	flatMapToDouble(Function mapper) 返回一个 DoubleStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
IntStream	flatMapToInt(Function mapper) 返回一个 IntStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
LongStream	flatMapToLong(Function mapper) 返回一个 LongStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
void	forEach(Consumer action) 对此流的每个元素执行操作。
void	forEachOrdered(Consumer action) 如果流具有定义的遇到顺序，则以流的遇到顺序对该流的每个元素执行操作。
static < T > Stream< T >	generate(Supplier< T > s) 返回无限顺序无序流，其中每个元素由提供的 Supplier 。
static < T > Stream< T >	iterate(T seed, UnaryOperator f) 返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ，产生 Stream包括 seed ， f(seed) ， f(f(seed)) ，等
Stream< T >	limit(long maxSize) 返回由此流的元素组成的流，截短长度不能超过 maxSize 。
< R > Stream< R >	map(Function mapper) 返回由给定函数应用于此流的元素的结果组成的流。
DoubleStream	mapToDouble(ToDoubleFunction mapper) 返回一个 DoubleStream ，其中包含将给定函数应用于此流的元素的结果。
IntStream	mapToInt(ToIntFunction mapper) 返回一个 IntStream ，其中包含将给定函数应用于此流的元素的结果。
LongStream	mapToLong(ToLongFunction mapper) 返回一个 LongStream ，其中包含将给定函数应用于此流的元素的结果。
Optional< T >	max(Comparator comparator) 根据提供的 Comparator返回此流的最大元素。
Optional< T >	min(Comparator comparator) 根据提供的 Comparator返回此流的最小元素。
boolean	noneMatch(Predicate predicate) 返回此流的元素是否与提供的谓词匹配。
static < T > Stream< T >	of(T… values) 返回其元素是指定值的顺序排序流。
static < T > Stream< T >	of(T t) 返回包含单个元素的顺序 Stream 。
Stream< T >	peek(Consumer action) 返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。
Optional< T >	reduce(BinaryOperator accumulator) 使用 associative累积函数对此流的元素执行 reduction ，并返回描述减小值的 Optional （如果有）。
T	reduce(T identity, BinaryOperator accumulator) 使用提供的身份值和 associative累积功能对此流的元素执行 reduction ，并返回减小的值。
< U > U	reduce(U identity, BiFunction accumulator, BinaryOperator combiner) 执行 reduction在此流中的元素，使用所提供的身份，积累和组合功能。
Stream< T >	skip(long n) 在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流。
Stream< T >	sorted() 返回由此流的元素组成的流，根据自然顺序排序。
Stream< T >	sorted(Comparator comparator) 返回由该流的元素组成的流，根据提供的 Comparator进行排序。
Object[]	toArray() 返回一个包含此流的元素的数组。
< A > A[]	toArray(IntFunction generator) 使用提供的 generator函数返回一个包含此流的元素的数组，以分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。

方法详细信息

filter

Stream filter(Predicate predicate)返回由与此给定谓词匹配的此流的元素组成的流。
这是一个intermediate operation 。

参数
predicate -一个 non-interfering ， stateless谓词应用到每个元素，以确定是否它应包含
结果
新的流

map

Stream map(Function mapper)返回由给定函数应用于此流的元素的结果组成的流。
这是一个intermediate operation 。

参数类型
R - 新流的元素类型
参数
mapper -一个 non-interfering ， stateless函数应用到每个元件
结果
新的流

mapToInt

IntStream mapToInt(ToIntFunction mapper)返回一个IntStream ，其中包含将给定函数应用于此流的元素的结果。
这是一个intermediate operation 。

参数
mapper -一个 non-interfering ， stateless函数应用到每个元件
结果
新的流

mapToLong

LongStream mapToLong(ToLongFunction mapper)返回一个LongStream ，其中包含将给定函数应用于此流的元素的结果。
这是一个intermediate operation 。

参数
mapper -一个 non-interfering ， stateless函数应用到每个元件
结果
新的流

mapToDouble

DoubleStream mapToDouble(ToDoubleFunction mapper)返回一个DoubleStream ，其中包含将给定函数应用于此流的元素的结果。
这是一个intermediate operation 。

参数
mapper -一个 non-interfering ， stateless函数应用到每个元件
结果
新的流

flatMap

Stream flatMap(Function> mapper)返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。 每个映射的流在其内容被放入此流之后是closed 。 （如果映射的流是null则使用空的流）。
这是一个intermediate operation 。

API Note:
flatMap()操作具有对流的元素应用一对多变换，然后将所得到的元素平坦化为新流的效果。
例子。

如果orders是采购订单流，并且每个采购订单都包含订单项的集合，则以下生成包含所有订单中所有订单项的流：

orders.flatMap(order -> order.getLineItems().stream())… 如果path是路径到一个文件，那么下面产生的气流words包含在该文件中：

Stream lines = Files.lines(path, StandardCharsets.UTF_8); Stream words = lines.flatMap(line -> Stream.of(line.split(" +"))); 传递给flatMap的mapper函数将一行（使用简单的正则表达式）分割成一个单词数组，然后从该数组中创建一个单词。
参数类型
R - 新流的元素类型
参数
mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素
结果
新的流

flatMapToInt

IntStream flatMapToInt(Function mapper)返回一个IntStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。 每个映射的流在其内容被放入此流之后是closed 。 （如果映射的流为null则使用空的流。）
这是一个intermediate operation 。

参数
mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素
结果
新的流

flatMapToLong

LongStream flatMapToLong(Function mapper)返回一个LongStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。 每个映射的流在其内容被放入此流之后为closed 。 （如果映射的流为null则使用空的流。）
这是一个intermediate operation 。

参数
mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素
结果
新的流

flatMapToDouble

DoubleStream flatMapToDouble(Function mapper)返回一个DoubleStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。 每个映射的流是closed ，其内容已经放入此流中。 （如果映射的流是null则使用空的流。）
这是一个intermediate operation 。

参数
mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素
结果
新的流

distinct

Stream distinct()返回由该流的不同元素（根据Object.equals(Object) ）组成的流。
对于有序流，选择不同的元素是稳定的（对于重复的元素，首先在遇到顺序中出现的元素被保留。）对于无序流，不能保证稳定性。

这是一个stateful intermediate operation 。

API Note:
保存稳定性为distinct()在并行管线是相对昂贵的（要求操作充当一个完整屏障，具有大量缓冲的开销）通常不需要的，和稳定性。 使用无序流源（如generate(Supplier) ）或具有除去排序约束BaseStream.unordered()可导致显著更高效的执行为distinct()在并行管线，如果情况许可的语义。 如果需要与遇到顺序一致， distinct()在并行流水线中使用distinct()您的性能或内存利用率不佳，则使用BaseStream.sequential()切换到顺序执行可能会提高性能。
结果
新的流

sorted

Stream sorted()返回由此流的元素组成的流，根据自然顺序排序。 如果该流的元件不是Comparable ，一个java.lang.ClassCastException执行终端操作时，可以抛出。
对于有序流，排序稳定。 对于无序的流，不能保证稳定性。

这是一个stateful intermediate operation 。

结果
新的流

sorted

Stream sorted(Comparator comparator)返回由该流的元素组成的流，根据提供的Comparator进行排序。
对于有序流，排序稳定。 对于无序的流，不能保证稳定性。

这是一个stateful intermediate operation 。

参数
comparator -一个 non-interfering ， stateless Comparator被用于比较流元素
结果
新的流

peek

Stream peek(Consumer action)返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。
这是一个intermediate operation 。

对于并行流管线，可以在上游操作的任何时间和任何线程中调用该元素可用的动作。 如果操作修改共享状态，则负责提供所需的同步。

API Note:
该方法主要用于支持调试，您希望在流程中流过某个特定点时查看元素：
Stream.of(“one”, “two”, “three”, “four”) .filter(e -> e.length() > 3) .peek(e -> System.out.println("Filtered value: " + e)) .map(String::toUpperCase) .peek(e -> System.out.println("Mapped value: " + e)) .collect(Collectors.toList()); 参数
action - 一个 88466851784848要从流中消耗的元素上执行的操作
结果
新的流

limit

Stream limit(long maxSize)返回由该流的元素组成的流，截断长度不能超过maxSize 。
这是一个short-circuiting stateful intermediate operation 。

API Note:
虽然limit()通常是在连续的流管道的廉价的操作，它可以是订购的并行管线相当昂贵的，特别是对于大的值maxSize ，由于limit(n)被约束返回不是任何n个元素，但在遭遇顺序中的第n个元素。 使用无序流源（如generate(Supplier) ）或去除所述排序约束与BaseStream.unordered()可导致显著加速比limit()在并行管线，如果情况许可的语义。 如果需要与遇到顺序一致， limit()在并行流水线中遇到limit()的性能下降或内存利用率下降，则使用BaseStream.sequential()切换到顺序执行可能会提高性能。
参数
maxSize - 流应该限制的元素数量
结果
新的流
异常
IllegalArgumentException - 如果 maxSize为负数

skip

Stream skip(long n)在丢弃流的第一个n元素后，返回由该流的n元素组成的流。 如果此流包含少于n元素，那么将返回一个空流。
这是一个stateful intermediate operation 。

API Note:
虽然skip()通常是在连续的流管道的廉价的操作，它可以是订购的并行管线相当昂贵的，特别是对于大的值n ，由于skip(n)被约束为跳过不是任何n个元素，但在遭遇顺序中的第n个元素。 使用无序流源（如generate(Supplier) ）或去除所述排序约束与BaseStream.unordered()可导致显著加速比skip()在并行管线，如果情况许可的语义。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与skip()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。
参数
n - 要跳过的主要元素的数量
结果
新的流
异常
IllegalArgumentException - 如果 n为负数

forEach

void forEach(Consumer action)对此流的每个元素执行操作。
这是一个terminal operation 。

这个操作的行为显然是不确定的。 对于并行流管道，此操作不保证遵守流的遇到顺序，因为这样做将牺牲并行性的好处。 对于任何给定的元素，动作可以在图书馆选择的任何时间和任何线索中执行。 如果操作访问共享状态，则负责提供所需的同步。

参数
action - 一个 non-interfering对元素执行的动作

forEachOrdered

void forEachOrdered(Consumer action)如果流具有定义的遇到顺序，则以流的遇到顺序对该流的每个元素执行操作。
这是一个terminal operation 。

此操作一次处理元素，如果存在，则按照遇到的顺序进行处理。 执行一个元素happens-before执行后续元素的操作的操作，但对于任何给定的元素，该操作可以在库选择的任何线程中执行。

参数
action - 一个 non-interfering对元素执行的动作

toArray

Object[] toArray()返回一个包含此流的元素的数组。
这是一个terminal operation 。

结果
一个包含此流的元素的数组
toArray
< A > A[] toArray(IntFunction generator)使用提供的generator函数返回包含此流的元素的数组，以分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。
这是一个terminal operation 。

API Note:
发生器函数采用一个整数，它是所需数组的大小，并产生一个所需大小的数组。 这可以用数组构造函数引用简明扼要地表达：
Person[] men = people.stream() .filter(p -> p.getGender() == MALE) .toArray(Person[]::new); 参数类型
A - 结果数组的元素类型
参数
generator - 产生所需类型和所提供长度的新数组的函数
结果
一个包含此流中的元素的数组
异常
ArrayStoreException - 如果从数组生成器返回的数组的运行时类型不是此流中每个元素的运行时类型的超类型

reduce

T reduce(T identity,
BinaryOperator accumulator)使用提供的身份值和associative累积功能对此流的元素执行reduction ，并返回减小的值。 这相当于：
T result = identity; for (T element : this stream) result = accumulator.apply(result, element) return result; 但不限于顺序执行。
identity值必须是累加器函数的标识。 这意味着，对于所有t ， accumulator.apply(identity, t)等于t 。 accumulator功能必须是associative功能。

这是一个terminal operation 。

API Note:
总和，最小，最大，平均和字符串连接都是减少的特殊情况。 一个数字流可以表示为：
Integer sum = integers.reduce(0, (a, b) -> a+b); 要么：
Integer sum = integers.reduce(0, Integer::sum); 尽管与简单地将循环中的总体变量相比，这可能看起来更为迂回的方式进行，但减少操作更平稳地并行化，而不需要额外的同步，并大大降低了数据竞争的风险。

参数
identity - 累积函数的身份值
accumulator -一个 associative ， non-interfering ， stateless功能组合两个值
结果
减少的结果

reduce

Optional reduce(BinaryOperator accumulator)使用associative累积函数对此流的元素执行reduction ，并返回描述减小值（如果有的话）的Optional 。 这相当于：
boolean foundAny = false; T result = null; for (T element : this stream) { if (!foundAny) { foundAny = true; result = element; } else result = accumulator.apply(result, element); } return foundAny ? Optional.of(result) : Optional.empty(); 但不限于顺序执行。
accumulator功能必须是associative功能。

这是一个terminal operation 。

参数
accumulator -一个 associative ， non-interfering ， stateless功能组合两个值
结果
一个Optional描述了减少的结果
异常
NullPointerException - 如果减少的结果为空
另请参见：
reduce(Object, BinaryOperator) ， min(Comparator) ， max(Comparator)
reduce
U reduce(U identity,
BiFunction accumulator,
BinaryOperator combiner)执行reduction在此流中的元素，使用所提供的身份，积累和组合功能。 这相当于：
U result = identity; for (T element : this stream) result = accumulator.apply(result, element) return result; 但不限于顺序执行。
identity值必须是组合器功能的标识。 这意味着，对于所有u ， combiner(identity, u)等于u 。 另外combiner功能必须兼容accumulator功能; 对于所有u和t ，以下必须保持：

combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t) 这是一个terminal operation 。

API Note:
通过map和reduce操作的明确组合，可以更简单地表示使用此表单的许多裁减。 accumulator函数充当融合映射器和累加器，这有时比单独的映射和还原更有效，例如当知道先前减少的值允许您避免某些计算时。
参数类型
U - 结果的类型
参数
identity - 组合器功能的标识值
accumulator -一个 associative ， non-interfering ， stateless功能用于将一个额外的元件到结果
combiner -一个 associative ， non-interfering ， stateless功能用于组合两个值，它必须与蓄能器功能兼容
结果
减少的结果

collect

R collect(Supplier supplier,
BiConsumer accumulator,
BiConsumer combiner)对此流的元素执行mutable reduction操作。 可变减少是减少值是可变结果容器的缩减值，例如ArrayList ，并且通过更新结果的状态而不是通过替换结果来合并元素。 这产生的结果相当于：
R result = supplier.get(); for (T element : this stream) accumulator.accept(result, element); return result; 像reduce(Object, BinaryOperator)一样 ， collect操作可以并行化，而不需要额外的同步。

这是一个terminal operation 。

API Note:
JDK中有许多现有的类，其签名非常适合用作参考的方法引用到collect() 。 例如，以下将会将字符串累加到一个ArrayList ：
List asList = stringStream.collect(ArrayList::new, ArrayList::add, ArrayList::addAll); 以下将使用一串字符串并将它们连接成一个字符串：

String concat = stringStream.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append) .toString(); 参数类型
R - 结果的类型
参数
supplier - 创建新结果容器的函数。 对于并行执行，可以多次调用此函数，并且每次都必须返回一个新的值。
accumulator -一个 associative ， non-interfering ， stateless功能用于将一个额外的元件到结果
combiner -一个 associative ， non-interfering ， stateless功能用于组合两个值，它必须与蓄能器功能兼容
结果
减少的结果

collect

R collect(Collector collector)使用Collector对此流的元素执行mutable reduction Collector 。 A Collector将用作参数的函数封装到collect(Supplier, BiConsumer, BiConsumer) ，允许重用集合策略和组合收集操作（如多级分组或分区）。
如果流是并行的，并且Collector是concurrent ，并且流是无序的或收集器是unordered ，则将执行并发的减少（有关并发减少的细节，请参阅Collector ）。

这是一个terminal operation 。

当并行执行时，可以实例化，填充和合并多个中间结果，以便保持可变数据结构的隔离。 因此，即使与非线程安全的数据结构（例如ArrayList ）并行执行，并行还原也不需要额外的同步。

API Note:
以下将将字符串累加到ArrayList中：
List asList = stringStream.collect(Collectors.toList()); 以下将按城市分类Person对象：

Map peopleByCity = personStream.collect(Collectors.groupingBy(Person::getCity)); 以下将按国家和城市对Person对象进行分类，将两个Collector组合在一起：

Map> peopleByStateAndCity = personStream.collect(Collectors.groupingBy(Person::getState, Collectors.groupingBy(Person::getCity))); 参数类型
R - 结果的类型
A - 中间累积类型的 Collector
参数
collector - Collector减少的Collector
结果
减少的结果

min

Optional min(Comparator comparator)根据提供的Comparator返回此流的最小元素。 这是一个reduction的特例 。
这是一个terminal operation 。

参数
comparator -一个 non-interfering ， stateless Comparator比较该流的元素
结果
一个 Optional此流的最小元素的 Optional如果流为空， Optional
异常
NullPointerException - 如果最小元素为空

max

Optional max(Comparator comparator)根据提供的Comparator返回此流的最大元素。 这是一个reduction的特殊情况。
这是一个terminal operation 。

参数
comparator -一个 non-interfering ， stateless Comparator比较该流的元素
结果
一个 Optional此流的最大元素的 Optional如果流为空， Optional
异常
NullPointerException - 如果最大元素为空

count

long count()返回此流中的元素数。 这是一个reduction的特殊情况，相当于：
return mapToLong(e -> 1L).sum(); 这是一个terminal operation 。

结果
这个流中元素的数量

anyMatch

boolean anyMatch(Predicate predicate)返回此流的任何元素是否与提供的谓词匹配。 如果不需要确定结果，则不能评估所有元素上的谓词。 如果流为空，则false返回和谓语不评估。
这是一个short-circuiting terminal operation 。

API Note:
该方法评估了流的元素（对于某些x P（x））的 谓词的存在量化。
参数
predicate -一个 non-interfering ， stateless谓词适用于该流的元素
结果
true如果流的任何元素匹配提供的谓词，否则为 false
allMatch
boolean allMatch(Predicate predicate)返回此流的所有元素是否与提供的谓词匹配。 如果不需要确定结果，则不能评估所有元素上的谓词。 如果流为空，则true返回和谓语不评估。
这是一个short-circuiting terminal operation 。

API Note:
该方法评估了流的元素（对于所有x P（x））的谓词的通用量化 。 如果流是空的，量化据说是空洞地满意 ，始终是true （不管的P（X））。
参数
predicate - a non-interfering，stateless 谓词适用于此流的元素
结果
true如果流的所有元素匹配提供的谓词或流是空的，否则 false

noneMatch

boolean noneMatch(Predicate predicate)返回此流的元素是否与提供的谓词匹配。 如果不需要确定结果，则不能评估所有元素上的谓词。 如果流为空，则true返回和谓语不评估。
这是一个short-circuiting terminal operation 。

API Note:
此方法评估通过该流中的元素的否定谓词的通用定量 （对于所有的x〜P（X））。 如果流是空的，那么量化被认为是空白的，并且始终是true ，不论P（x）如何。
参数
predicate -一个 non-interfering ， stateless谓词适用于该流的元素
结果
true如果流中没有元素匹配提供的谓词或流是空的，否则 false

findFirst

Optional findFirst()返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional 。 如果流没有遇到顺序，则可能会返回任何元素。
这是一个short-circuiting terminal operation 。

结果
一个 Optional此流的第一个元素的 Optional如果流为空， Optional
异常
NullPointerException - 如果选择的元素为空

findAny

Optional findAny()返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional 。
这是一个short-circuiting terminal operation 。

这个操作的行为显然是不确定的; 可以自由选择流中的任何元素。 这是为了允许并行操作中的最大性能; 成本是同一来源上的多次调用可能不会返回相同的结果。 （如果需要稳定的结果，请改用findFirst() ）

结果
一个 Optional此流的某些元素的 Optional如果流为空， Optional
异常
NullPointerException - 如果选择的元素为空

builder

static Stream.Builder builder()返回一个 Stream的生成器。
参数类型
T - 元素的类型
结果
流构建器

empty

static Stream empty()返回一个空的顺序 Stream 。
参数类型
T - 流元素的类型
结果
一个空的顺序流

of

static Stream of(T t)返回包含单个元素的顺序 Stream 。
参数类型
T - 流元素的类型
参数
t - 单一元素
结果
单例顺序流

of

@SafeVarargs
static Stream of(T… values)返回其元素是指定值的顺序排序流。
参数类型
T - 流元素的类型
参数
values - 新流的元素
结果
新的流

iterate

static Stream iterate(T seed,
UnaryOperator f)返回有序无限连续Stream由函数的迭代应用产生f至初始元素seed ，产生Stream包括seed ， f(seed) ， f(f(seed)) ，等
第一元件（位置0在） Stream将是提供seed 。 对于n > 0 ，位置n的元素将是将函数f应用于位置n - 1的元素的n - 1 。

参数类型
T - 流元素的类型
参数
seed - 初始元素
f - 要应用于前一个元素以生成新元素的函数
结果
一个新的顺序 Stream

generate

static Stream generate(Supplier s)返回无限顺序无序流，其中每个元素由提供的Supplier 。 这适合于产生恒定流，随机元素流等
参数类型
T - 流元素的类型
参数
s -所述 Supplier生成的元素的
结果
一个新的无限顺序无序 Stream

concat

static Stream concat(Stream a,
Stream b)创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。 如果两个输入流都被排序，则生成的流被排序，并且如果任何一个输入流是并行的，则并行。 当结果流关闭时，调用两个输入流的关闭处理程序。
Implementation Note:
在重复连接构建流时要小心。 访问深度级联的流的元素可能导致深层呼叫链，甚至可能导致StackOverflowException 。
参数类型
T - 流元素的类型
参数
a - 第一个流
b - 第二个流
结果
两个输入流的并置