Java 8-Stream API-流操作

约定不等于承诺〃 2022-05-21 06:55 298阅读 0赞

java.util.stream.Stream中的Stream接口定义了许多操作。它们可以分为两大类。

*  filter、map和limit可以连成一条流水线
 *  collect触发流水线执行并关闭它

可以连接起来的操作称为中间操作，关闭流的操作称为终端操作。

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>类型</th> 
   <th>返回类型</th> 
   <th>使用的类型/函数式接口</th> 
   <th>函数描述符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>filter</td> 
   <td>中间</td> 
   <td><code>Stream&lt;T&gt;</code></td> 
   <td><code>Predicate&lt;T&gt;</code></td> 
   <td>T-&gt;boolean</td> 
  </tr> 
  <tr> 
   <td>distinct</td> 
   <td>中间<br>(有状态-无界)</td> 
   <td><code>Stream&lt;T&gt;</code></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>skip</td> 
   <td>中间<br>(有状态-有界)</td> 
   <td><code>Stream&lt;T&gt;</code></td> 
   <td>long</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>limit</td> 
   <td>中间<br>(有状态-有界)</td> 
   <td><code>Stream&lt;T&gt;</code></td> 
   <td>long</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>map</td> 
   <td>中间</td> 
   <td><code>Stream&lt;R&gt;</code></td> 
   <td>Function</td> 
   <td>T-&gt;R</td> 
  </tr> 
  <tr> 
   <td>flatMap</td> 
   <td>中间</td> 
   <td><code>Stream&lt;R&gt;</code></td> 
   <td><code>Function&lt;T,Stream&lt;R&gt;&gt;</code></td> 
   <td><code>T-&gt;Stream&lt;R&gt;</code></td> 
  </tr> 
  <tr> 
   <td>sorted</td> 
   <td>中间<br>(有状态-无界)</td> 
   <td><code>Stream&lt;T&gt;</code></td> 
   <td><code>Comparator&lt;T&gt;</code></td> 
   <td>(T,T)-&gt;int</td> 
  </tr> 
  <tr> 
   <td>anyMatch</td> 
   <td>终端</td> 
   <td>boolean</td> 
   <td><code>Predicate&lt;T&gt;</code></td> 
   <td>T-&gt;boolean</td> 
  </tr> 
  <tr> 
   <td>noneMatch</td> 
   <td>终端</td> 
   <td>boolean</td> 
   <td><code>Predicate&lt;T&gt;</code></td> 
   <td>T-&gt;boolean</td> 
  </tr> 
  <tr> 
   <td>allMatch</td> 
   <td>终端</td> 
   <td>boolean</td> 
   <td><code>Predicate&lt;T&gt;</code></td> 
   <td>T-&gt;boolean</td> 
  </tr> 
  <tr> 
   <td>findAny</td> 
   <td>终端</td> 
   <td><code>Optional&lt;T&gt;</code></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>findFirst</td> 
   <td>终端</td> 
   <td><code>Optional&lt;T&gt;</code></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>forEach</td> 
   <td>终端</td> 
   <td>void</td> 
   <td><code>Consumer&lt;T&gt;</code></td> 
   <td>T-&gt;void</td> 
  </tr> 
  <tr> 
   <td>collect</td> 
   <td>终端</td> 
   <td>R</td> 
   <td><code>Collector&lt;T,A,R&gt;</code></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>reduce</td> 
   <td>终端<br>(有状态-有界)</td> 
   <td><code>Optional&lt;T&gt;</code></td> 
   <td><code>BinaryOperator&lt;T&gt;</code></td> 
   <td>(T,T)-&gt;T</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>终端</td> 
   <td>long</td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

# 中间操作 #

诸如filter或sorted等中间操作会返回另一个流。这让多个操作可以连接起来形成一个查询。重要的是，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理—他们很懒。

# 筛选与切片 #

filter方法，该操作会接受一个谓词（一个返回boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。

distinct方法，返回一个元素各异（根据所生成元素的hashCode和equals方法实现）的流。

limit(n)方法，该方法会返回一个不超过给定长度的流。

skip(n)方法，返回一个扔掉了前n个元素的流。如果流中元素不足n个，则返回一个空流。

# 查找和匹配 #

anyMatch方法可以回答“流中是否有一个元素能匹配给定的谓词”。anyMatch方法返回一个boolean，因此是一个终端操作。

boolean b=menu.stream().anyMatch(Dish::isVegetarian)

allMatch方法检查谓词是否匹配所有元素

noneMatch如果没有匹配的返回true，有一个匹配就返回false

anyMatch、allMatch和noneMatch这三个操作都用到了我们所谓的短路。

findAny方法将返回当前流中的任意元素。

Optional<Dish> dish=menu.stream()
                    .filter(Dish::isVegetarian)
                    .findAny();

Optional类（java.util.Optional）是一个容器类，代表一个值存在或不存在。在上面代码中，findAny可能什么元素都没有找到。

Optional中的方法

*  isPresent():Optional包含值的时候返回true，否则返回false
 *  ifPresent(Consumer block):会在值存在的时候执行给定的代码块，不存在就什么都不做
 *  T get()会在值存在时返回值，否则抛出一个NoSuchElement异常
 *  T orElse(T other)会在值存在时返回值，否则返回一个默认值

menu.stream()
        .filter(Dish::isVegetarian)
        .findAny()
        .ifPresent(d->System.out.println(d.getName));

查找第一个元素

findFirst找到第一个元素

关于findAny和findFirst。找到第一个元素在并行上限制更多，如果你不关心返回的元素是哪个，请使用findAny，因为它在使用并行流时限制较少。

# 归约 #

将流中所有元素反复结合起来，得到一个值。这样的查询可以被归类为归约操作（将流归约成一个值）。

元素求和

之前的方式

int sum=0;
    for(int x:numbers){
        sum+=x;
    }

这段代码中有两个参数

*  总和变量的初始值，在这里是0
 *  将列表中所有元素结合在一起的操作，在这里是+

int sum=numbers.stream().reduce(0,(a,b)->a+b);
    int sum=numbers.stream().reduce(0,Integer::sum);

reduce接收两个参数：

*  一个初始值，这里是0
 *  一个BinaryOperator来将两个元素结合起来产生一个新值。

int product=numbers.stream().reduce(1,(a,b)-a*b);

Lambda反复结合每个元素，直到流被归约成一个值。

比如，0,5,3,9

首先，0作为Lambda(a)的第一个参数，从流中获得4作为第二个参数（b）。0+4得到4，它成了新的累积值。然后在用累积值和流中下一个元素5调用Lambda，产生新的累积值9.接下来，再用累积值和下一个元素3调用Lambda，得到12.最后，用12和流中最后一个元素9调用Lambda，得到最终结果21.

无初始值

Optional<Integer> sum=numbers.stream().reduce((a,b)->a+b);

最大值和最小值

reduce接受两个参数

*  一个初始值
 *  一个Lambda把两个流元素结合起来并产生一个新值

Optional<Integer> max=numbers.stream().reduce(Integer::max);
    Optional<Integer> max=numbers.stream().reduce((x,y)->x<y?x:y);

怎样用map和reduce方法数一数流中有多少个菜呢？

答案：可以把流中每个元素都映射成数字1，然后用reduce求和。这相当于按顺序数流中的元素个数。

int count=menu.stream()
            .map(d->1)
            .reduce(0,(a,b)->a+b);

map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名，因为它很容易并行化。

归约方法的优势与并行化

使用reduce的好处在于，这里的迭代被内部迭代抽象掉了，这让内部实现得以选择并行执行reduce操作。而迭代求和例子要更新共享变量sum，这不是那么容易并行化的。如果你加入了同步，很可能会发现线程竞争抵消了并行本应带来的性能提升！这种计算的并行化需要另一种办法：将输入分块，分块求和，最后再合并起来。但这样的话代码看起来就完全不一样了。可变的累加器模式对于并行化来说是死路一条。你需要一种新的模式，这正是reduce所提供的。使用流来对所有的元素并行求和时，你的代码几乎不用修改：stream()换成了parallelStream()

int sum=numbers.parallelStream().reduce(0,Integer::sum);

但要并行执行这段代码也要付出一定代价，传递给reduce的Lambda不能更改状态（如实例变量），而且操作必须满足结合律才可以按任意顺序执行。

## 流操作：无状态和有状态 ##

诸如map或filter等操作会从输入流中获取每一个元素，并在输出流中得到0或1个结果。这些操作一般都是无状态的：它们没有内部状态（假设用户提供的Lambda或方法引用没有内部可变状态）。

但诸如reduce、sum、max等操作需要内部状态来积累。在上面的情况下，内部状态很小。在我们的例子里就是一个int或double。不管流中有多少元素要处理，内部状态都是有界的。

相反，诸如sort或distinct等操作一开始都和filter和map差不多—都是接受一个流，再生成一个流（中间操作），但有一个关键的区别。从流中排序和删除重复项时都需要知道先前的历史。例如，排序要求所有元素都放入缓冲区后才能给输出流加入一个项目，这一操作的存储要求是无界的。要是流比较大或是无限流的，就可能会有问题（把质数流倒序会做什么呢？它应当返回最大的质数，但数学告诉我们它不存在）。我们把这些操作叫作有状态操作。

## 映射 ##

可以使用map和flatMap提取或转换流中的元素  
Arrays.stream()方法可以接受一个数组并产生一个流

flatMap可以将各个生成流扁平化为单个流

List<String> uniqueCharacters=
        words.stream()
            .map(w->w.split(""))
            .flatMap(Arrays::stream)
            .distinct()
            .collect(Collectors.toList());

flatMap方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流。

需求：给定两个数字列表，如何返回所有的数对呢？例如，给定列表\[1,2,3\]和列表\[3,4\]，应该返回\[(1,3),(1,4),(2,3),(2,4),(3,3),(3,4)\]

List<Integer> numbers1=Arrays.asList(1,2,3);
    List<Integer> numbers2=Arrays.asList(3,4);
    List<int[]> pairs=
        numbers1.stream()
        .flatMap(i->numbers2.stream()
                 .map(j->new int[]{i,j}))
        .collect(toList());