在前面我们简朴先容了lambda表达式，Java8旨在辅佐措施员写出更好的代码， 其对焦点类库的改造也是要害的一部门，Stream是Java8种处理惩罚荟萃的抽象观念， 它可以指定你但愿对荟萃的操纵，可是执行操纵的时间交给详细实现来抉择。

为什么需要Stream?

Java语言中荟萃是利用最多的API，险些每个Java措施城市用到荟萃操纵， 这里的Stream和IO中的Stream差异，它提供了对荟萃操纵的加强，极大的提高了操纵荟萃工具的便利性。

荟萃对付大大都编程任务而言都是根基的，为了表明荟萃是怎么事情，我们想象一下当下最火的外卖APP， 当我们点菜的时候需要凭据间隔、价值、销量等举办排序后筛选出本身满足的菜品。 你大概想选择间隔本身最近的一家店肆点菜，尽量用荟萃可以完成这件事，但荟萃的操纵远远算不上完美。

如果让你编写上面示例中的代码，你大概会写出如下：

// 店肆属性
public class Property {
    String  name;
    // 间隔，单元:米
    Integer distance;
    // 销量，月售
    Integer sales;
    // 价值，这里简朴起见就写一个级别代表价值段
    Integer priceLevel;
    public Property(String name, int distance, int sales, int priceLevel) {
        this.name = name;
        this.distance = distance;
        this.sales = sales;
        this.priceLevel = priceLevel;
    }
    // getter setter 省略
}

我想要筛选间隔我最近的店肆，你大概会写下这样的代码：

public static void main(String[] args) {
    Property p1 = new Property("叫了个鸡", 1000, 500, 2);
    Property p2 = new Property("张三丰饺子馆", 2300, 1500, 3);
    Property p3 = new Property("永和大王", 580, 3000, 1);
    Property p4 = new Property("肯德基", 6000, 200, 4);
    List<Property> properties = Arrays.asList(p1, p2, p3, p4);
    Collections.sort(properties, (x, y) -> x.distance.compareTo(y.distance));
    String name = properties.get(0).name;
    System.out.println("间隔我最近的店肆是:" + name);
}

这里也利用了部门lambda表达式，在Java8之前你大概写的更疾苦一些。 要是要处理惩罚大量元素又该怎么办呢？为了提高机能，你需要并行处理惩罚，并操作多核架构。 但写并行代码比用迭代器还要巨大，并且调试起来也够受的！

但Stream中操纵这些对象虽然长短常简朴的，小试牛刀:

// Stream操纵
String name2 = properties.stream()
                .sorted(Comparator.comparingInt(x -> x.distance))
                .findFirst()
                .get().name;
System.out.println("间隔我最近的店肆是:" + name);

新的API对所有的荟萃操纵都提供了生成流操纵的要领，写的代码也行云流水，我们很是简朴的就筛选了离我最近的店肆。 在后头我们继承讲授Stream更多的特性和玩法。

外部迭代和内部迭代

当你处理惩罚集适时，凡是会对它举办迭代，然后处理惩罚返回的每个元素。好比我想看看月销量大于1000的店肆个数。

利用for轮回举办迭代

int count = 0;
for (Property property : properties) {
    if(property.sales > 1000){
        count++;
    }
}

上面的操纵是可行的，可是当每次迭代的时候你需要些许多反复的代码。将for轮回修改为并行执行也很是坚苦， 需要修改每个for的实现。

从荟萃背后的道理来看，for轮回封装了迭代的语法糖，首先挪用iterator要领，发生一个Iterator工具， 然后节制整个迭代，这就是外部迭代。迭代的进程通过挪用Iterator工具的hasNext和next要领完成。

利用迭代器举办计较

int count = 0;
Iterator<Property> iterator = properties.iterator();
while(iterator.hasNext()){
    Property property = iterator.next();
    if(property.sales > 1000){
        count++;
    }
}

而迭代器也是有问题的。它很难抽象出未知的不能操纵；另外它本质上照旧串行化的操纵，总体来看利用 for轮回会将行为和要领等量齐观。

另一种步伐是利用内部迭代完成，properties.stream()该要领返回一个Stream而不是迭代器。

利用内部迭代举办计较

long count2 = properties.stream()
                .filter(p -> p.sales > 1000)
                .count();

上述代码是通过Stream API完成的，我们可以把它领略为2个步调：

1. 找出所有销量大于1000的店肆
2. 计较出店肆个数

为了找出销量大于1000的店肆，需要先做一次过滤：filter，你可以看看这个要领的入参就是前面讲到的Predicate断言型函数式接口， 测试一个函数完成后，返回值为boolean。 由于Stream API的气势气魄，我们没有改变荟萃的内容，而是描写了Stream的内容，最终挪用count()要领计较出Stream 里包括了几多个过滤之后的工具，返回值为long。

建设Stream