Stream基础知识

时间 2019-12-10

标签 stream 基础知识栏目 Apache 繁體版

原文原文链接

Stream API

Stream是Java8中处理集合的关键抽象概念，它能够指定你但愿对集合进行的操做，可是将执行操做的时间交给具体实现来决定。例如，若是你但愿计算某个方法的平均值，你能够在每一个元素上指定调用的方法，从而得到全部值的平均值。你可使用Stream API来并行执行操做，使用过多线程来计算每一段的总和与数量，再将结果汇总起来。正则表达式

一个Stream表面上看与一个集合很相似，容许你改变和获取数据。可是实际上它与集合是有很大区别的：数组

Stream本身不会存储元素。元素可能被存储在底层的集合中，或者根据须要产生出来。
Stream操做符不会改变源对象。相反，它们会返回一个持有结果的新Stream。
Stream操做符多是延迟执行的。这意味者它们会等到须要结果的时候才执行。例如你只想要前5个长单词，而不须要统计全部长字符，那么filter方法将会在5次匹配后中止过滤。所以，甚至能够有无限的Stream。

List<String> words = ...;
//Java8在Collection接口中新添加的stream方法，能够将任何集合转化为一个Stream
long count = words.stream().filter(w -> w.length() > 12).count();

//将stream方法改为parallel Stream方法，就可让StreamAPI并行执行过滤和统计操做。
long count = words.vStream().filter(w -> w.length() > 12).count();

Stream遵循“作什么，而不是怎么去作”的原则。上面的代码中，描述了须要作什么：获的长单词并对它们的个数进行统计。咱们没有制定按照什么顺序，或者在哪一个线程中作，它们都是理所应当发生的。相反，循环在一开始就须要指定如何进行运算，所以就是去了优化的机会。
当你使用Stream时，你会经过三个阶段来创建一个操做流水线。安全

建立一个Stream
在一个或多个步骤中，指定将初始Stream转换为另外一个Stream的中间操做。
使用一个终止操做来产生一个结果。该操做会强制它以前的延迟操做当即执行。在这以后，该Stream就不会再被使用了。

在上面的代码中，经过stream或parallelStream方法来建立Stream，在经过filter方法对其进行转换，而count方法就是终止操做。多线程

建立Stream

Java8在Collection接口中新添加的stream方法，能够将任何集合转化为一个Stream并发
若是是一个数组，能够用静态的Stream.of方法将它转化为一个Stream;若是须要将数组的一部分转化为Stream，可使用Arrays.stream()dom
```
 Stream<String> words = Stream.of(String[] array);
 Stream<String> words = Stream.of(String ...args);
 Stream<String> words = Arrays.stream(array, from, to);
```
要建立一个不含任何元素的Stream，可使用静态的Stream.empty()ide
建立无限Stream的静态方法。函数
- generate方法接受一个无参的函数(从技术上说，是一个Supplier <T>接口的对象)。当须要一个Stream值时，就能够调用该方法来产生一个值。优化
```
Stream<String> echos = Stream.generate( () -> "Echo");//建立一个含有常量值的Stream
Stream<Double> randoms = Stream.generate( Math::random );
```
- iteratre方法接受一个"种子(seed)"值和一个函数(从技术上讲，是一个UnaryOperator<T>接口的对象)做为参数，而且会对以前的值重复应用该函数。例如：ui
```
Stream<BigInterger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInter.ONE));
```
  在Java8中，添加了许多可以产生Stream的方法。例如，Pattern类添加了一个splitAsStream的方法，可以按照正则表达式对CharSequence(接口，String、StringBuilder和StringBuffer都实现该接口)对象进行分隔。
```
Stream<String> words = Pattern.compile(",").splitAsStream("abc,def");
```

Stream的转换

Stream转换是指从一个流中读取数据，并将转换后的数据写入另外一流中。

filter、map、flatMap方法
- filter()
  filter方法的参数是一个Predicate<T>对象——即一个从T到Boolean的函数。
```
List<String> wordList = ...;
Stream<String> words = wordList.stream();
Stream<String> longWOrds = words.filter(w -> w.length() > 12);
```
- map()
  咱们常常须要对一个流中的值进行某种形式的转换。这时能够考虑使用map方法，并传递给它一个执行转换的函数。例如
```
//使用了带有一个方法引用的map方法
Stream<String> lovercaseWords = words.map(String::toLowerCase);
//一般会使用一个lambda表达式来代替方法表达式
Stream<Character> firstChars = words.map(s -> charAt(0)); //该方法产生的流会包含每一个单词的第一个字符
```
- flatMap()
  假设如今有一个函数，以下：
```
public static Stream<Character> characterStream(String s) {
    List<Character> result = new ArrayList<>();
    for (char c : s.toCharArray()) result.add(c);
    return result.stream();
}        
```
  调用该方法，如characterStream("boat")会返回流['b', 'o', 'a', 't']。假设将该方法映射到一个字符串流上：
  Stream<Stream<Character>> result = words.mapo(w -> characterStream(w));
  将会获得一个包含多个流的流，如：[..., ['b', 'o', 'a', 't'], ...]。若是要将其展开为一个只包含字符串的流[..., 'b', 'o', 'a', 't', ...]，则须要使用flatMap方法，而不是map方法：
```
Stream<Character> letters = words.flatMap(w -> characterStream(w));
```
提取子流和组合流
- limit()
  Stream.limit(n)会返回一个包含n个元素的新流(若是原始长度小于m，则返回原始的流)。这个方法特别适用于裁剪指定长度的流。例如产生一个包含100个随机数字的流：
```
Stream<Double> randoms = Stream.generate(Math::random).limit(100);
```
- skip()
  Stream.skip(n)正好相反，它会丢掉前面的n个元素。
```
Stream<String> words = Stream.of("abc", "cdf","ghi").skip(1); //会丢弃掉"abc"
```
- concat()
  Stream.concat(Stream, Stream)将两个流链接到一块儿：
```
Stream<Character> combined = Stream.concat(Stream.of('H', 'e', 'l', 'l', 'o'), Stream.of('W', 'o', 'r', 'l', 'd'));
//产生一个新流['H', 'e', 'l', 'l', 'o'，'W', 'o', 'r', 'l', 'd']
```
  注意，第一个流的长度不该该是无限的，不然第二个流旧永远没有机会被添加到第一个流后面。
有状态的转换
以前介绍的流转换都是无状态的，即当从一个已过滤或已映射的流中获取某个元素时，结果并不依赖以前的元素。除此以外，Java8也提供了有状态的转换。
- distinct()
  distinct方法会根据原始流中的元素返回一个具备相同顺序、抑制了重复元素的新流。显然，该流必须记住以前已读取的元素。
```
Stream<String> uniqueWords = Stream.of("merrily", "merrily", "gently").distinct();
// 只获取一个"merrily"
```
- sorted()
  sorted方法必须遍历整个流，并在产生任何元素以前对它进行排序。显然，没法对一个无限流进行排序。
```
Stream<String> longestFirst = words.sorted(Comparator.comparing(String::length).reversed());
```

Stream终止操做

前面已经了解任何创###Stream终止操做建流和转换流，接下来将介绍：如何从数据流数据中找到“答案”。

聚合方法
在本节中介绍的方法统称聚合方法。它们将流聚合为一个值，以便在程序中使用。聚合方法都是终止操做。当一个流应用了终止操做后，它就不能再应用其它操做了。
- count()
  返回流中元素总数。
```
long count = Stream.of("abc", "bcd", "cde").count(); //count的结果为 3。
```
- max(), min()
  max方法返回流中最大值。min方法返回流中最小值。
  须要注意的是，它们返回的是一个Optional<T>值，它可能会封装返回值，也可能表示没有返回(当流为空时)。之前在这种状况一般会返回null，程序拿到该返回值后，进行下一步操做，可能会致使抛出空指针异常。在Java8中，Optional类型时一种更好的表示缺乏返回值的方式。
  下面是一个如何得到最大值的示例：
```
Optional<String> largest = Stream.of("abc", "bcd", "cde").max(String::compareToIgnoreCase);
if (largest.isPresent())
    System.out.println("largest: " + largest.get());
```
- findFirst(), findAny()
  findFirst方法会返回非空集合中的第一个值(一般与filter方法结合使用)；若是想找到全部匹配的元素中的任意一个，那么可使用findAny方法，这个方法在对流进行并行执行时十分有效，由于只要在任何片断中发现第一个匹配元素，都会结束整个计算。
```
Optional<String> startsWithQ = Stream.of("abc", Qabc1", "bcd", "Qabc2").parallel().filter(s -> s.startWith("Q")).findAny();
```
- allMatch(), anyMatch()
  allMatch方法和anyMatch方法，它们分别在全部元素和没有元素匹配predicate时返回true。虽然这些方法老是会检查整个流，可是仍能够经过并行执行来提升速度。
Optional类型
Optional<T>对象或者是对一个对象的封装，或者表示不是任何对象。它通常比指向T类型的引用更安全，由于它不会反回null。
若是存在被封装的对象，那么get方法会返回该对象，不然会返回一个NoSuchElementException。所以，
```
Optional<T> optionalValue = ...;
optionalValue.get().someMethod();
```
并不比下面的方式更安全：
```
T value = ...;
value.someMethod();
```
isPresent方法会反映出一个Optional<T>对象是否有值。一样的：
```
if (optionalValue.isPresent()) optionalValue.get().someMethod();
```
并不比下面的方式更简单：
```
if (value != null) value.someMethod();
```
下面开始了解如何真正使用Optional值。
- 使用Optional
  高效使用Optional的关键在于，使用一个或者接受正确值、或者返回另外一个替代值的方法。
  - ifPresent()
    ifPresent方法能够接受一个函数。若是存在可选值，那么它会将该值传递给函数，不然不会进行任何操做。例如，若是但愿在当有值存在时将它添加到一个集合中，能够调用：
```
optionalValue.ifPresent(v -> results.add(v));
```
    //或者
```
optionalValue.ifPresent(results::add);
```
  - map()
    当调用ifPresent方法时，不会反回任何值。若是你但愿对结果进行处理，可使用map方法。
```
Optional<Boolean> added = optionalValue.map(results::add);
```
    由于results.add()返回值是boolean类型，如今added有多是如下三种值：被封装到Optional中的true或者false，或者是一个空的可选值。
  - orElse()
    已经了解了当一个可选值存在时应该如何对它优雅地进行处理。另外一种使用可选值的方式是，当没有值存在时，产生一个替代值。一般，当没有可匹配项时，会但愿使用一个默认值，例如一个空字符串：
```
String result = optionalString.orElse("");
// 若是封装的字符串为空的话，则使用给定的空字符串""
```
  - orElseGet()
    当没有值存在时，还能够调用代码来计算
```
String result = optionalString.orElseGet(() -> System.getProperty("user.dir"));
```
  - orElseThrow()
    当没有值存在时，会抛出一个指定的异常。
```
String result = optionalString.orElseThrow(NoSuchElementException::new);
//须要提供一个产生异常对象的方法
```
- 建立可选值
  以前已经讨论了如何处理一个已存在的Optional对象。接下来讲明如何建立一个Optional对象。
  - Optional.of(obj),Optional.empty()
    of方法建立一个封装了obj的Optional对象，empty方法建立一个”空"的Optional对象。
  - Optional.ofNullable()
    ofNullable方法被设计为null值和可选值之间的一座桥梁。若是obj不为null，那么Optional.ofNullable(obj)会返回Optional.of(obj)，不然会返回Optional.empty()。
- 使用flatMap来组合可选值函数
  -- 暂略
聚合操做
略
收集结果
当你处理完流以后，一般只是想看一下结果，而不是将它们聚合为一个值。
- iterator()
  该方法会生成一个传统风格的迭代器，用于访问元素。
- toArray()
  因为没法在运行时建立一个泛型数组，因此表达式stream.toArray()会返回一个Object[]数组。若是但愿获得一个正确类型的数组，能够将类型传递给数组的构造函数：
```
String[] result = String.of("abc", "bcd", "cde").toArray(String[]::new);
```
- collect()
  - collect(Supplier, BiConsumer, BiConsumer)
    该方法接收三个参数：
    1. 一个能建立目标类型实例的方法，例如HashSet的构造方法
    2. 一个将元素添加到目标中的方法，例如一个add方法
    3. 一个将两个对象整合到一块儿的方法，例如addAll方法
  下面是如何使用HashSet的collect方法的示例：
```
HashSet<String> result = String.of("abc", "bcd", "abc").collect(HashSet::new, HashSet::add, HashSet::addAll);
```
  - collect(Collector)
    上面介绍了须要接收三个参数的collect方法，在实际中，并不须要这么作，由于Collector接口已经为咱们提供了这三个方法，而且Collectors类还为经常使用的手机类型提供了各个工厂方法。
    要将一个流收集到一个list或者set中，只须要调用：
```
List<String> result = String.of("abc", "bcd").collect(Collectors.toList());
Set<String> result = String.of("abc", "bcd", "abc").collect(Collectors.toSet());
```
    若是但愿控制获得的set类型，可使用以下方式：
```
TreeSet<String> result = String.of("abc", "bcd", "abc").collect(Collectors.toCollection(TreeSet::new));
```
    假设有一个Steam<Person>对象，而且但愿将其中的元素收集到一个map中，这样随后能够经过它们的id来查找。Collectors.toMap方法有两个函数参数，分别用来生成map的键和值。例如：
```
Map<Integer, String> idToName = persons.collect(Collectors.toMap(Person::getId, Person::getName));
Map<Integer, Person> idToPerson = persons.collect(Collectors.toMap(Person::getId, Function.identity()));
```
- forEach()， forEachOrdered()
  当只要将它们打印出来，或逐个遍历它们，那么可使用forEach方法，以下：
```
Stream.of("abc", "bcd", "cdf").forEach(System.out::println);
```
  向该方法传递的函数会被应用到流中的每一个元素上。须要注意的是，在一个并行流上，要确保该函数能够被并发执行。
在一个并行流上，可能会以任意的顺序来访问元素。若是但愿按照流的顺序来执行它们，那么可使用forEachOrdered方法。

forEach方法和forEachOrdered方法都是终止操做。所以在调用它们以后，就不能再使用这个流了。若是但愿还能继续使用这个流，请使用peek方法。

其余

原始类型流
假设有一个整型数组，并将该数组收集到一个Stream<Integer>的流中，不过奖每一个证书包装成Integer对象显然是一个低效的作法，对于其余原始类型double、float、long、short、char、byte及boolean也是同样。为此，Stream API提供了IntStream和LongStream和DoubleStream三种类型，专门用来直接存储原始类型值，没必要使用包装，而Stream API设计者认为不须要为其它5种原始类型都添加对应的专门类型。

要建立一个IntStream，能够调用IntStream.of和Arrays.stream方法：
```
IntStream stream = IntStream.of(1, 3, 5, 7);
IntStream stream = Arrays.stream(values, from, to); // values是一个int[]数组
```
并行流
流使得并行计算变得容易。默认状况下，流操做会建立一个串行流，方法Collection.parallelStream()除外。parallel方法能够将任意的串行流转换为一个并行流。例如：
```
Stream<String> parallelWords = Stream.of(wordArray).parallel();
```
一个并行流，只要在终止方法执行前，流处于并行模式，那么全部延迟执行的流操做就都会被并行执行。

当并行运行流操做时，须要确保传递给并行流操做的函数都是线程安全的，应当返回与串行运行时相同的结果。很重要的一点是，这些操做都是无状态的，所以能够以任意顺序被执行。

默认状况下，从有序集合、范围值、生成器及迭代器，或者调用Stream.storted所产生的流，都是有序的。有序并不会妨碍并行，例如，当计算stream.map(fun)时，流能够被分为n段，每一段都会被并发处理。而后再按顺序将结果组合起来。

当不考虑有序时，一些操做能够更有效地并行运行。调用Stream.unordered方法能够不关心顺序。好比，能够放弃有序来加快limit方法的速度。若是只须要一个流中的任意n个元素，并不关心具体内容时，能够调用：
```
Stream<String> stream = stringStream.parallel().unordered().limit(n);
```

函数式接口
在前文中，你已经了解了许多参数为函数的操做。例如，Stream.filter方法就将一个函数做为参数，filter方法的描述以下：

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

filter方法的使用例子，以下：

Stream<String> longWords = words.filter( s -> s.length() >= 12 );
//words是一个含有多个字符串的流

查看文档能够知道，Predicate是一个接口，只含有一个返回boolean值的非默认方法：

public interface Predicate {
    boolean test(T argument);
}

在实际开发中，开发人员可能会常常传一个lambda表达式或者方法引用，因此方法名并不重要。重要的部分是返回boolean值。当查阅文档时，只须要记住Predicate是一个返回boolean值的函数就好了。

下表总结了可以做为Stream和Collectors方法参数的函数式接口。

函数式接口	参数类型	返回类型	描述
Supplier<T>	无	T	提供一个T类型的值
Consumer<T>	T	void	处理一个T类型的值
BiConsumer<T, U>	T, U	void	处理T类型和U类型的值
Predicate<T>	T	boolean	一个计算Boolean值的函数
ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>	T	int long double	分别计算int、long、double值的函数
IntFunction<R> LongFunction<R> DoubleFunction<R>	int long double	R	参数分别为int、long、double类型的函数
Function<T, R>	T	R	一个参数类型为T的函数
BiFunction<T, U, R>	T, U	R	一个参数类型为T和U的函数
UnaryOperator<T>	T	T	对类型T进行的一元操做
BinaryOperator<T>	T, T	T	对类型T进行的二元操做