Java8新特性整理之流的介绍与使用（三）

你的名字 2022-05-31 04:42 171阅读 0赞

## 流是什么 ##

官方定义：**支持顺序和并行聚合操作的元素序列。**

这里有几个关键词，顺序、并行、聚合、元素序列。

所谓顺序就是单线程顺序执行，并行就是多线程分解执行，聚合就是将顺序或并行执行的结果计算后得出最终结果，元素序列则是将数据源（数组，文件，集合等）流化后的数据结构。

## 流与集合 ##

上面说的还是有些不明朗，下面结合Java中的集合（Collection）来进一步解释流。

Java现有的集合概念和新的流概念都提供了接口，来配合代表元素型有序值的数据接口。所  
谓有序，就是说我们一般是按顺序取用值，而不是随机取用的。

举例来说，如果要观看苍老师课程，有两种方式，一种是下载到本地观看，另一种是在线观看。而下载观看的方式等待下载的时间比较长同时占用磁盘空间较大；在线观看就比较快了，可以只观看高潮部分，而且只占用很少的缓冲空间。

对比来看，苍老师课程是字节或帧的数据结构，用集合方式处理的话（下载到本地观看）需要将整个结构中的数据都计算一遍，而用流的方式处理的话（在线观看高潮部分），只需要计算某个字节（帧）范围。

**区别**：

*  集合是内存数据结构，可以增删元素，而流是概念上固定的数据结构，不可以增删元素，只进行计算。
 *  集合可以多次遍历，而流只能遍历一次（下一次需要从数据源再获得一个新的流）。
 *  集合使用外部迭代（如for-each）,而流使用内部迭代（流内部帮你把迭代做了）。
 *  关键区别，集合是有界的，流可以是无界的。

## 流的操作 ##

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

*  中间操作，诸如filter或sorted等中间操作会返回另一个流，即返回值为Stream的方法。
 *  终端操作，终端操作会从流的流水线生成结果，其结果是任何不是流的值，即返回值不为Stream的方法。

## 使用流 ##

流的使用一般包括三件事：  
\- 一个数据源（如集合）来执行一个查询；  
\- 一个中间操作链，形成一条流的流水线；  
\- 一个终端操作，执行流水线，并能生成结果。

下面介绍下流中的常用方法：

### 中间操作常用方法 ###

**filter方法：**

接受一个返回boolean的Lambda表达式的参数，返回由流元素组成的流，该流与给定谓词匹配。

**distinct方法：**

返回由不同对象组成的流，内部使用对象的equals方法比较是否相同。

**skip方法:**

接受一个long类型的参数n，表示头n个数，返回由剩下的元素组成的流，如果流容器中的元素比n小，则返回空的流。

**limit方法：**

接受一个long类型的参数maxSize，表示限制的最大数量，返回一个不超过maxSize长度的流。

**sorted方法：**

接受一个Comparator类型的参数，表示函数引用作为参数，返回根据Comparator接口中定义的行为组成排序后的流。

**map方法：**

接收一个函数（方法引用）作为参数，返回一个流，由将给定函数应用于该流元素的结果组成。

### 终端操作常用方法 ###

**anyMatch方法：**

流中是否有一个元素能匹配给定的谓词

**allMatch方法：**

流中的元素是否都能匹配给定的谓词。

**noneMatch方法：**

和allMatch相对的是noneMatch。它可以确保流中没有任何元素与给定的谓词匹配。

**findAny方法：**

返回当前流中的任意元素。

**findFirst方法：**

找到第一个元素。

**forEach方法：**

遍历流中的每一个元素。

**collect方法：**

接受一个`Collectors`类中的方法（收集器）作为参数，返回一个归约的结果。

collect是一个终端操作，它接受的参数是将流中元素累积到汇总结果的各种方式（称为收集器）。

**reduce方法：**

把一个流中的元素反复结合起来，返回一个归约的结果（将流归约成一个值）。

**count方法：**

返回流中的元素个数。

### 举个例子 ###

前面都是理论知识，下面举个栗子：

Dish.java

public class Dish { 
        private final String name;
        private final boolean vegetarian; // 是否是素食
        private final int calories; // 卡路里
        private final Type type;  // 盘子装的菜的类型
    
        public Dish(String name, boolean vegetarian, int calories, Type type) {
            this.name = name;
            this.vegetarian = vegetarian;
            this.calories = calories;
            this.type = type;
        }
    
        public String getName() {
            return name;
        }
    
        public boolean isVegetarian() {
            return vegetarian;
        }
    
        public int getCalories() {
            return calories;
        }
    
        public Type getType() {
            return type;
        }
    
        public enum Type {
            MEAT, FISH, OTHER;
        }
    }

初始化数据：

List<Dish> menu = Arrays.asList(
                    new Dish("pork", false, 800, Dish.Type.MEAT),
                    new Dish("beef", false, 700, Dish.Type.MEAT),
                    new Dish("chicken", false, 400, Dish.Type.MEAT),
                    new Dish("french fries", true, 530, Dish.Type.OTHER),
                    new Dish("rice", true, 350, Dish.Type.OTHER),
                    new Dish("season fruit", true, 120, Dish.Type.OTHER),
                    new Dish("pizza", true, 550, Dish.Type.OTHER),
                    new Dish("prawns", false, 300, Dish.Type.FISH),
                    new Dish("salmon", false, 450, Dish.Type.FISH));

使用：

List<String> dishes = menu.stream()
                    .filter(dish -> dish.getCalories() > 300)   // 从流中过滤元素
                    .map(Dish::getName)                         // 提取元素
                    .limit(3)                                   // 截断流，使其元素不超过给定的数量
                    .collect(toList());                         // 将流转换为列表

上面例子会取出卡路里大于300的前三个Dish的名字列表。

## 数值流 ##

下面来谈谈流的特化 – **数值流**

对前面Dish中的菜的卡路里求和：

int calories = menu.stream()
                .map(Dish::getCalories)
                .reduce(0, Integer::sum);

reduce方法第一个参数表示初始值，第二个参数代表接受两个参数的函数，Integer的sum方法接受两个参数，所以可以传递一个方法引用。

乍一看，这个方法好像没什么问题，输出结果也正确。

但你其实忽略了一个问题，map方法会返回一个Stream类型的流，其中T是引用类型，所以它有一个暗含的装箱成本，会造成性能的降低。

怎么解决上面的问题呢？

Java 8引入了三个原始类型特化流接口来解决这个问题：IntStream、DoubleStream和LongStream，分别将流中的元素特化为int、long和double，从而避免了暗含的装箱成本。每个接口都带来了进行常用数值归约的新方法，比如对数值流求和的sum，找到最大元素的max。

现在改正上面的代码：

int calories = menu.stream()
                .mapToInt(Dish::getCalories)
                .sum();

当然，如有你需要转换回对象流，则需要调用原始类型特化流接口的`boxed`方法进行装箱。

## 什么是并行流 ##

并行流就是一个把内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

这样一来，你就可以自动把给定操作的工作负荷分配给多核处理器的所有内核，让它们都忙起来。

可以通过对收集源调用`parallelStream`或`parallel`方法来把集合转换为并行流：

int calories = menu.parallelStream()
                    .mapToInt(Dish::getCalories)
                    .sum();

或

int calories = menu.stream()
                    .parallel()
                    .mapToInt(Dish::getCalories)
                    .sum();

下表按照可分解性总结了一些流数据源适不适于并行。

<table> 
 <thead> 
  <tr> 
   <th>源</th> 
   <th>可分解性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArrayList</td> 
   <td>极佳</td> 
  </tr> 
  <tr> 
   <td>LinkedList</td> 
   <td>差</td> 
  </tr> 
  <tr> 
   <td>IntStream.range</td> 
   <td>极佳</td> 
  </tr> 
  <tr> 
   <td>Stream.iterate</td> 
   <td>差</td> 
  </tr> 
  <tr> 
   <td>HashSet</td> 
   <td>好</td> 
  </tr> 
  <tr> 
   <td>TreeSet</td> 
   <td>好</td> 
  </tr> 
 </tbody> 
</table>